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 #include "du_e2ap_msg_hdl.h"
 107
 108 #ifdef O1_ENABLE
 109 #include "CmInterface.h"
 110 extern StartupConfig g_cfg;
 111 #endif
 112
 113 DuCfgParams duCfgParam;
 114
 115 /******************************************************************
 116  *
 117  * @brief Function to fetch lcId based on DRB Id
 118  *
 119  * @details
 120  *
 121  *    Function : fetchLcId
 122  *
 123  *    @params[in] drbId
 124  *
 125  *    Functionality: Function to fetch lcId based on DRB Id
 126  *
 127  * Returns: lcId - SUCCESS
 128  *          RFAILED - FAILURE
 129  *****************************************************************/
 130
 131 uint8_t fetchLcId(uint8_t drbId)
 132 {
 133    uint8_t cellIdx = 0, ueIdx = 0, lcIdx = 0, numLcs = 0, lcId = 0;
 134
 135    for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
 136    {
 137       for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
 138       {
 139          if(duCb.actvCellLst[cellIdx] != NULLP)
 140          {
 141             numLcs = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.numLcs;
 142             for(lcIdx = 0; lcIdx < numLcs; lcIdx++)
 143             {
 144                if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.rlcLcCfg[lcIdx].rbId == drbId && \
 145                   duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.rlcLcCfg[lcIdx].rbType == RB_TYPE_DRB)
 146                {
 147                   lcId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.rlcLcCfg[lcIdx].lcId;
 148                   return lcId;
 149                }
 150             }
 151          }
 152       }
 153    }
 154    DU_LOG("\nERROR   -->  DU_APP: fetchLcId() failed for drbId %d", drbId);
 155    return RFAILED;
 156 }
 157
 158 /************************************************************************
 159  *
 160  * @brief Converts enum values into actual value of Poll retransmit timer
 161  *
 162  * @details
 163  *
 164  *    Function : getPollPdu
 165  *
 166  *    Functionality: Converts enum values into actual value of poll
 167  *    retransmit timer
 168  *
 169  * @params[in] Enum value of pollPdu
 170  * @return Actual value of pollPdu
 171  *
 172  * **********************************************************************/
 173
 174 uint16_t getPollRetxTmr(uint8_t pollRetxTmrCfg)
 175 {
 176    uint16_t pollRetxTmr;
 177
 178    /* All values of poll retx timer are at interval of 5ms.
 179     * This is valid upto 250ms
 180     * Hence converting the enum value to actual value by multiplying it to 5
 181     */
 182    if(pollRetxTmrCfg <= T_PollRetransmit_ms250)
 183       pollRetxTmr = (pollRetxTmrCfg + 1) * 5;
 184    else
 185    {
 186       switch(pollRetxTmrCfg)
 187       {
 188          case T_PollRetransmit_ms300:
 189             pollRetxTmr = 300;
 190             break;
 191          case T_PollRetransmit_ms350:
 192             pollRetxTmr = 350;
 193             break;
 194          case T_PollRetransmit_ms400:
 195             pollRetxTmr = 400;
 196             break;
 197          case T_PollRetransmit_ms450:
 198             pollRetxTmr = 450;
 199             break;
 200          case T_PollRetransmit_ms500:
 201             pollRetxTmr = 500;
 202             break;
 203          case T_PollRetransmit_ms800:
 204             pollRetxTmr = 800;
 205             break;
 206          default:
 207             DU_LOG("\nERROR  -->  F1AP: Invalid value of Poll Retransmit timer");
 208             pollRetxTmr = 0;
 209       }
 210    }
 211    return pollRetxTmr;
 212 }
 213
 214 /*******************************************************************
 215  *
 216  * @brief Converts enum values into actual value of PollPdu
 217  *
 218  * @details
 219  *
 220  *    Function : getPollPdu
 221  *
 222  *    Functionality: Converts enum values into actual value of PollPdu
 223  *
 224  * @params[in] Enum value of pollPdu
 225  * @return Actual value of pollPdu
 226  *
 227  * ****************************************************************/
 228 int32_t getPollPdu(uint8_t pollPduCfg)
 229 {
 230    int32_t pollPdu;
 231    switch(pollPduCfg)
 232    {
 233       case PollPDU_p4:
 234          pollPdu = 4;
 235          break;
 236       case PollPDU_p8:
 237          pollPdu = 8;
 238          break;
 239       case PollPDU_p16:
 240          pollPdu = 16;
 241          break;
 242       case PollPDU_p32:
 243          pollPdu = 32;
 244          break;
 245       case PollPDU_p64:
 246          pollPdu = 64;
 247          break;
 248       case PollPDU_p128:
 249          pollPdu = 128;
 250          break;
 251       case PollPDU_p256:
 252          pollPdu = 256;
 253          break;
 254       case PollPDU_p512:
 255          pollPdu = 512;
 256          break;
 257       case PollPDU_p1024:
 258          pollPdu = 1024;
 259          break;
 260       case PollPDU_p2048:
 261          pollPdu = 2048;
 262          break;
 263       case PollPDU_p4096:
 264          pollPdu = 4096;
 265          break;
 266       case PollPDU_p6144:
 267          pollPdu = 6144;
 268          break;
 269       case PollPDU_p8192:
 270          pollPdu = 8192;
 271          break;
 272       case PollPDU_p12288:
 273          pollPdu = 12288;
 274          break;
 275       case PollPDU_p16384:
 276          pollPdu = 16384;
 277          break;
 278       case PollPDU_p20480:
 279          pollPdu = 20480;
 280          break;
 281       case PollPDU_p24576:
 282          pollPdu = 24576;
 283          break;
 284       case PollPDU_p28672:
 285          pollPdu = 28672;
 286          break;
 287       case PollPDU_p32768:
 288          pollPdu = 32768;
 289          break;
 290       case PollPDU_p40960:
 291          pollPdu = 40960;
 292          break;
 293       case PollPDU_p49152:
 294          pollPdu = 49152;
 295          break;
 296       case PollPDU_p57344:
 297          pollPdu = 57344;
 298          break;
 299       case PollPDU_p65536:
 300          pollPdu = 65536;
 301          break;
 302       case PollPDU_infinity:
 303          pollPdu = -1;
 304          break;
 305       default:
 306          DU_LOG("\nERROR  -->  F1AP: Invalid value of poll pdu");
 307          pollPdu = 0;
 308          break;
 309    }
 310    return pollPdu;
 311 }
 312
 313 /*******************************************************************
 314  *
 315  * @brief Converts enum values into actual value of poll bytes
 316  *
 317  * @details
 318  *
 319  *    Function : getPollByte
 320  *
 321  *    Functionality: Converts enum values into actual value of pollBytes
 322  *
 323  * @params[in] Enum value
 324  * @return Actual value
 325  *
 326  * ****************************************************************/
 327 int32_t getPollByte(uint16_t pollBytesCfg)
 328 {
 329    int32_t pollBytes;
 330    switch(pollBytesCfg)
 331    {
 332       case PollByte_kB1:
 333          pollBytes = 1000;
 334          break;
 335       case PollByte_kB2:
 336          pollBytes = 2000;
 337          break;
 338       case PollByte_kB5:
 339          pollBytes = 5000;
 340          break;
 341       case PollByte_kB8:
 342          pollBytes = 8000;
 343          break;
 344       case PollByte_kB10:
 345          pollBytes = 10000;
 346          break;
 347       case PollByte_kB15:
 348          pollBytes = 15000;
 349          break;
 350       case PollByte_kB25:
 351          pollBytes = 25000;
 352          break;
 353       case PollByte_kB50:
 354          pollBytes = 50000;
 355          break;
 356       case PollByte_kB75:
 357          pollBytes = 75000;
 358          break;
 359       case PollByte_kB100:
 360          pollBytes = 100000;
 361          break;
 362       case PollByte_kB125:
 363          pollBytes = 125000;
 364          break;
 365       case PollByte_kB250:
 366          pollBytes = 250000;
 367          break;
 368       case PollByte_kB375:
 369          pollBytes = 375000;
 370          break;
 371       case PollByte_kB500:
 372          pollBytes = 500000;
 373          break;
 374       case PollByte_kB750:
 375          pollBytes = 750000;
 376          break;
 377       case PollByte_kB1000:
 378          pollBytes = 1000000;
 379          break;
 380       case PollByte_kB1250:
 381          pollBytes = 1250000;
 382          break;
 383       case PollByte_kB1500:
 384          pollBytes = 1500000;
 385          break;
 386       case PollByte_kB2000:
 387          pollBytes = 2000000;
 388          break;
 389       case PollByte_kB3000:
 390          pollBytes = 3000000;
 391          break;
 392       case PollByte_kB4000:
 393          pollBytes = 4000000;
 394          break;
 395       case PollByte_kB4500:
 396          pollBytes = 4500000;
 397          break;
 398       case PollByte_kB5000:
 399          pollBytes = 5000000;
 400          break;
 401       case PollByte_kB5500:
 402          pollBytes = 5500000;
 403          break;
 404       case PollByte_kB6000:
 405          pollBytes = 6000000;
 406          break;
 407       case PollByte_kB6500:
 408          pollBytes = 6500000;
 409          break;
 410       case PollByte_kB7000:
 411          pollBytes = 7000000;
 412          break;
 413       case PollByte_kB7500:
 414          pollBytes = 7500000;
 415          break;
 416       case PollByte_mB8:
 417          pollBytes = 8000000;
 418          break;
 419       case PollByte_mB9:
 420          pollBytes = 9000000;
 421          break;
 422       case PollByte_mB10:
 423          pollBytes = 10000000;
 424          break;
 425       case PollByte_mB11:
 426          pollBytes = 11000000;
 427          break;
 428       case PollByte_mB12:
 429          pollBytes = 12000000;
 430          break;
 431       case PollByte_mB13:
 432          pollBytes = 13000000;
 433          break;
 434       case PollByte_mB14:
 435          pollBytes = 14000000;
 436          break;
 437       case PollByte_mB15:
 438          pollBytes = 15000000;
 439          break;
 440       case PollByte_mB16:
 441          pollBytes = 16000000;
 442          break;
 443       case PollByte_mB17:
 444          pollBytes = 17000000;
 445          break;
 446       case PollByte_mB18:
 447          pollBytes = 18000000;
 448          break;
 449       case PollByte_mB20:
 450          pollBytes = 20000000;
 451          break;
 452       case PollByte_mB25:
 453          pollBytes = 25000000;
 454          break;
 455       case PollByte_mB30:
 456          pollBytes = 30000000;
 457          break;
 458       case PollByte_mB40:
 459          pollBytes = 40000000;
 460          break;
 461       case PollByte_infinity:
 462          pollBytes = -1;
 463          break;
 464       default:
 465          DU_LOG("\nERROR  -->  F1AP: Invalid value of poll bytes");
 466          pollBytes = 0;
 467    }
 468    return pollBytes;
 469 }
 470
 471 /*******************************************************************
 472  *
 473  * @brief Converts enum values into actual value of maxRetx
 474  *
 475  * @details
 476  *
 477  *    Function : getMaxRetx
 478  *
 479  *    Functionality: Converts enum values into actual value of maxRetx
 480  *
 481  * @params[in] Enum value
 482  * @return Actual value
 483  *
 484  * ****************************************************************/
 485 uint8_t getMaxRetx(uint8_t maxRetxCfg)
 486 {
 487    uint8_t maxRetx;
 488    switch(maxRetxCfg)
 489    {
 490       case UL_AM_RLC__maxRetxThreshold_t1:
 491          maxRetx = 1;
 492          break;
 493       case UL_AM_RLC__maxRetxThreshold_t2:
 494          maxRetx = 2;
 495          break;
 496       case UL_AM_RLC__maxRetxThreshold_t3:
 497          maxRetx = 3;
 498          break;
 499       case UL_AM_RLC__maxRetxThreshold_t4:
 500          maxRetx = 4;
 501          break;
 502       case UL_AM_RLC__maxRetxThreshold_t6:
 503          maxRetx = 6;
 504          break;
 505       case UL_AM_RLC__maxRetxThreshold_t8:
 506          maxRetx = 8;
 507          break;
 508       case UL_AM_RLC__maxRetxThreshold_t16:
 509          maxRetx = 16;
 510          break;
 511       case UL_AM_RLC__maxRetxThreshold_t32:
 512          maxRetx = 32;
 513          break;
 514       default:
 515          DU_LOG("\nERROR  -->  F1AP: Invalid configuration for Max retransmission threshold");
 516          maxRetx = 0;
 517    }
 518    return maxRetx;
 519 }
 520
 521 /*******************************************************************
 522  * @brief Converts enum values into actual value of reassembly timer
 523  *
 524  * @details
 525  *
 526  *    Function : getReAsmblTmr
 527  *
 528  *    Functionality: Converts enum values into actual value of reassembly
 529  *    timer
 530  *
 531  * @params[in] Enum value of reassembly timer
 532  * @return Actual value of reassembly timer
 533  *
 534  * **********************************************************************/
 535
 536 int8_t getReAsmblTmr(uint8_t reAsmblTmrCfg)
 537 {
 538    int8_t reAsmblTmr = 0;
 539
 540    if(reAsmblTmrCfg == T_Reassembly_ms0)
 541    {
 542       reAsmblTmr = 0;
 543    }
 544    else if(reAsmblTmrCfg >= T_Reassembly_ms5 || reAsmblTmrCfg <= T_Reassembly_ms100)
 545    {
 546      /* All values of re assembly timer are at interval of 5ms.
 547       * This is valid upto 100ms
 548       * Hence converting the enum value to actual value by multiplying it to 5
 549       */
 550       reAsmblTmr = reAsmblTmrCfg * 5;
 551    }
 552    else if(reAsmblTmrCfg >= T_Reassembly_ms110 || reAsmblTmrCfg <= T_Reassembly_ms200)
 553    {
 554      /* All values of re assembly timer are at interval of 10ms.
 555       * This is valid upto 200ms
 556       * since enum value starts from 20 for 100ms, subtracting 10 and
 557       * converting the enum value to actual value by multiplying it to 10
 558       */
 559       reAsmblTmr = ((reAsmblTmrCfg-10) * 10);
 560    }
 561    else
 562    {
 563       DU_LOG("\nERROR  -->  F1AP : Invalid value of Re Assembly timer %d", reAsmblTmrCfg);
 564       reAsmblTmr = -1;
 565    }
 566    return reAsmblTmr;
 567 }
 568
 569 /************************************************************************
 570  *
 571  * @brief Converts enum values into actual value of status prohibit timer
 572  *
 573  * @details
 574  *
 575  *    Function : getStatProhTmr
 576  *
 577  *    Functionality: Converts enum values into actual value of status prohibit
 578  *    timer
 579  *
 580  * @params[in] Enum value of status prohibit timer
 581  * @return Actual value of status prohibit timer
 582  *
 583  * **********************************************************************/
 584
 585 int16_t getStatProhTmr(uint8_t statProhTmrCfg)
 586 {
 587    int16_t statProhTmr =0;
 588
 589    if(statProhTmrCfg == T_StatusProhibit_ms0)
 590    {
 591       statProhTmr = 0;
 592    }
 593    else if(statProhTmrCfg >= T_StatusProhibit_ms5 || statProhTmrCfg <= T_StatusProhibit_ms250)
 594    {
 595       /* All values of re assembly timer are at interval of 5ms.
 596        * This is valid upto 250ms
 597        * Hence converting the enum value to actual value by multiplying it to 5
 598        */
 599       statProhTmr = statProhTmrCfg * 5;
 600    }
 601    else
 602    {
 603       switch(statProhTmrCfg)
 604       {
 605          case T_StatusProhibit_ms300:
 606             statProhTmr = 300;
 607             break;
 608          case T_StatusProhibit_ms350:
 609             statProhTmr = 350;
 610             break;
 611          case T_StatusProhibit_ms400:
 612             statProhTmr = 400;
 613             break;
 614          case T_StatusProhibit_ms450:
 615             statProhTmr = 450;
 616             break;
 617          case T_StatusProhibit_ms500:
 618             statProhTmr = 500;
 619             break;
 620          case T_StatusProhibit_ms800:
 621             statProhTmr = 800;
 622             break;
 623          case T_StatusProhibit_ms1000:
 624             statProhTmr = 1000;
 625             break;
 626          case T_StatusProhibit_ms1200:
 627             statProhTmr = 1200;
 628             break;
 629          case T_StatusProhibit_ms1600:
 630             statProhTmr = 1600;
 631             break;
 632          case T_StatusProhibit_ms2000:
 633             statProhTmr = 2000;
 634             break;
 635          case T_StatusProhibit_ms2400:
 636             statProhTmr = 2400;
 637             break;
 638          default:
 639             DU_LOG("\nInvalid value of Status Prohibit timer %d", statProhTmrCfg);
 640             statProhTmr = -1;
 641             break;
 642       }
 643    }
 644    return statProhTmr;
 645 }
 646
 647 /*******************************************************************
 648 *
 649 * @brief Adding F1AP pdu to reserved pdu list
 650 *
 651 * @details
 652 *
 653 *    Function : addToReservedF1apPduList
 654 *
 655 *    Functionality: Adding F1AP pdu to reserved pdu list.
 656 *     These pdu are awaiting aknowledgment from CU
 657 *
 658 * @params[in] uint8_t transId, F1AP_PDU_t *f1apMsg
 659 *
 660 * @return ROK - success
 661 *         RFAILED - failure
 662 *
 663 * ****************************************************************/
 664
 665 void addToReservedF1apPduList(uint8_t transId, F1AP_PDU_t *f1apPdu)
 666 {
 667    CmLList         *node = NULLP;
 668    ReservedF1apPduInfo *pduInfo = NULLP;
 669    DU_ALLOC(pduInfo, sizeof(ReservedF1apPduInfo));
 670    if(pduInfo)
 671    {
 672       DU_ALLOC(node, sizeof(CmLList));
 673       if(node)
 674       {
 675          pduInfo->transId = transId;
 676          pduInfo->f1apMsg = (void*) f1apPdu;
 677
 678          node->node = (PTR)pduInfo;
 679          cmLListAdd2Tail(&duCb.reservedF1apPduList, node);
 680       }
 681    }
 682 }
 683
 684 /*******************************************************************
 685 *
 686 * @brief searching for F1AP pdu from ReservedF1apPduList
 687 *
 688 * @details
 689 *
 690 *    Function : searchFromReservedF1apPduList
 691 *
 692 *    Functionality: searching for F1AP pdu information
 693 *
 694 * @params[in] uint8_t transId
 695 *
 696 * @return pointer to F1AP_PDU_t
 697 *
 698 * ****************************************************************/
 699
 700 CmLList *searchFromReservedF1apPduList(uint8_t transId)
 701 {
 702    CmLList         *node;
 703    ReservedF1apPduInfo *f1apPdu;
 704    if(duCb.reservedF1apPduList.count)
 705    {
 706       CM_LLIST_FIRST_NODE(&duCb.reservedF1apPduList, node);
 707       while(node)
 708       {
 709          f1apPdu = (ReservedF1apPduInfo*)node->node;
 710          if(f1apPdu->transId == transId)
 711          {
 712             return node;
 713          }
 714          node = node->next;
 715       }
 716    }
 717    return NULL;
 718 }
 719
 720 /*******************************************************************
 721 *
 722 * @brief deleting F1AP pdu information from ReservedF1apPduList
 723 *
 724 * @details
 725 *
 726 *    Function : deleteFromReservedF1apPduList
 727 *
 728 *    Functionality: deleting pdu information from ReservedF1apPduList
 729 *
 730 * @params[in] CmLList *node
 731 *
 732 * @return void
 733 *
 734 * ****************************************************************/
 735
 736 void deleteFromReservedF1apPduList(CmLList *node)
 737 {
 738    ReservedF1apPduInfo *f1apPdu;
 739
 740    if(node != NULL)
 741    {
 742       f1apPdu = (ReservedF1apPduInfo *)node->node;
 743       cmLListDelFrm(&duCb.reservedF1apPduList, node);
 744       DU_FREE(f1apPdu, sizeof(ReservedF1apPduInfo));
 745       DU_FREE(node, sizeof(CmLList));
 746       node = NULL;
 747    }
 748 }
 749
 750 /*******************************************************************
 751  *
 752  * @brief Builds Uplink Info for NR
 753  *
 754  * @details
 755  *
 756  *    Function : BuildULNRInfo
 757  *
 758  *    Functionality: Building NR Uplink Info
 759  *
 760  * @params[in] NRFreqInfo_t *ulnrfreq
 761  * @return ROK     - success
 762  *         RFAILED - failure
 763  *
 764  * ****************************************************************/
 765 uint8_t BuildULNRInfo(NRFreqInfo_t *ulnrfreq)
 766 {
 767    uint8_t idx=0;
 768    ulnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 769                        fdd.ulNrFreqInfo.nrArfcn;
 770    ulnrfreq->freqBandListNr.list.count = 1;
 771    ulnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 772    DU_ALLOC(ulnrfreq->freqBandListNr.list.array,ulnrfreq->freqBandListNr.list.size);
 773    if(ulnrfreq->freqBandListNr.list.array == NULLP)
 774    {
 775       return RFAILED;
 776    }
 777    for(idx=0;idx<ulnrfreq->freqBandListNr.list.count;idx++)
 778    {
 779       DU_ALLOC(ulnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 780       if(ulnrfreq->freqBandListNr.list.array[idx] == NULLP)
 781       {
 782          return RFAILED;
 783       }
 784    }
 785    ulnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 786                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
 787                                                                  freqBand[0].nrFreqBand;
 788    ulnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 789    return ROK;
 790 }
 791 /*******************************************************************
 792  *
 793  * @brief Builds Downlink NR Info
 794  *
 795  * @details
 796  *
 797  *    Function : BuildDLNRInfo
 798  *
 799  *    Functionality: Building Downlink NR Info
 800  *
 801  * @params[in] NRFreqInfo_t *dlnrfreq
 802  * @return ROK     - success
 803  *         RFAILED - failure
 804  *
 805  * ****************************************************************/
 806 uint8_t BuildDLNRInfo(NRFreqInfo_t *dlnrfreq)
 807 {
 808    uint8_t idx=0;
 809    dlnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 810                        fdd.dlNrFreqInfo.nrArfcn;
 811    dlnrfreq->freqBandListNr.list.count = 1;
 812    dlnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 813    DU_ALLOC(dlnrfreq->freqBandListNr.list.array,dlnrfreq->freqBandListNr.list.size);
 814    if(dlnrfreq->freqBandListNr.list.array == NULLP)
 815    {
 816       return RFAILED;
 817    }
 818    for(idx=0;idx< dlnrfreq->freqBandListNr.list.count;idx++)
 819    {
 820       DU_ALLOC(dlnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 821       if(dlnrfreq->freqBandListNr.list.array[idx] == NULLP)
 822       {
 823          return RFAILED;
 824       }
 825    }
 826    dlnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 827                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
 828                                                                  freqBand[0].nrFreqBand;
 829    dlnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 830
 831    return ROK;
 832 }
 833
 834 /*******************************************************************
 835  *
 836  * @brief Builds NRCell ID
 837  *
 838  * @details
 839  *
 840  *    Function : BuildNrCellId
 841  *
 842  *    Functionality: Building the NR Cell ID
 843  *
 844  * @params[in] BIT_STRING_t *nrcell
 845  * @return ROK     - success
 846  *         RFAILED - failure
 847  *
 848  * ****************************************************************/
 849
 850 S16 BuildNrCellId(BIT_STRING_t *nrcell)
 851 {
 852    memset(nrcell->buf, 0, nrcell->size);
 853    nrcell->buf[4]   = duCfgParam.sib1Params.cellIdentity;
 854    nrcell->bits_unused = 4;
 855    return ROK;
 856 }
 857
 858 /*******************************************************************
 859  *
 860  * @brief Builds Nrcgi
 861  *
 862  * @details
 863  *
 864  *    Function : BuildNrcgi
 865  *
 866  *    Functionality: Building the PLMN ID and NR Cell id
 867  *
 868  * @params[in] NRCGI_t *nrcgi
 869  * @return ROK     - success
 870  *         RFAILED - failure
 871  *
 872  * ****************************************************************/
 873 uint8_t BuildNrcgi(NRCGI_t *nrcgi)
 874 {
 875    uint8_t ret;
 876    uint8_t byteSize = 5;
 877    /* Allocate Buffer Memory */
 878    nrcgi->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 879    DU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
 880    if(nrcgi->pLMN_Identity.buf == NULLP)
 881    {
 882       return RFAILED;
 883    }
 884    ret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 885          nrcgi->pLMN_Identity.buf); // Building PLMN function
 886    if(ret != ROK)
 887    {
 888       return RFAILED;
 889    }
 890    /*nrCellIdentity*/
 891    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
 892    DU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
 893    if(nrcgi->nRCellIdentity.buf == NULLP)
 894    {
 895       return RFAILED;
 896    }
 897    BuildNrCellId(&nrcgi->nRCellIdentity);
 898
 899    return ROK;
 900 }
 901 /*******************************************************************
 902  *
 903  * @brief Builds FiveGStac
 904  *
 905  * @details
 906  *
 907  *    Function : BuildFiveGSTac
 908  *
 909  *    Functionality: Building the FiveGSTac
 910  *
 911  * @params[in] OCTET_STRING_t *fivegsTac
 912  * @return ROK     - success
 913  *         RFAILED - failure
 914  *
 915  * ****************************************************************/
 916 uint8_t BuildFiveGSTac(Served_Cell_Information_t *servcell)
 917 {
 918    DU_ALLOC(servcell->fiveGS_TAC,sizeof(FiveGS_TAC_t));
 919    if(servcell->fiveGS_TAC == NULLP)
 920    {
 921       return RFAILED;
 922    }
 923    servcell->fiveGS_TAC->size = 3 * sizeof(uint8_t);
 924    DU_ALLOC(servcell->fiveGS_TAC->buf,\
 925          sizeof(servcell->fiveGS_TAC->size));
 926    if(servcell->fiveGS_TAC->buf == NULLP)
 927    {
 928       return RFAILED;
 929    }
 930    servcell->fiveGS_TAC->buf[0] = 0;
 931    servcell->fiveGS_TAC->buf[1] = 0;
 932    servcell->fiveGS_TAC->buf[2] = duCfgParam.srvdCellLst[0].duCellInfo.tac;
 933    return ROK;
 934 }
 935
 936 /*******************************************************************
 937  *
 938  * @brief fill nr frequency information
 939  *
 940  * @details
 941  *
 942  *    Function : fillNrTddInfo
 943  *
 944  *    Functionality: fill nr frequency information
 945  *
 946  * @params[in] NRFreqInfo_t freqInfo
 947  * @return ROK     - success
 948  *         RFAILED - failure
 949  *
 950  * ****************************************************************/
 951 uint8_t fillNrTddInfo(TDD_Info_t *tddInfo)
 952 {
 953    uint8_t elementCnt = 1, freqBandListIdx = 0, supportedBandIdx = 0;
 954    NRFreqInfo_t *freqInfo = NULLP;
 955
 956    if(tddInfo == NULLP)
 957    {
 958       DU_LOG("\nERROR  --> DU APP : Null pointer received at fillNrTddInfo");
 959       return RFAILED;
 960    }
 961
 962    freqInfo = &tddInfo->nRFreqInfo;
 963    freqInfo->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.nrArfcn;
 964
 965    freqInfo->freqBandListNr.list.count = elementCnt;
 966    freqInfo->freqBandListNr.list.size = freqInfo->freqBandListNr.list.count  * sizeof(FreqBandNrItem_t *);
 967    DU_ALLOC(freqInfo->freqBandListNr.list.array, freqInfo->freqBandListNr.list.size );
 968    if(!freqInfo->freqBandListNr.list.array)
 969    {
 970       DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 971       return RFAILED;
 972    }
 973
 974    for(freqBandListIdx = 0; freqBandListIdx<freqInfo->freqBandListNr.list.count; freqBandListIdx++)
 975    {
 976       DU_ALLOC(freqInfo->freqBandListNr.list.array[freqBandListIdx],  sizeof(FreqBandNrItem_t ));
 977       if(!freqInfo->freqBandListNr.list.array[freqBandListIdx])
 978       {
 979          DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 980          return RFAILED;
 981       }
 982
 983       freqInfo->freqBandListNr.list.array[freqBandListIdx]->freqBandIndicatorNr = duCfgParam.srvdCellLst[0].duCellInfo.\
 984       f1Mode.mode.tdd.nrFreqInfo.freqBand[0].nrFreqBand;
 985       freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.count = elementCnt;
 986       freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.size = freqInfo->freqBandListNr.list.array[freqBandListIdx]->\
 987       supportedSULBandList.list.count * sizeof(SupportedSULFreqBandItem_t*);
 988
 989       DU_ALLOC(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array,\
 990             freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.size);
 991       if(!freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array)
 992       {
 993          DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
 994          return RFAILED;
 995       }
 996
 997       for(supportedBandIdx = 0; supportedBandIdx<freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.count; supportedBandIdx++)
 998       {
 999          DU_ALLOC(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx],\
1000                sizeof(SupportedSULFreqBandItem_t));
1001          if(!freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx])
1002          {
1003             DU_LOG("\nERROR  --> DU APP : Memory allocation failed at fillNrTddInfo");
1004             return RFAILED;
1005          }
1006
1007          freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx]->freqBandIndicatorNr =\
1008          duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.freqBand[0].sulBand[0];
1009       }
1010    }
1011
1012    tddInfo->transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.sulInfo.sulTxBw.nrScs;
1013    tddInfo->transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.tdd.nrFreqInfo.sulInfo.sulTxBw.nrb;
1014
1015    return ROK;
1016 }
1017
1018 /*******************************************************************
1019  *
1020  * @brief Builds NR Mode
1021  *
1022  * @details
1023  *
1024  *    Function : BuildNrMode
1025  *
1026  *    Functionality: Building the NR Mode
1027  *
1028  * @params[in] NR_Mode_Info_t *fdd
1029  * @return ROK     - success
1030  *         RFAILED - failure
1031  *
1032  * ****************************************************************/
1033 uint8_t BuildNrMode(NR_Mode_Info_t *mode)
1034 {
1035    uint8_t BuildDLNRInforet=0;
1036    uint8_t BuildULNRInforet=0;
1037
1038 #ifdef NR_TDD
1039    mode->present = NR_Mode_Info_PR_tDD;
1040 #else
1041    mode->present = NR_Mode_Info_PR_fDD;
1042 #endif
1043
1044    if(mode->present == NR_Mode_Info_PR_fDD)
1045    {
1046       DU_ALLOC(mode->choice.fDD,sizeof(FDD_Info_t));
1047       if(mode->choice.fDD == NULLP)
1048       {
1049          DU_LOG("\nERROR  --> Memory allocation failed in BuildNrMode");
1050          return RFAILED;
1051       }
1052       BuildULNRInforet = BuildULNRInfo(&mode->choice.fDD->uL_NRFreqInfo);
1053       if(BuildULNRInforet != ROK)
1054       {
1055          DU_LOG("\nERROR  --> Failed to build UlNrFreqInfo");
1056          return RFAILED;
1057       }
1058       BuildDLNRInforet = BuildDLNRInfo(&mode->choice.fDD->dL_NRFreqInfo);
1059       if(BuildDLNRInforet != ROK)
1060       {
1061          DU_LOG("\nERROR  --> Failed to build DlNrFreqInfo");
1062          return RFAILED;
1063       }
1064       mode->choice.fDD->uL_Transmission_Bandwidth.nRSCS = \
1065                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
1066                                                           f1Mode.mode.fdd.ulTxBw.nrScs;
1067       mode->choice.fDD->uL_Transmission_Bandwidth.nRNRB = \
1068                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
1069                                                           f1Mode.mode.fdd.ulTxBw.nrb;
1070       mode->choice.fDD->dL_Transmission_Bandwidth.nRSCS = \
1071                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
1072                                                           f1Mode.mode.fdd.dlTxBw.nrScs;
1073       mode->choice.fDD->dL_Transmission_Bandwidth.nRNRB = \
1074                                                           duCfgParam.srvdCellLst[0].duCellInfo.\
1075                                                           f1Mode.mode.fdd.dlTxBw.nrb;
1076    }
1077    else if(mode->present == NR_Mode_Info_PR_tDD)
1078    {
1079       DU_ALLOC(mode->choice.tDD,sizeof(TDD_Info_t));
1080       if(mode->choice.tDD == NULLP)
1081       {
1082          DU_LOG("\nERROR  --> Memory allocation failed in BuildNrMode");
1083          return RFAILED;
1084       }
1085
1086       if(fillNrTddInfo(mode->choice.tDD) != ROK)
1087       {
1088          DU_LOG("\nERROR  --> Failed to fill Nr TDD information");
1089          return RFAILED;
1090       }
1091
1092    }
1093
1094    return ROK;
1095 }
1096 /*******************************************************************
1097  *
1098  * @brief Builds IE Extensions for Served PLMNs
1099  *
1100  * @details
1101  *
1102  *    Function : BuildExtensions
1103  *
1104  *    Functionality: Building the IE Extensions
1105  *
1106  * @params[in] struct ProtocolExtensionContainer_4624P3 *buildextend
1107  * @return ROK     - success
1108  *         RFAILED - failure
1109  *
1110  * ****************************************************************/
1111 uint8_t BuildExtensions(ProtocolExtensionContainer_4624P3_t **ieExtend)
1112 {
1113    uint8_t idx=0, plmnidx=0, sliceLstIdx=0;
1114    uint8_t elementCnt=0, extensionCnt=0;
1115
1116    extensionCnt=IE_EXTENSION_LIST_COUNT;
1117    DU_ALLOC(*ieExtend,sizeof(ProtocolExtensionContainer_4624P3_t));
1118    if((*ieExtend) == NULLP)
1119    {
1120       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1121       return RFAILED;
1122    }
1123    (*ieExtend)->list.count = extensionCnt;
1124    (*ieExtend)->list.size = \
1125                             extensionCnt * sizeof(ServedPLMNs_ItemExtIEs_t *);
1126    DU_ALLOC((*ieExtend)->list.array,(*ieExtend)->list.size);
1127    if((*ieExtend)->list.array == NULLP)
1128    {
1129       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1130       return RFAILED;
1131    }
1132    for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
1133    {
1134       DU_ALLOC((*ieExtend)->list.array[plmnidx],\
1135             sizeof(ServedPLMNs_ItemExtIEs_t));
1136       if((*ieExtend)->list.array[plmnidx] == NULLP)
1137       {
1138          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1139          return RFAILED;
1140       }
1141    }
1142
1143    elementCnt = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].taiSliceSuppLst.numSupportedSlices;
1144    idx = 0;
1145    (*ieExtend)->list.array[idx]->id = ProtocolIE_ID_id_TAISliceSupportList;
1146    (*ieExtend)->list.array[idx]->criticality = Criticality_ignore;
1147    (*ieExtend)->list.array[idx]->extensionValue.present = \
1148    ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
1149    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1150       list.count = elementCnt;
1151    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1152       list.size = (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1153       list.count * sizeof(SliceSupportItem_t *);
1154
1155    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1156          list.array, elementCnt * sizeof(SliceSupportItem_t *));
1157    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1158          list.array == NULLP)
1159    {
1160       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1161       return RFAILED;
1162    }
1163
1164    for(sliceLstIdx =0; sliceLstIdx<elementCnt; sliceLstIdx++)
1165    {
1166       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1167             list.array[sliceLstIdx],sizeof(SliceSupportItem_t));
1168       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1169             list.array[sliceLstIdx] == NULLP)
1170       {
1171          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1172          return RFAILED;
1173       }
1174       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1175          list.array[sliceLstIdx]->sNSSAI.sST.size = sizeof(uint8_t);
1176       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
1177             .list.array[sliceLstIdx]->sNSSAI.sST.buf,(*ieExtend)->list.array[idx]->\
1178             extensionValue.choice.SliceSupportList.\
1179             list.array[sliceLstIdx]->sNSSAI.sST.size);
1180       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
1181             .list.array[sliceLstIdx]->sNSSAI.sST.buf == NULLP)
1182       {
1183          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1184          return RFAILED;
1185       }
1186       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1187          list.array[sliceLstIdx]->sNSSAI.sST.buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.\
1188          cellInfo.srvdPlmn[0].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
1189
1190       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1191             list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1192       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1193             list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
1194       {
1195          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1196          return RFAILED;
1197       }
1198       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1199          list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
1200       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1201             list.array[sliceLstIdx]->sNSSAI.sD->buf, (*ieExtend)->list.array[idx]->extensionValue.choice.\
1202             SliceSupportList.list.array[sliceLstIdx]->sNSSAI.sD->size);
1203       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1204             list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
1205       {
1206          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1207          return RFAILED;
1208       }
1209       memcpy((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1210       list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[0].duCellInfo.\
1211       cellInfo.srvdPlmn[0].taiSliceSuppLst.snssai[sliceLstIdx]->sd, (*ieExtend)->list.array[idx]->\
1212       extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->sNSSAI.sD->size);
1213    }
1214    return ROK;
1215 }
1216 /*******************************************************************
1217  *
1218  * @brief Builds Served PLMN
1219  *
1220  * @details
1221  *
1222  *    Function : BuildServedPlmn
1223  *
1224  *    Functionality: Building the Served PLMN
1225  *
1226  * @params[in] GNB_DU_Served_Cells_Item_t *srvCellItem
1227  * @return ROK     - success
1228  *         RFAILED - failure
1229  *
1230  * ****************************************************************/
1231 uint8_t  BuildServedPlmn(ServedPLMNs_List_t *srvplmn)
1232 {
1233    uint8_t  plmnidx;
1234    uint8_t  servPlmnCnt=1;
1235    uint8_t buildPlmnIdret=0;
1236    uint8_t BuildExtensionsret=0;
1237    srvplmn->list.count = servPlmnCnt;
1238    srvplmn->list.size = \
1239                         servPlmnCnt*sizeof(ServedPLMNs_Item_t *);
1240    DU_ALLOC(srvplmn->list.array,srvplmn->list.size);
1241    if(srvplmn->list.array == NULLP)
1242    {
1243       return RFAILED;
1244    }
1245    for(plmnidx=0; plmnidx<servPlmnCnt; plmnidx++)
1246    {
1247       DU_ALLOC(srvplmn->list.array[plmnidx],\
1248             sizeof(ServedPLMNs_Item_t));
1249       if(srvplmn->list.array[plmnidx] == NULLP)
1250       {
1251          return RFAILED;
1252       }
1253    }
1254    srvplmn->list.array[0]->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
1255    DU_ALLOC(srvplmn->list.array[0]->pLMN_Identity.buf, srvplmn->list.array[0]->pLMN_Identity.size);
1256    buildPlmnIdret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
1257          srvplmn->list.array[0]->pLMN_Identity.buf);
1258    if(buildPlmnIdret!= ROK)
1259    {
1260       return RFAILED;
1261    }
1262    BuildExtensionsret = BuildExtensions(&srvplmn->list.array[0]->iE_Extensions);
1263    if(BuildExtensionsret!= ROK)
1264    {
1265       return RFAILED;
1266    }
1267    return ROK;
1268 }
1269 /*******************************************************************
1270  *
1271  * @brief Builds Served Cell List
1272  *
1273  * @details
1274  *
1275  *    Function : BuildServedCellList
1276  *
1277  *    Functionality: Building Served Cell List
1278  *
1279  * @params[in] PLMNID plmn
1280  * @return ROK     - success
1281  *         RFAILED - failure
1282  *
1283  * ****************************************************************/
1284
1285 uint8_t BuildServedCellList(GNB_DU_Served_Cells_List_t *duServedCell)
1286 {
1287    uint8_t  BuildNrcgiret=0;
1288    uint8_t  BuildFiveGSTacret=0;
1289    uint8_t  BuildServedPlmnret=0;
1290    uint8_t  BuildNrModeret=0;
1291    uint8_t  idx;
1292    uint8_t  plmnidx;
1293    uint8_t  plmnCnt=1;
1294    GNB_DU_Served_Cells_Item_t *srvCellItem;
1295    duServedCell->list.size = plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t *);
1296    duServedCell->list.count = plmnCnt;
1297
1298    DU_ALLOC(duServedCell->list.array, duServedCell->list.size);
1299    if(duServedCell->list.array == NULLP)
1300    {
1301       return RFAILED;
1302    }
1303    for(plmnidx=0; plmnidx<plmnCnt; plmnidx++)
1304    {
1305       DU_ALLOC(duServedCell->list.array[plmnidx],\
1306             sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1307       if(duServedCell->list.array[plmnidx] == NULLP)
1308       {
1309          return RFAILED;
1310       }
1311    }
1312    idx = 0;
1313    duServedCell->list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_Served_Cells_Item;
1314    duServedCell->list.array[idx]->criticality = Criticality_reject;
1315    duServedCell->list.array[idx]->value.present = \
1316                                                   GNB_DU_Served_Cells_ItemIEs__value_PR_GNB_DU_Served_Cells_Item;
1317    srvCellItem = \
1318                  &duServedCell->list.array[idx]->value.choice.GNB_DU_Served_Cells_Item;
1319    /*nRCGI*/
1320    BuildNrcgiret = BuildNrcgi(&srvCellItem->served_Cell_Information.nRCGI);
1321    if(BuildNrcgiret != ROK)
1322    {
1323       return RFAILED;
1324    }
1325    /*nRPCI*/
1326    srvCellItem->served_Cell_Information.nRPCI = \
1327                                                 duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
1328
1329    /*fiveGS_TAC*/
1330    BuildFiveGSTacret = BuildFiveGSTac(&srvCellItem->served_Cell_Information);
1331    if(BuildFiveGSTacret != ROK)
1332    {
1333       return RFAILED;
1334    }
1335    /*Served PLMNs*/
1336    BuildServedPlmnret = BuildServedPlmn(&srvCellItem->served_Cell_Information.servedPLMNs);
1337    if(BuildServedPlmnret !=ROK)
1338    {
1339       return RFAILED;
1340    }
1341    /*nR Mode Info with FDD*/
1342    BuildNrModeret = BuildNrMode(&srvCellItem->served_Cell_Information.nR_Mode_Info);
1343    if(BuildNrModeret != ROK)
1344    {
1345       return RFAILED;
1346    }
1347    /*Measurement timing Config*/
1348    srvCellItem->served_Cell_Information.measurementTimingConfiguration.\
1349       size = sizeof(uint8_t);
1350    DU_ALLOC(srvCellItem->served_Cell_Information.\
1351          measurementTimingConfiguration.buf,srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1352    if(srvCellItem->served_Cell_Information.\
1353          measurementTimingConfiguration.buf == NULLP)
1354    {
1355       return RFAILED;
1356    }
1357    srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf[0] = \
1358                                                                                 duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
1359
1360    /* GNB DU System Information */
1361    DU_ALLOC(srvCellItem->gNB_DU_System_Information,
1362          sizeof(GNB_DU_System_Information_t));
1363    if(!srvCellItem->gNB_DU_System_Information)
1364    {
1365       return RFAILED;
1366    }
1367    /* MIB */
1368    srvCellItem->gNB_DU_System_Information->mIB_message.size = duCfgParam.srvdCellLst[0].duSysInfo.mibLen;
1369    DU_ALLOC(srvCellItem->gNB_DU_System_Information->mIB_message.buf,
1370          srvCellItem->gNB_DU_System_Information->mIB_message.size);
1371    if(!srvCellItem->gNB_DU_System_Information->mIB_message.buf)
1372    {
1373       return RFAILED;
1374    }
1375    memcpy(srvCellItem->gNB_DU_System_Information->mIB_message.buf, duCfgParam.srvdCellLst[0].duSysInfo.mibMsg, \
1376                    srvCellItem->gNB_DU_System_Information->mIB_message.size);
1377
1378    /* SIB1 */
1379    srvCellItem->gNB_DU_System_Information->sIB1_message.size =\
1380                                                               duCfgParam.srvdCellLst[0].duSysInfo.sib1Len;
1381
1382    DU_ALLOC(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,
1383          srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1384    if(!srvCellItem->gNB_DU_System_Information->sIB1_message.buf)
1385    {
1386       return RFAILED;
1387    }
1388    for(int x=0; x<srvCellItem->gNB_DU_System_Information->sIB1_message.size; x++)
1389    {
1390       srvCellItem->gNB_DU_System_Information->sIB1_message.buf[x]=\
1391                                                                   duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg[x];
1392    }
1393    return ROK;
1394 }
1395 /*******************************************************************
1396  *
1397  * @brief Builds RRC Version
1398  *
1399  * @details
1400  *
1401  *    Function : BuildRrcVer
1402  *
1403  *    Functionality: Building RRC Version
1404  *
1405  * @params[in] int idx,int elementCnt,RRC_Version_t *rrcver
1406  * @return ROK     - success
1407  *         RFAILED - failure
1408  *
1409  * ****************************************************************/
1410 uint8_t BuildRrcVer(RRC_Version_t *rrcVer)
1411 {
1412    uint8_t rrcExt;
1413    uint8_t rrcLatest;
1414    rrcVer->latest_RRC_Version.size = sizeof(uint8_t);
1415    DU_ALLOC(rrcVer->latest_RRC_Version.buf,sizeof(uint8_t));
1416    if(rrcVer->latest_RRC_Version.buf == NULLP)
1417    {
1418       return RFAILED;
1419    }
1420    rrcVer->latest_RRC_Version.buf[0] = 0;
1421    rrcVer->latest_RRC_Version.bits_unused = 5;
1422    DU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1423    if(rrcVer->iE_Extensions == NULLP)
1424    {
1425       return RFAILED;
1426    }
1427    rrcVer->iE_Extensions->list.count = 1;
1428    rrcVer->iE_Extensions->list.size = sizeof(RRC_Version_ExtIEs_t *);
1429    DU_ALLOC(rrcVer->iE_Extensions->list.array,rrcVer->iE_Extensions->list.size);
1430    if(rrcVer->iE_Extensions->list.array == NULLP)
1431    {
1432       return RFAILED;
1433    }
1434    rrcExt = 0;
1435    DU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
1436          sizeof(RRC_Version_ExtIEs_t));
1437    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
1438    {
1439       return RFAILED;
1440    }
1441    rrcVer->iE_Extensions->list.array[rrcExt]->id = \
1442                                                    ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
1443    rrcVer->iE_Extensions->list.array[rrcExt]->criticality = Criticality_reject;
1444    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.present =\
1445                                                                       RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
1446    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1447       .Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
1448    DU_ALLOC(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1449          .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1450          array[rrcExt]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1451    if(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1452          .Latest_RRC_Version_Enhanced.buf == NULLP)
1453    {
1454       return RFAILED;
1455    }
1456    rrcLatest = 0;
1457    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1458       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 15;
1459    rrcLatest++;
1460    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1461       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 5;
1462    rrcLatest++;
1463    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1464       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 0;
1465    return ROK;
1466 }
1467 /*******************************************************************
1468  *
1469  * @brief Sends F1 msg over SCTP
1470  *
1471  * @details
1472  *
1473  *    Function : sendF1APMsg
1474  *
1475  *    Functionality: Sends F1 msg over SCTP
1476  *
1477  * @params[in] Region region
1478  *             Pool pool
1479  * @return ROK     - success
1480  *         RFAILED - failure
1481  *
1482  * ****************************************************************/
1483 uint8_t sendF1APMsg()
1484 {
1485    Buffer *mBuf = NULLP;
1486
1487    if(ODU_GET_MSG_BUF(DU_APP_MEM_REGION, DU_POOL, &mBuf) == ROK)
1488    {
1489       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
1490       {
1491             ODU_PRINT_MSG(mBuf, 0,0);
1492
1493             if(sctpSend(mBuf, F1_INTERFACE) != ROK)
1494             {
1495                DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
1496                ODU_PUT_MSG_BUF(mBuf);
1497                return RFAILED;
1498             }
1499       }
1500       else
1501       {
1502          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
1503          ODU_PUT_MSG_BUF(mBuf);
1504          return RFAILED;
1505       }
1506       ODU_PUT_MSG_BUF(mBuf);
1507    }
1508    else
1509    {
1510       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
1511       return RFAILED;
1512    }
1513    return ROK;
1514 } /* sendF1APMsg */
1515
1516 /*******************************************************************
1517  *
1518  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1519  *
1520  * @details
1521  *
1522  *    Function :  FreeRrcVer
1523  *
1524  *    Functionality: deallocating the memory of function BuildRrcVer
1525  *
1526  * @params[in] RRC_Version_t *rrcVer
1527  *
1528  * @return void
1529  *
1530  *****************************************************************/
1531 void FreeRrcVer(RRC_Version_t *rrcVer)
1532 {
1533    if(rrcVer->latest_RRC_Version.buf != NULLP)
1534    {
1535       if(rrcVer->iE_Extensions != NULLP)
1536       {
1537          if(rrcVer->iE_Extensions->list.array != NULLP)
1538          {
1539             if(rrcVer->iE_Extensions->list.array[0] != NULLP)
1540             {
1541                if(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf
1542                      != NULLP)
1543                {
1544                   DU_FREE(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice\
1545                         .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1546                         array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1547                }
1548                DU_FREE(rrcVer->iE_Extensions->list.array[0],sizeof(RRC_Version_ExtIEs_t));
1549             }
1550             DU_FREE(rrcVer->iE_Extensions->list.array,sizeof(RRC_Version_ExtIEs_t*));
1551          }
1552          DU_FREE(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1553       }
1554       DU_FREE(rrcVer->latest_RRC_Version.buf,rrcVer->latest_RRC_Version.size);
1555    }
1556 }
1557
1558 /*******************************************************************
1559  *
1560  * @brief Deallocating memory of TDD NrFreqInfo
1561  *
1562  * @details
1563  *
1564  *    Function : freeTddNrFreqInfo
1565  *
1566  *    Functionality: freeTddNrFreqInfo
1567  *
1568  * @params[in]  F1AP_PDU_t *f1apDuCfg
1569  *
1570  * @return ROK     - void
1571  *
1572  * ****************************************************************/
1573 void freeTddNrFreqInfo(NRFreqInfo_t *freqInfo)
1574 {
1575    uint8_t freqBandListIdx = 0, supportedBandIdx = 0;
1576
1577    if(freqInfo->freqBandListNr.list.array)
1578    {
1579       for(freqBandListIdx = 0; freqBandListIdx<freqInfo->freqBandListNr.list.count; freqBandListIdx++)
1580       {
1581          if(freqInfo->freqBandListNr.list.array[freqBandListIdx])
1582          {
1583             if(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array)
1584             {
1585                for(supportedBandIdx = 0; supportedBandIdx<freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.count; supportedBandIdx++)
1586                {
1587                   DU_FREE(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array[supportedBandIdx],\
1588                         sizeof(SupportedSULFreqBandItem_t));
1589                }
1590                DU_FREE(freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.array,\
1591                      freqInfo->freqBandListNr.list.array[freqBandListIdx]->supportedSULBandList.list.size);
1592
1593             }
1594             DU_FREE(freqInfo->freqBandListNr.list.array[freqBandListIdx],  sizeof(FreqBandNrItem_t ));
1595          }
1596       }
1597       DU_FREE(freqInfo->freqBandListNr.list.array, freqInfo->freqBandListNr.list.size );
1598    }
1599 }
1600
1601 /*******************************************************************
1602  *
1603  * @brief Deallocating memory allocated for Nr fdd frequencey mode
1604  *
1605  * @details
1606  *
1607  *    Function : freeFddNrFreqInfo
1608  *
1609  *    Functionality:Free memory allocated for Nr fdd frequencey mode
1610  *
1611  * @params[in]
1612  *
1613  * @return ROK     - void
1614  *
1615  * ****************************************************************/
1616 void freeFddNrFreqInfo(FDD_Info_t *fDD)
1617 {
1618    uint8_t arrIdx =0;
1619
1620    if(fDD != NULLP)
1621    {
1622       if(fDD->uL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1623       {
1624          DU_FREE(fDD->uL_NRFreqInfo.freqBandListNr.list.\
1625                array[arrIdx], sizeof(FreqBandNrItem_t));
1626          DU_FREE(fDD->uL_NRFreqInfo.freqBandListNr.list.array, \
1627                fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1628       }
1629
1630       if(fDD->dL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1631       {
1632          DU_FREE(fDD->dL_NRFreqInfo.freqBandListNr.list.\
1633                array[arrIdx], sizeof(FreqBandNrItem_t));
1634          DU_FREE(fDD->dL_NRFreqInfo.freqBandListNr.list.array,\
1635                fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1636       }
1637       DU_FREE(fDD,sizeof(FDD_Info_t));
1638    }
1639 }
1640
1641 /*******************************************************************
1642  *
1643  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1644  *
1645  * @details
1646  *
1647  *    Function :  FreeServedCellList
1648  *
1649  *    Functionality:  deallocating the memory of function BuildServedCellList
1650
1651  *
1652  * @params[in] GNB_DU_Served_Cells_List_t *duServedCell
1653  *
1654  * @return void
1655  *
1656  * ****************************************************************/
1657 void FreeServedCellList( GNB_DU_Served_Cells_List_t *duServedCell)
1658 {
1659    uint8_t   plmnCnt=MAX_PLMN;
1660    uint8_t  extensionCnt=IE_EXTENSION_LIST_COUNT;
1661    uint8_t  plmnIdx=0, sliceIdx=0;
1662    GNB_DU_Served_Cells_Item_t *srvCellItem;
1663    ServedPLMNs_Item_t  *servedPlmnItem;
1664    SliceSupportItem_t  *sliceSupportItem;
1665
1666    if(duServedCell->list.array!=NULLP)
1667    {
1668       if(duServedCell->list.array[0]!=NULLP)
1669       {
1670          srvCellItem= &duServedCell->list.array[0]->value.choice.GNB_DU_Served_Cells_Item;
1671
1672          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1673                srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size * sizeof(uint8_t));
1674          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1675                srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size * sizeof(uint8_t));
1676
1677          if(srvCellItem->served_Cell_Information.fiveGS_TAC!=NULLP)
1678          {
1679             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
1680                   sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
1681             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,sizeof(FiveGS_TAC_t));
1682          }
1683
1684          if(srvCellItem->served_Cell_Information.servedPLMNs.list.array!=NULLP)
1685          {
1686             if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx] != NULLP)
1687             {
1688                servedPlmnItem = srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx];
1689                DU_FREE(servedPlmnItem->pLMN_Identity.buf, servedPlmnItem->pLMN_Identity.size);
1690
1691                if(servedPlmnItem->iE_Extensions != NULLP)
1692                {
1693                   if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1694                   {
1695                      if(servedPlmnItem->iE_Extensions->list.array[0] != NULLP)
1696                      {
1697                         if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1698                               SliceSupportList.list.array != NULLP)
1699                         {
1700                            for(sliceIdx =0; sliceIdx<servedPlmnItem->iE_Extensions->list.array[0]->\
1701                                  extensionValue.choice.SliceSupportList.list.count; sliceIdx++)
1702                            {
1703                               if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1704                                     SliceSupportList.list.array[sliceIdx] != NULLP)
1705                               {
1706                                  sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[0]->\
1707                                                     extensionValue.choice.SliceSupportList.list.array[sliceIdx];
1708
1709                                  DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sizeof(uint8_t));
1710
1711                                  if(sliceSupportItem->sNSSAI.sD != NULLP)
1712                                  {
1713                                     DU_FREE(sliceSupportItem->sNSSAI.sD->buf,\
1714                                           sliceSupportItem->sNSSAI.sD->size);
1715                                     DU_FREE(sliceSupportItem->sNSSAI.sD, sizeof(OCTET_STRING_t));
1716                                  }
1717
1718                                  DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.\
1719                                        choice.SliceSupportList.list.array[sliceIdx], sizeof(SliceSupportItem_t));
1720                               }
1721                            }
1722                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1723                                  SliceSupportList.list.array, servedPlmnItem->iE_Extensions->list.array[0]->\
1724                                  extensionValue.choice.SliceSupportList.list.size);
1725                         }
1726                         DU_FREE(servedPlmnItem->iE_Extensions->list.array[0],\
1727                               sizeof(ServedPLMNs_ItemExtIEs_t));
1728                      }
1729                      DU_FREE(servedPlmnItem->iE_Extensions->list.array,\
1730                            extensionCnt*sizeof(ServedPLMNs_ItemExtIEs_t*));
1731                   }
1732                   DU_FREE(servedPlmnItem->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P3_t));
1733                }
1734                DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx],\
1735                      sizeof(ServedPLMNs_Item_t));
1736             }
1737             DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array,\
1738                   sizeof(ServedPLMNs_Item_t *));
1739          }
1740
1741          if(srvCellItem->served_Cell_Information.nR_Mode_Info.present == NR_Mode_Info_PR_fDD)
1742          {
1743             freeFddNrFreqInfo(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD);
1744          }
1745          else
1746          {
1747             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.tDD != NULLP)
1748             {
1749                freeTddNrFreqInfo(&srvCellItem->served_Cell_Information.nR_Mode_Info.choice.tDD->nRFreqInfo);
1750                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.tDD, sizeof(TDD_Info_t));
1751             }
1752          }
1753
1754          DU_FREE(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1755                srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1756
1757          if(srvCellItem->gNB_DU_System_Information != NULLP)
1758          {
1759             if(srvCellItem->gNB_DU_System_Information->mIB_message.buf != NULLP)
1760             {
1761                DU_FREE(srvCellItem->gNB_DU_System_Information->mIB_message.buf,\
1762                      srvCellItem->gNB_DU_System_Information->mIB_message.size);
1763             }
1764
1765             if(srvCellItem->gNB_DU_System_Information->sIB1_message.buf != NULLP)
1766             {
1767                DU_FREE(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,\
1768                      srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1769             }
1770
1771             DU_FREE(srvCellItem->gNB_DU_System_Information, sizeof(GNB_DU_System_Information_t));
1772          }
1773
1774          DU_FREE(duServedCell->list.array[0], sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1775       }
1776       DU_FREE(duServedCell->list.array, plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t*));
1777    }
1778 }
1779
1780 /*******************************************************************
1781  *
1782  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1783  *
1784  * @details
1785  *
1786  *    Function :  FreeF1SetupReq
1787  *
1788  *    Functionality:  deallocating the memory of function BuildAndSendF1SetupReq
1789  *
1790  * @params[in] F1AP_PDU_t *f1apMsg
1791  *
1792  * @return void
1793  *
1794  * ****************************************************************/
1795 void FreeF1SetupReq(F1AP_PDU_t *f1apMsg)
1796 {
1797    uint8_t ieIdx, ieIdx2;
1798    F1SetupRequest_t *f1SetupReq=NULLP;
1799
1800    if(f1apMsg != NULLP)
1801    {
1802       if(f1apMsg->choice.initiatingMessage != NULLP)
1803       {
1804          f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1805          if(f1SetupReq->protocolIEs.list.array != NULLP)
1806          {
1807             for(ieIdx = 0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
1808             {
1809                if(f1SetupReq->protocolIEs.list.array[ieIdx] != NULLP)
1810                {
1811                   switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
1812                   {
1813                      case ProtocolIE_ID_id_TransactionID:
1814                         break;
1815                      case ProtocolIE_ID_id_gNB_DU_ID:
1816                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1817                               f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1818                         break;
1819                      case ProtocolIE_ID_id_gNB_DU_Name:
1820                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,\
1821                               strlen((char *)duCfgParam.duName));
1822                         break;
1823                      case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
1824                         FreeServedCellList(&f1SetupReq->protocolIEs.list.\
1825                               array[ieIdx]->value.choice.GNB_DU_Served_Cells_List);
1826                         break;
1827                      case ProtocolIE_ID_id_GNB_DU_RRC_Version:
1828                         FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version);
1829                         break;
1830                      default:
1831                         DU_LOG("\nERROR  -->  Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id);
1832                         break;
1833                   }
1834                }
1835             }
1836             for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++)
1837             {
1838                DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx2],sizeof(F1SetupRequestIEs_t));
1839             }
1840             DU_FREE(f1SetupReq->protocolIEs.list.array,\
1841                   f1SetupReq->protocolIEs.list.size);
1842          }
1843          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1844       }
1845       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1846    }
1847 }
1848 /*******************************************************************
1849  *
1850  * @brief Builds and Send the F1SetupRequest
1851  *
1852  * @details
1853  *
1854  *    Function : BuildAndSendF1SetupReq
1855  *
1856  * Functionality:Fills the F1SetupRequest
1857  *
1858  * @return ROK     - success
1859  *         RFAILED - failure
1860  *
1861  ******************************************************************/
1862 uint8_t BuildAndSendF1SetupReq()
1863 {
1864    uint8_t   ret, ieIdx, elementCnt;
1865    F1AP_PDU_t                 *f1apMsg = NULLP;
1866    F1SetupRequest_t           *f1SetupReq=NULLP;
1867    GNB_DU_Served_Cells_List_t *duServedCell=NULLP;
1868    RRC_Version_t              *rrcVer=NULLP;
1869    asn_enc_rval_t             encRetVal;        /* Encoder return value */
1870    ret= RFAILED;
1871
1872    DU_LOG("\nINFO   -->  F1AP : Building F1 Setup Request\n");
1873    do
1874    {
1875       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1876       if(f1apMsg == NULLP)
1877       {
1878          break;
1879       }
1880       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1881       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1882       if(f1apMsg->choice.initiatingMessage == NULLP)
1883       {
1884          break;
1885       }
1886       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_F1Setup;
1887       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
1888       f1apMsg->choice.initiatingMessage->value.present = \
1889                                                          InitiatingMessage__value_PR_F1SetupRequest;
1890
1891       f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1892
1893       elementCnt = (duCfgParam.duName != NULL) ? 5 : 4;
1894
1895       f1SetupReq->protocolIEs.list.count = elementCnt;
1896       f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t );
1897
1898       /* Initialize the F1Setup members */
1899       DU_ALLOC(f1SetupReq->protocolIEs.list.array,f1SetupReq->protocolIEs.list.size);
1900       if(f1SetupReq->protocolIEs.list.array == NULLP)
1901       {
1902          break;
1903       }
1904       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
1905       {
1906          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx],\
1907                sizeof(F1SetupRequestIEs_t));
1908          if(f1SetupReq->protocolIEs.list.array[ieIdx] == NULLP)
1909          {
1910             break;
1911          }
1912       }
1913
1914       ieIdx = 0;
1915       /*TransactionID*/
1916       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransactionID;
1917       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1918       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present =\
1919                                                                F1SetupRequestIEs__value_PR_TransactionID;
1920       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = \
1921                                                                              TRANS_ID;
1922
1923       /*DU ID*/
1924       ieIdx++;
1925       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
1926       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1927       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1928                                                                 F1SetupRequestIEs__value_PR_GNB_DU_ID;
1929       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size =\
1930                                                                              sizeof(uint8_t);
1931
1932       DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1933             f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1934       if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == \
1935             NULLP)
1936       {
1937          break;
1938       }
1939
1940       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] =\
1941          duCfgParam.duId;
1942
1943       /*DU Name*/
1944       if(duCfgParam.duName != NULL)
1945       {
1946          ieIdx++;
1947          f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_Name;
1948          f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
1949          f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = F1SetupRequestIEs__value_PR_GNB_DU_Name;
1950          f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.size =\
1951             strlen((char *)duCfgParam.duName);
1952          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.\
1953                GNB_DU_Name.buf, strlen((char *)duCfgParam.duName));
1954          if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.\
1955                buf == NULLP)
1956          {
1957             break;
1958          }
1959          strcpy((char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.\
1960                choice.GNB_DU_Name.buf,
1961                (char*)&duCfgParam.duName);
1962
1963       }
1964
1965       /*Served Cell list */
1966       ieIdx++;
1967       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1968                                                      ProtocolIE_ID_id_gNB_DU_Served_Cells_List;
1969       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1970       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1971                                                                 F1SetupRequestIEs__value_PR_GNB_DU_Served_Cells_List;
1972       duServedCell = &f1SetupReq->protocolIEs.list.\
1973                      array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
1974       if(BuildServedCellList(duServedCell))
1975       {
1976          break;
1977       }
1978       /*RRC Version*/
1979       ieIdx++;
1980       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1981                                                      ProtocolIE_ID_id_GNB_DU_RRC_Version ;
1982       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1983       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1984                                                                 F1SetupRequestIEs__value_PR_RRC_Version;
1985       rrcVer = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
1986       if(BuildRrcVer(rrcVer))
1987       {
1988          break;
1989       }
1990       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1991
1992       /* Encode the F1SetupRequest type as APER */
1993       memset(encBuf, 0, ENC_BUF_MAX_LEN);
1994       encBufSize = 0;
1995       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1996             encBuf);
1997
1998       /* Encode results */
1999       if(encRetVal.encoded == ENCODE_FAIL)
2000       {
2001          DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupRequest structure (at %s)\n",\
2002                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2003          break;
2004       }
2005       else
2006       {
2007          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1SetupRequest\n");
2008          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
2009          {
2010             printf("%x",encBuf[ieIdx]);
2011          }
2012
2013          duCb.f1SetupReqAndRspMsg.f1MsgReqBufSize = encBufSize;
2014          DU_ALLOC(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf, encBufSize);
2015          if(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf == NULLP)
2016          {
2017              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed to store the encoding of f1setup req");
2018              return RFAILED;
2019          }
2020          memcpy(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf, &encBuf, duCb.f1SetupReqAndRspMsg.f1MsgReqBufSize);
2021       }
2022
2023       /* Sending msg */
2024       if(sendF1APMsg() != ROK)
2025       {
2026          DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup request failed");
2027          break;
2028       }
2029
2030       ret=ROK;
2031       break;
2032    }while(true);
2033
2034    FreeF1SetupReq(f1apMsg);
2035
2036    return ret;
2037 }/* End of BuildAndSendF1SetupReq */
2038
2039 /*******************************************************************
2040  *
2041  * @brief Deallocating memory allocated for Served_Cells_To_Modify_Item_t
2042  *
2043  * @details
2044  *
2045  *    Function : freeCellsToModifyItem
2046  *
2047  *    Functionality: Deallocating memory of variables allocated in
2048  *                    BuildAndSendDUConfigUpdate function
2049  *
2050  * @params[in]  Served_Cells_To_Modify_Item_t *modifyItem
2051  *
2052  * @return ROK     - void
2053  *
2054  * ****************************************************************/
2055
2056 void freeCellsToModifyItem(Served_Cells_To_Modify_Item_t *modifyItem)
2057 {
2058    uint8_t arrIdx=0, servedPlmnIdx=0, sliceLstIdx=0;
2059    ServedPLMNs_Item_t *servedPlmnItem = NULLP;
2060    SliceSupportItem_t *sliceSupportItem = NULLP;
2061
2062    DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf, modifyItem->oldNRCGI.pLMN_Identity.size);
2063    DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf, modifyItem->oldNRCGI.nRCellIdentity.size);
2064
2065    DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
2066            modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
2067    DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
2068          modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
2069
2070    if(modifyItem->served_Cell_Information.servedPLMNs.list.array != NULLP)
2071    {
2072       if(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx] != NULLP)
2073       {
2074          servedPlmnItem = modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx];
2075
2076          DU_FREE(servedPlmnItem->pLMN_Identity.buf,servedPlmnItem->pLMN_Identity.size);
2077
2078          if(servedPlmnItem->iE_Extensions != NULLP)
2079          {
2080             if(servedPlmnItem->iE_Extensions->list.array != NULLP)
2081             {
2082                if(servedPlmnItem->iE_Extensions->list.array[arrIdx] != NULLP)
2083                {
2084                   if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
2085                         list.array != NULLP)
2086                   {
2087                      for(sliceLstIdx =0; sliceLstIdx<servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
2088                            extensionValue.choice.SliceSupportList.list.count; sliceLstIdx++)
2089                      {
2090                         if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
2091                               list.array[sliceLstIdx] != NULLP)
2092                         {
2093
2094                            sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
2095                                               SliceSupportList.list.array[sliceLstIdx];
2096
2097                            DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sliceSupportItem->sNSSAI.sST.size);
2098                            if(sliceSupportItem->sNSSAI.sD != NULLP)
2099                            {
2100                               DU_FREE(sliceSupportItem->sNSSAI.sD->buf, sliceSupportItem->sNSSAI.sD->size);
2101                               DU_FREE(sliceSupportItem->sNSSAI.sD,sizeof(OCTET_STRING_t));
2102                            }
2103                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
2104                                  SliceSupportList.list.array[sliceLstIdx], sizeof(SliceSupportItem_t));
2105                         }
2106                      }
2107                      DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.\
2108                            choice.SliceSupportList.list.array,\
2109                            servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
2110                            extensionValue.choice.SliceSupportList.list.size);
2111                   }
2112                }
2113                for(servedPlmnIdx=0; servedPlmnIdx< servedPlmnItem->iE_Extensions->list.count ; servedPlmnIdx++)
2114                {
2115                   DU_FREE(servedPlmnItem->iE_Extensions->list.array[servedPlmnIdx], sizeof(ServedPLMNs_ItemExtIEs_t ));
2116                }
2117                DU_FREE(servedPlmnItem->iE_Extensions->list.array, servedPlmnItem->iE_Extensions->list.size);
2118             }
2119             DU_FREE(servedPlmnItem->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
2120          }
2121       }
2122       for(servedPlmnIdx=0; servedPlmnIdx<modifyItem->served_Cell_Information.servedPLMNs.list.count; servedPlmnIdx++)
2123       {
2124          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[servedPlmnIdx], sizeof(ServedPLMNs_Item_t));
2125       }
2126       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
2127          modifyItem->served_Cell_Information.servedPLMNs.list.size);
2128    }
2129
2130    if(modifyItem->served_Cell_Information.nR_Mode_Info.present == NR_Mode_Info_PR_fDD)
2131    {
2132       freeFddNrFreqInfo(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD);
2133    }
2134    else
2135    {
2136       if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.tDD)
2137       {
2138          freeTddNrFreqInfo(&modifyItem->served_Cell_Information.nR_Mode_Info.choice.tDD->nRFreqInfo);
2139          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.tDD, sizeof(TDD_Info_t));
2140       }
2141    }
2142    DU_FREE(modifyItem->served_Cell_Information.measurementTimingConfiguration.buf,\
2143       modifyItem->served_Cell_Information.measurementTimingConfiguration.size);
2144 }
2145
2146 /*******************************************************************
2147  *
2148  * @brief Deallocating memory of BuildAndSendDUConfigUpdate
2149  *
2150  * @details
2151  *
2152  *    Function : FreeDUConfigUpdate
2153  *
2154  *    Functionality: Deallocating memory of variables allocated in
2155  *                    BuildAndSendDUConfigUpdate function
2156  *
2157  * @params[in]  F1AP_PDU_t *f1apDuCfg
2158  *
2159  * @return ROK     - void
2160  *
2161  * ****************************************************************/
2162 void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg)
2163 {
2164    uint8_t  ieIdx=0, cellModifyIdx=0, cellDeleteIdx=0;
2165    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
2166    Served_Cells_To_Modify_List_t  *cellsToModify=NULLP;
2167    Served_Cells_To_Delete_List_t  *cellsToDelete=NULLP;
2168    Served_Cells_To_Delete_Item_t  *deleteItem = NULLP;
2169    Served_Cells_To_Delete_ItemIEs_t *deleteItemIe = NULLP;
2170
2171    if(f1apDuCfg != NULLP)
2172    {
2173       if(f1apDuCfg->choice.initiatingMessage != NULLP)
2174       {
2175          duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->\
2176                        value.choice.GNBDUConfigurationUpdate;
2177          if(duCfgUpdate->protocolIEs.list.array != NULLP)
2178          {
2179             for(ieIdx=0; ieIdx<duCfgUpdate->protocolIEs.list.count; ieIdx++)
2180             {
2181                if(duCfgUpdate->protocolIEs.list.array[ieIdx] != NULLP)
2182                {
2183                   switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
2184                   {
2185                      case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
2186                         {
2187                            cellsToModify = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
2188                                            value.choice.Served_Cells_To_Modify_List;
2189                            if(cellsToModify->list.array != NULLP)
2190                            {
2191                               for(cellModifyIdx=0; cellModifyIdx<cellsToModify->list.count ;cellModifyIdx++)
2192                               {
2193                                  if(cellsToModify->list.array[cellModifyIdx] != NULLP)
2194                                  {
2195                                     freeCellsToModifyItem(&cellsToModify->list.array[cellModifyIdx]->value.choice.\
2196                                           Served_Cells_To_Modify_Item);
2197                                     DU_FREE(cellsToModify->list.array[cellModifyIdx],\
2198                                           sizeof(Served_Cells_To_Modify_ItemIEs_t));
2199                                  }
2200                               }
2201                               DU_FREE(cellsToModify->list.array,cellsToModify->list.size);
2202                            }
2203                            break;
2204                         }
2205                      case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
2206                         {
2207                            cellsToDelete = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
2208                                            value.choice.Served_Cells_To_Delete_List;
2209                            if(cellsToDelete->list.array != NULLP)
2210                            {
2211                               for(cellDeleteIdx=0; cellDeleteIdx<cellsToDelete->list.count ;cellDeleteIdx++)
2212                               {
2213                                  if(cellsToDelete->list.array[cellDeleteIdx] != NULLP)
2214                                  {
2215                                     deleteItemIe = ((Served_Cells_To_Delete_ItemIEs_t*)\
2216                                           cellsToDelete->list.array[cellDeleteIdx]);
2217                                     deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
2218                                     DU_FREE(deleteItem->oldNRCGI.pLMN_Identity.buf,\
2219                                           deleteItem->oldNRCGI.pLMN_Identity.size);
2220                                     DU_FREE(deleteItem->oldNRCGI.nRCellIdentity.buf,\
2221                                           deleteItem->oldNRCGI.nRCellIdentity.size);
2222                                     DU_FREE(cellsToDelete->list.array[cellDeleteIdx],\
2223                                           sizeof(Served_Cells_To_Delete_ItemIEs_t));
2224                                  }
2225                               }
2226                               DU_FREE(cellsToDelete->list.array,cellsToDelete->list.size);
2227                            }
2228
2229                            break;
2230                         }
2231                      case ProtocolIE_ID_id_gNB_DU_ID:
2232                         {
2233                            DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2234                                  duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2235                            break;
2236                         }
2237                   }
2238                   DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx],\
2239                         sizeof(GNBDUConfigurationUpdateIEs_t));
2240                }
2241             }
2242             DU_FREE(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2243          }
2244          DU_FREE(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2245       }
2246       DU_FREE(f1apDuCfg, (Size)sizeof(F1AP_PDU_t));
2247    }
2248 }
2249
2250 /*******************************************************************
2251  *
2252  * @brief Fills Served Plmns required in ServCellInfo IE
2253  *
2254  * @details
2255  *
2256  *    Function : fillServedPlmns
2257  *
2258  *    Functionality: Fills Served Plmns required in ServCellInfo IE
2259  *
2260  * @params[in] Pointer to ServedPLMNs_List_t *
2261  *
2262  * @return ROK     - success
2263  *         RFAILED - failure
2264  *
2265  *****************************************************************/
2266
2267 uint8_t fillServedPlmns(ServedPLMNs_List_t *servedPlmn)
2268 {
2269    uint8_t ieIdx=0, arrayIdx=0, ieListCnt=0, elementCnt=0, sliceLstIdx=0;
2270
2271    servedPlmn->list.array[arrayIdx]->pLMN_Identity.size = 3*sizeof(uint8_t);
2272    DU_ALLOC(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf, servedPlmn->list.\
2273          array[arrayIdx]->pLMN_Identity.size);
2274    if(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf == NULLP)
2275    {
2276       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2277       return RFAILED;
2278    }
2279    buildPlmnId(duCfgParam.srvdCellLst[arrayIdx].duCellInfo.cellInfo.srvdPlmn[arrayIdx].plmn,\
2280          servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf);
2281    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
2282    if(servedPlmn->list.array[arrayIdx]->iE_Extensions == NULLP)
2283    {
2284       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2285       return RFAILED;
2286    }
2287
2288    ieListCnt=1;
2289    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.count = ieListCnt;
2290    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.size = ieListCnt *sizeof(ServedPLMNs_ItemExtIEs_t *);
2291    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array,servedPlmn->list.array[arrayIdx]->\
2292          iE_Extensions->list.size);
2293    if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array == NULLP)
2294    {
2295       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2296       return RFAILED;
2297    }
2298    for(ieIdx=arrayIdx;ieIdx<ieListCnt;ieIdx++)
2299    {
2300       DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx],\
2301             sizeof(ServedPLMNs_ItemExtIEs_t));
2302       if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx] == NULLP)
2303       {
2304          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2305          return RFAILED;
2306       }
2307    }
2308
2309    ieIdx = 0;
2310    elementCnt = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].taiSliceSuppLst.numSupportedSlices;
2311    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->id =ProtocolIE_ID_id_TAISliceSupportList;
2312    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->criticality = Criticality_ignore;
2313    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.present = \
2314    ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
2315    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2316       list.count = elementCnt;
2317    servedPlmn->list.array[arrayIdx]->\
2318       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2319       list.size = elementCnt * sizeof(SliceSupportItem_t *);
2320    DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2321          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2322          list.array,servedPlmn->list.array[arrayIdx]->\
2323          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.size);
2324    if(servedPlmn->list.array[arrayIdx]->\
2325          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2326          list.array == NULLP)
2327    {
2328       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2329       return RFAILED;
2330    }
2331
2332    for(sliceLstIdx =0; sliceLstIdx< elementCnt; sliceLstIdx++)
2333    {
2334       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2335       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2336       list.array[sliceLstIdx],sizeof( SliceSupportItem_t));
2337       if(servedPlmn->list.array[arrayIdx]->\
2338       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2339       list.array[sliceLstIdx] == NULLP)
2340       {
2341          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2342          return RFAILED;
2343       }
2344
2345       servedPlmn->list.array[arrayIdx]->\
2346       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2347       list.array[sliceLstIdx]->sNSSAI.sST.size = sizeof(uint8_t);
2348       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2349       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2350       list.array[sliceLstIdx]->sNSSAI.sST.buf,servedPlmn->list.array[arrayIdx]->\
2351       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->\
2352       sNSSAI.sST.size);
2353
2354       if(servedPlmn->list.array[arrayIdx]->\
2355       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2356       list.array[sliceLstIdx]->sNSSAI.sST.buf == NULLP)
2357       {
2358          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2359          return RFAILED;
2360       }
2361       servedPlmn->list.array[arrayIdx]->\
2362       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2363       list.array[sliceLstIdx]->sNSSAI.sST.buf[arrayIdx] =  duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
2364       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
2365
2366       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2367       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2368       list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
2369       if(servedPlmn->list.array[arrayIdx]->\
2370       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2371       list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
2372       {
2373          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2374          return RFAILED;
2375       }
2376       servedPlmn->list.array[arrayIdx]->\
2377       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2378       list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
2379       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2380       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2381       list.array[sliceLstIdx]->sNSSAI.sD->buf,servedPlmn->list.array[arrayIdx]->\
2382       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2383       list.array[sliceLstIdx]->sNSSAI.sD->size);
2384       if(servedPlmn->list.array[arrayIdx]->\
2385       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2386       list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
2387       {
2388          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2389          return RFAILED;
2390       }
2391       memcpy(servedPlmn->list.array[arrayIdx]->\
2392       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2393       list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
2394       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sd,\
2395       servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2396       list.array[sliceLstIdx]->sNSSAI.sD->size);
2397    }
2398    return ROK;
2399 }
2400
2401 /*******************************************************************
2402  *
2403  * @brief Fills Nr Fdd Info required in ServCellInfo IE
2404  *
2405  * @details
2406  *
2407  *    Function : fillNrFddInfo
2408  *
2409  *    Functionality: Fills Nr Fdd Info required in ServCellInfo IE
2410  *
2411  * @params[in] FDD_Info_t *fDD
2412  *
2413  * @return ROK     - success
2414  *         RFAILED - failure
2415  *
2416  *****************************************************************/
2417
2418 uint8_t fillNrFddInfo(FDD_Info_t *fDD)
2419 {
2420    fDD->uL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.\
2421       f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn;
2422    fDD->uL_NRFreqInfo.freqBandListNr.list.count = 1;
2423    fDD->uL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t*);
2424    DU_ALLOC(fDD->uL_NRFreqInfo.freqBandListNr.list.\
2425          array, fDD->uL_NRFreqInfo.freqBandListNr.list.size);
2426    if(fDD->uL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2427    {
2428       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
2429       return RFAILED;
2430    }
2431
2432    DU_ALLOC(fDD->uL_NRFreqInfo.freqBandListNr.list.array[0], \
2433       sizeof(FreqBandNrItem_t));
2434    if(fDD->uL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2435    {
2436       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
2437       return RFAILED;
2438    }
2439
2440    fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2441       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
2442       freqBand[0].nrFreqBand;
2443    fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2444    fDD->dL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.\
2445       dlNrFreqInfo.nrArfcn;
2446    fDD->dL_NRFreqInfo.freqBandListNr.list.count = 1;
2447    fDD->dL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
2448    DU_ALLOC(fDD->dL_NRFreqInfo.freqBandListNr.list.array, fDD->dL_NRFreqInfo.freqBandListNr.list.size);
2449    if(fDD->dL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2450    {
2451       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
2452       return RFAILED;
2453    }
2454
2455    DU_ALLOC(fDD->dL_NRFreqInfo.freqBandListNr.list.array[0],  sizeof(FreqBandNrItem_t));
2456    if(fDD->dL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2457    {
2458       DU_LOG("\nERROR  --> Memory allocation failed in fillNrFddInfo");
2459       return RFAILED;
2460    }
2461
2462    fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2463       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
2464       freqBand[0].nrFreqBand;
2465    fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2466
2467    /*Transmission Bandwidth*/
2468    fDD->uL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2469       f1Mode.mode.fdd.ulTxBw.nrScs;
2470    fDD->uL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2471       f1Mode.mode.fdd.ulTxBw.nrb;
2472    fDD->dL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2473       f1Mode.mode.fdd.dlTxBw.nrScs;
2474    fDD->dL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2475       f1Mode.mode.fdd.dlTxBw.nrb;
2476
2477    return ROK;
2478 }
2479
2480 /*******************************************************************
2481  *
2482  * @brief Fills ServCellInfo IE
2483  *
2484  * @details
2485  *
2486  *    Function : fillServedCellInfo
2487  *
2488  *    Functionality: Fills ServCellInfo
2489  *
2490  * @params[in] Pointer to Served_Cell_Information_t *
2491  *
2492  * @return ROK     - success
2493  *         RFAILED - failure
2494  *
2495  *****************************************************************/
2496
2497 uint8_t fillServedCellInfo(Served_Cell_Information_t *srvCellInfo)
2498 {
2499    uint8_t ieIdx, ieListCnt;
2500
2501    /*nRCGI*/
2502    srvCellInfo->nRCGI.pLMN_Identity.size =3*sizeof(uint8_t);
2503    DU_ALLOC(srvCellInfo->nRCGI.pLMN_Identity.buf,\
2504          srvCellInfo->nRCGI.pLMN_Identity.size);
2505    if(srvCellInfo->nRCGI.pLMN_Identity.buf == NULLP)
2506    {
2507       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2508       return RFAILED;
2509    }
2510    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2511          srvCellInfo->nRCGI.pLMN_Identity.buf);
2512    srvCellInfo->nRCGI.nRCellIdentity.size =5*sizeof(uint8_t);
2513    DU_ALLOC(srvCellInfo->nRCGI.nRCellIdentity.buf,\
2514          srvCellInfo->nRCGI.nRCellIdentity.size);
2515    if(srvCellInfo->nRCGI.nRCellIdentity.buf == NULLP)
2516    {
2517       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2518       return RFAILED;
2519    }
2520
2521    fillBitString(&srvCellInfo->nRCGI.nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
2522    /*nRPCI*/
2523    srvCellInfo->nRPCI = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
2524
2525    /*servedPLMNs*/
2526    ieListCnt = 1;
2527    srvCellInfo->servedPLMNs.list.count = ieListCnt;
2528    srvCellInfo->servedPLMNs.list.size = ieListCnt*sizeof(ServedPLMNs_Item_t *);
2529    DU_ALLOC(srvCellInfo->servedPLMNs.list.array, srvCellInfo->servedPLMNs.list.size);
2530    if(srvCellInfo->servedPLMNs.list.array == NULLP)
2531    {
2532       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2533       return RFAILED;
2534    }
2535    for(ieIdx=0; ieIdx < ieListCnt; ieIdx++)
2536    {
2537       DU_ALLOC(srvCellInfo->servedPLMNs.list.array[ieIdx], sizeof(ServedPLMNs_Item_t));
2538       if(srvCellInfo->servedPLMNs.list.array[ieIdx]== NULLP)
2539       {
2540          DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2541          return RFAILED;
2542       }
2543    }
2544    if(fillServedPlmns(&srvCellInfo->servedPLMNs))
2545    {
2546       DU_LOG("\nERROR  --> Failed to fill Served Plmn info");
2547       return RFAILED;
2548    }
2549
2550 #ifndef NR_TDD
2551    /*nR Mode Info with FDD*/
2552    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_fDD;
2553    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.fDD, sizeof(FDD_Info_t));
2554    if(srvCellInfo->nR_Mode_Info.choice.fDD == NULLP)
2555    {
2556       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2557       return RFAILED;
2558    }
2559    if(fillNrFddInfo(srvCellInfo->nR_Mode_Info.choice.fDD))
2560    {
2561        DU_LOG("\nERROR  --> Failed to fill the Nr FDD information");
2562       return RFAILED;
2563    }
2564 #else
2565    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_tDD;
2566    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.tDD, sizeof(TDD_Info_t));
2567    if(srvCellInfo->nR_Mode_Info.choice.tDD == NULLP)
2568    {
2569       DU_LOG("\nERROR  --> Memory allocation failed in fillServedCellInfo");
2570       return RFAILED;
2571    }
2572    if(fillNrTddInfo(srvCellInfo->nR_Mode_Info.choice.tDD) != ROK)
2573    {
2574       DU_LOG("\nERROR  --> Failed to fill the Nr TDD information");
2575       return RFAILED;
2576    }
2577 #endif
2578
2579    /*Measurement timing Config*/
2580    srvCellInfo->measurementTimingConfiguration.size = sizeof(uint8_t);
2581    DU_ALLOC(srvCellInfo->measurementTimingConfiguration.\
2582          buf,srvCellInfo->measurementTimingConfiguration.size);
2583    if(srvCellInfo->measurementTimingConfiguration.buf == NULLP)
2584    {
2585       return RFAILED;
2586    }
2587    srvCellInfo->measurementTimingConfiguration.\
2588          buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
2589
2590    return ROK;
2591 }
2592
2593 /*******************************************************************
2594  *
2595  * @brief Fills ServCellToModItem IE
2596  *
2597  * @details
2598  *
2599  *    Function : fillServCellToModItem
2600  *
2601  *    Functionality: Fills ServCellToModItem IE
2602  *
2603  * @params[in] Pointer to Served_Cells_To_Modify_Item_t *
2604  *
2605  * @return ROK     - success
2606  *         RFAILED - failure
2607  *
2608  *****************************************************************/
2609
2610 uint8_t fillServCellToModItem(Served_Cells_To_Modify_Item_t *modifyItem)
2611 {
2612    /*pLMN_Identity*/
2613    modifyItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2614    DU_ALLOC(modifyItem->oldNRCGI.pLMN_Identity.buf,modifyItem->oldNRCGI.pLMN_Identity.size);
2615    if(modifyItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2616    {
2617       return RFAILED;
2618    }
2619    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2620          modifyItem->oldNRCGI.pLMN_Identity.buf);
2621
2622    /*nRCellIdentity*/
2623    modifyItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2624    DU_ALLOC(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2625          modifyItem->oldNRCGI.nRCellIdentity.size);
2626    if(modifyItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2627    {
2628       return RFAILED;
2629    }
2630    fillBitString(&modifyItem->oldNRCGI.nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
2631
2632    if(fillServedCellInfo(&modifyItem->served_Cell_Information))
2633       return RFAILED;
2634    else
2635       return ROK;
2636 }
2637
2638 /*******************************************************************
2639  *
2640  * @brief Builds ServCellToModList
2641  *
2642  * @details
2643  *
2644  *    Function : buildServCellToModList
2645  *
2646  *    Functionality: Builds the serv cell to Mod List
2647  *
2648  * @params[in] Pointer to Served_Cells_To_Modify_List_t *
2649  *
2650  * @return ROK     - success
2651  *         RFAILED - failure
2652  *
2653  *****************************************************************/
2654
2655 uint8_t buildServCellToModList(Served_Cells_To_Modify_List_t *cellsToModify)
2656 {
2657    uint8_t ieListCnt, ieIdx;
2658    Served_Cells_To_Modify_Item_t *modifyItem = NULLP;
2659
2660    ieListCnt = 1;
2661    cellsToModify->list.count = ieListCnt;
2662    cellsToModify->list.size = ieListCnt*sizeof(Served_Cells_To_Modify_ItemIEs_t *);
2663    DU_ALLOC(cellsToModify->list.array,cellsToModify->list.size);
2664    if(cellsToModify->list.array == NULLP)
2665    {
2666       return RFAILED;
2667    }
2668    for(ieIdx=0; ieIdx< ieListCnt; ieIdx++)
2669    {
2670       DU_ALLOC(cellsToModify->list.array[ieIdx],sizeof(Served_Cells_To_Modify_ItemIEs_t));
2671       if(cellsToModify->list.array[ieIdx] == NULLP)
2672       {
2673          return RFAILED;
2674       }
2675    }
2676    cellsToModify->list.array[0]->id = ProtocolIE_ID_id_Served_Cells_To_Modify_Item;
2677    cellsToModify->list.array[0]->criticality = Criticality_reject;
2678    cellsToModify->list.array[0]->value.present =\
2679       Served_Cells_To_Modify_ItemIEs__value_PR_Served_Cells_To_Modify_Item;
2680    modifyItem=&cellsToModify->list.array[0]->value.choice.Served_Cells_To_Modify_Item;
2681
2682    if(fillServCellToModItem(modifyItem))
2683       return RFAILED;
2684    else
2685       return ROK;
2686 }
2687 /*******************************************************************
2688  *
2689  * @brief filling the DeleteItemList
2690  *
2691  * @details
2692  *
2693  *    Function : fillCellToDeleteItem
2694  *
2695  *    Functionality: Filling the DeleteItemIe
2696  *
2697  * @params[in] Pointer to Served_Cells_To_Delete_ItemIEs_t
2698  *
2699  * @return ROK     - success
2700  *         RFAILED - failure
2701  *
2702  *****************************************************************/
2703 uint8_t fillCellToDeleteItem(struct Served_Cells_To_Delete_ItemIEs *deleteItemIe)
2704 {
2705    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
2706
2707    deleteItemIe->id = ProtocolIE_ID_id_Served_Cells_To_Delete_Item;
2708    deleteItemIe->criticality = Criticality_reject;
2709    deleteItemIe->value.present =\
2710    Served_Cells_To_Delete_ItemIEs__value_PR_Served_Cells_To_Delete_Item;
2711    deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
2712
2713    /*pLMN_Identity*/
2714    deleteItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2715    DU_ALLOC(deleteItem->oldNRCGI.pLMN_Identity.buf,deleteItem->oldNRCGI.pLMN_Identity.size);
2716    if(deleteItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2717    {
2718       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2719       return RFAILED;
2720    }
2721    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2722          deleteItem->oldNRCGI.pLMN_Identity.buf);
2723
2724    /*nRCellIdentity*/
2725    deleteItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2726    DU_ALLOC(deleteItem->oldNRCGI.nRCellIdentity.buf,\
2727          deleteItem->oldNRCGI.nRCellIdentity.size);
2728    if(deleteItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2729    {
2730       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2731       return RFAILED;
2732    }
2733    fillBitString(&deleteItem->oldNRCGI.nRCellIdentity, ODU_VALUE_FOUR, ODU_VALUE_FIVE, duCfgParam.sib1Params.cellIdentity);
2734    return ROK;
2735 }
2736 /*******************************************************************
2737  *
2738  * @brief Builds ServCellToDeleteList
2739  *
2740  * @details
2741  *
2742  *    Function : buildServCellToDeleteList
2743  *
2744  *    Functionality: Builds the serv cell to delete List
2745  *
2746  * @params[in] Pointer to Served_Cells_To_Delete_List_t *
2747  *
2748  * @return ROK     - success
2749  *         RFAILED - failure
2750  *
2751  *****************************************************************/
2752
2753 uint8_t buildServCellToDeleteList(Served_Cells_To_Delete_List_t *cellsToDelete)
2754 {
2755    uint8_t ieListCnt, arrIdx;
2756
2757    ieListCnt = 1;
2758    cellsToDelete->list.count = ieListCnt;
2759    cellsToDelete->list.size = ieListCnt*sizeof(Served_Cells_To_Delete_ItemIEs_t *);
2760
2761    DU_ALLOC(cellsToDelete->list.array,cellsToDelete->list.size);
2762    if(cellsToDelete->list.array == NULLP)
2763    {
2764       DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2765       return RFAILED;
2766    }
2767
2768    for(arrIdx=0; arrIdx< ieListCnt; arrIdx++)
2769    {
2770       DU_ALLOC(cellsToDelete->list.array[arrIdx],sizeof(Served_Cells_To_Delete_ItemIEs_t));
2771       if(cellsToDelete->list.array[arrIdx] == NULLP)
2772       {
2773          DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2774          return RFAILED;
2775       }
2776    }
2777
2778    arrIdx=0;
2779    if(fillCellToDeleteItem((Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx]) !=ROK)
2780    {
2781       DU_LOG("\nERROR  -->  F1AP: buildServCellToDeleteList(): failed to fill Served_Cells_To_Delete_ItemIEs");
2782       return RFAILED;
2783    }
2784    return ROK;
2785 }
2786
2787 /*******************************************************************
2788  *
2789  * @brief Builds and sends the DUConfigUpdate
2790  *
2791  * @details
2792  *
2793  *    Function : BuildAndSendDUConfigUpdate
2794  *
2795  *    Functionality: Constructs the DU Update message and sends
2796  *                   it to the CU through SCTP.
2797  *
2798  * @params[in] void **buf,Buffer to which encoded pattern is written into
2799  * @params[in] int *size,size of buffer
2800  *
2801  * @return ROK     - success
2802  *         RFAILED - failure
2803  *
2804  * ****************************************************************/
2805 uint8_t BuildAndSendDUConfigUpdate(ServCellAction servCellAction)
2806 {
2807    uint8_t ret =0, ieIdx=0, elementCnt=0;
2808    bool memAlloctionFailure = false;
2809    F1AP_PDU_t                 *f1apDuCfg = NULLP;
2810    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
2811    asn_enc_rval_t encRetVal;     /* Encoder return value */
2812
2813    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2814    ret= RFAILED;
2815
2816    while(true)
2817    {
2818       DU_LOG("\nINFO   -->  F1AP : Building DU config update\n");
2819       /* Allocate the memory for F1DuCfg */
2820       DU_ALLOC(f1apDuCfg, sizeof(F1AP_PDU_t));
2821       if(f1apDuCfg == NULLP)
2822       {
2823          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2824          break;
2825       }
2826
2827       f1apDuCfg->present = F1AP_PDU_PR_initiatingMessage;
2828       DU_ALLOC(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2829       if(f1apDuCfg->choice.initiatingMessage == NULLP)
2830       {
2831          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2832          break;
2833       }
2834
2835       f1apDuCfg->choice.initiatingMessage->procedureCode = \
2836                                                            ProcedureCode_id_gNBDUConfigurationUpdate;
2837       f1apDuCfg->choice.initiatingMessage->criticality = Criticality_reject;
2838       f1apDuCfg->choice.initiatingMessage->value.present = \
2839                                                            InitiatingMessage__value_PR_GNBDUConfigurationUpdate;
2840       duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\
2841                     choice.GNBDUConfigurationUpdate;
2842       elementCnt = 3;
2843       duCfgUpdate->protocolIEs.list.count = elementCnt;
2844       duCfgUpdate->protocolIEs.list.size = \
2845                                            elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t*);
2846
2847       /* Initialize the F1Setup members */
2848       DU_ALLOC(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2849       if(duCfgUpdate->protocolIEs.list.array == NULLP)
2850       {
2851          DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2852          break;
2853       }
2854       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
2855       {
2856          DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx],sizeof(GNBDUConfigurationUpdateIEs_t));
2857          if(duCfgUpdate->protocolIEs.list.array[ieIdx] == NULLP)
2858          {
2859             DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2860             memAlloctionFailure = true;
2861             break;
2862          }
2863       }
2864
2865       if(memAlloctionFailure == true)
2866       {
2867          break;
2868       }
2869       /*TransactionID*/
2870       ieIdx = 0;
2871       duCfgUpdate->protocolIEs.list.array[ieIdx]->id=ProtocolIE_ID_id_TransactionID;
2872       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
2873       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2874       GNBDUConfigurationUpdateIEs__value_PR_TransactionID;
2875       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = TRANS_ID;
2876
2877       ieIdx++;
2878       if(servCellAction == SERV_CELL_TO_MODIFY)
2879       {
2880          /*Served Cell to Modify */
2881          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2882          ProtocolIE_ID_id_Served_Cells_To_Modify_List;
2883          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2884          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2885          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Modify_List;
2886          if(buildServCellToModList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2887                   Served_Cells_To_Modify_List))
2888          {
2889             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToModList");
2890             break;
2891          }
2892       }
2893       else
2894       {
2895          /*Served Cell to Delete */
2896          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2897          ProtocolIE_ID_id_Served_Cells_To_Delete_List;
2898          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2899          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2900          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Delete_List;
2901          if(buildServCellToDeleteList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2902          Served_Cells_To_Delete_List)!=ROK)
2903          {
2904             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToDeleteList");
2905             break;
2906          }
2907
2908       }
2909       // NOTE :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
2910       /*GNB DU ID */
2911       ieIdx++;
2912       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
2913       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
2914       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2915       GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID;
2916       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size = sizeof(uint8_t);
2917       DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2918             duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2919       if(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == NULLP)
2920       {
2921          DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): Memory allocation failed for GNB_DU_ID");
2922          break;
2923       }
2924       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] = duCfgParam.duId;
2925
2926       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
2927
2928       /* Encode the DU Config Update type as APER */
2929       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
2930       encBufSize = 0;
2931       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
2932
2933       /* Checking encode results */
2934       if(encRetVal.encoded == ENCODE_FAIL)
2935       {
2936          DU_LOG("ERROR  -->  F1AP : Could not encode DUConfigUpdate structure (at %s)\n",\
2937                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2938          break;
2939       }
2940       else
2941       {
2942          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DUConfigUpdate\n");
2943          for(ieIdx =0; ieIdx < encBufSize; ieIdx++)
2944          {
2945             printf("%x",encBuf[ieIdx]);
2946          }
2947       }
2948       /* Sending msg */
2949       if(sendF1APMsg() != ROK)
2950       {
2951          DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update failed");
2952          break;
2953       }
2954
2955       ret = ROK;
2956       break;
2957    }
2958
2959    addToReservedF1apPduList(TRANS_ID,f1apDuCfg);
2960    return ret;
2961 }
2962
2963
2964 /*******************************************************************
2965  *
2966  * @brief free the ULRRCMessageTransfer
2967  *
2968  * @details
2969  *
2970  *    Function : FreeULRRCMessageTransfer
2971  *
2972  *    Functionality: Deallocating the memory of variable allocated in
2973  *                      FreeULRRCMessageTransfer
2974  *
2975  * @params[in]
2976  *
2977  * @return ROK     - void
2978  *
2979  ******************************************************************/
2980 void FreeULRRCMessageTransfer( F1AP_PDU_t *f1apMsg)
2981 {
2982    uint8_t idx1;
2983    ULRRCMessageTransfer_t  *ulRRCMsg;
2984
2985    if(f1apMsg != NULLP)
2986    {
2987       if(f1apMsg->choice.initiatingMessage != NULLP)
2988       {
2989          ulRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2990          if(ulRRCMsg->protocolIEs.list.array != NULLP)
2991          {
2992             for(idx1=0;idx1<ulRRCMsg->protocolIEs.list.count;idx1++)
2993             {
2994                if(ulRRCMsg->protocolIEs.list.array[idx1] != NULLP)
2995                {
2996                   if(ulRRCMsg->protocolIEs.list.array[idx1]->value.present ==
2997                         ULRRCMessageTransferIEs__value_PR_RRCContainer)
2998                   {
2999                      DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
3000                            ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
3001                   }
3002                   DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1],sizeof(ULRRCMessageTransferIEs_t));
3003                }
3004             }
3005             DU_FREE(ulRRCMsg->protocolIEs.list.array,ulRRCMsg->protocolIEs.list.size );
3006          }
3007          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
3008       }
3009       DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
3010    }
3011 }
3012 /*******************************************************************
3013  *
3014  * @brief Builds and sends the ULRRCMessageTransfer
3015  *
3016  * @details
3017  *
3018  *    Function : BuildAndSendULRRCMessageTransfer
3019  *
3020  *    Functionality: Constructs the UL RRC Message Transfer and sends
3021  *                   it to the CU through SCTP.
3022  *
3023  * @params[in]
3024  *
3025  * @return ROK     - success
3026  *         RFAILED - failure
3027  *
3028  * ****************************************************************/
3029 uint8_t BuildAndSendULRRCMessageTransfer(DuUeCb  ueCb, uint8_t lcId, \
3030       uint16_t msgLen, uint8_t *rrcMsg)
3031 {
3032    uint8_t   elementCnt =0;
3033    uint8_t   idx1 =0;
3034    uint8_t   idx =0;
3035    F1AP_PDU_t                   *f1apMsg = NULLP;
3036    ULRRCMessageTransfer_t       *ulRRCMsg = NULLP;
3037    asn_enc_rval_t               encRetVal;        /* Encoder return value */
3038    uint8_t ret =RFAILED;
3039
3040    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
3041
3042    while(true)
3043    {
3044       DU_LOG("\n INFO   -->  F1AP : Building UL RRC Message Transfer Message\n");
3045
3046       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
3047       if(f1apMsg == NULLP)
3048       {
3049          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
3050          break;
3051       }
3052       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
3053       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
3054       if(f1apMsg->choice.initiatingMessage == NULLP)
3055       {
3056          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
3057          break;
3058       }
3059       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_ULRRCMessageTransfer;
3060       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
3061       f1apMsg->choice.initiatingMessage->value.present = \
3062                                                          InitiatingMessage__value_PR_ULRRCMessageTransfer;
3063       ulRRCMsg =
3064          &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
3065       elementCnt = 4;
3066       ulRRCMsg->protocolIEs.list.count = elementCnt;
3067       ulRRCMsg->protocolIEs.list.size = \
3068                                         elementCnt * sizeof(ULRRCMessageTransferIEs_t *);
3069
3070       /* Initialize the F1Setup members */
3071       DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size);
3072       if(ulRRCMsg->protocolIEs.list.array == NULLP)
3073       {
3074          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
3075          break;
3076       }
3077       for(idx=0; idx<elementCnt; idx++)
3078       {
3079          DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t));
3080          if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP)
3081          {
3082             break;
3083          }
3084       }
3085
3086       idx1 = 0;
3087
3088       /*GNB CU UE F1AP ID*/
3089       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
3090       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
3091       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
3092                                                               ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
3093       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = ueCb.gnbCuUeF1apId;
3094
3095       /*GNB DU UE F1AP ID*/
3096       idx1++;
3097       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
3098       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
3099       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
3100                                                               ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
3101       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = ueCb.gnbDuUeF1apId;
3102
3103       /*SRBID*/
3104       idx1++;
3105       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
3106       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
3107       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
3108                                                               ULRRCMessageTransferIEs__value_PR_SRBID;
3109       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = lcId;
3110
3111       /*RRCContainer*/
3112       idx1++;
3113       ulRRCMsg->protocolIEs.list.array[idx1]->id  = ProtocolIE_ID_id_RRCContainer;
3114       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
3115       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
3116                                                               ULRRCMessageTransferIEs__value_PR_RRCContainer;
3117       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size = msgLen;
3118       DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
3119             ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
3120       if(!ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
3121       {
3122          DU_LOG(" ERROR  -->  F1AP : Memory allocation for BuildAndSendULRRCMessageTransfer failed");
3123          break;
3124       }
3125       memset(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, 0, msgLen);
3126       memcpy(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, \
3127             rrcMsg, ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
3128
3129       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
3130
3131       /* Encode the F1SetupRequest type as APER */
3132       memset(encBuf, 0, ENC_BUF_MAX_LEN);
3133       encBufSize = 0;
3134       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
3135             encBuf);
3136       /* Encode results */
3137       if(encRetVal.encoded == ENCODE_FAIL)
3138       {
3139          DU_LOG( "\nERROR  -->  F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
3140                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
3141          break;
3142       }
3143       else
3144       {
3145          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
3146          for(int i=0; i< encBufSize; i++)
3147          {
3148             printf("%x",encBuf[i]);
3149          }
3150       }
3151
3152       /* Sending  msg  */
3153       if(sendF1APMsg()  !=      ROK)
3154       {
3155          DU_LOG("\nERROR  -->   F1AP : Sending  UL RRC Message Transfer Failed");
3156          break;
3157       }
3158       ret = ROK;
3159       break;
3160    }
3161    FreeULRRCMessageTransfer(f1apMsg);
3162
3163    return ret;
3164 }/* End of BuildAndSendULRRCMessageTransfer*/
3165
3166 /*******************************************************************
3167  *
3168  * @brief Builds tag config
3169  *
3170  * @details
3171  *
3172  *    Function : BuildTagConfig
3173  *
3174  *    Functionality: Builds tag config in MacCellGroupConfig
3175  *
3176  * @params[in] TAG_Config *tag_Config
3177  *
3178  * @return ROK     - success
3179  *         RFAILED - failure
3180  *
3181  * ****************************************************************/
3182 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
3183 {
3184    struct TAG_Config__tag_ToAddModList *tagList;
3185    uint8_t                     idx, elementCnt;
3186
3187    tagConfig->tag_ToReleaseList = NULLP;
3188    tagConfig->tag_ToAddModList = NULLP;
3189    DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
3190    if(!tagConfig->tag_ToAddModList)
3191    {
3192       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
3193       return RFAILED;
3194    }
3195
3196    elementCnt = 1; //ODU_VALUE_ONE;
3197    tagList = tagConfig->tag_ToAddModList;
3198    tagList->list.count = elementCnt;
3199    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
3200
3201    tagList->list.array = NULLP;
3202    DU_ALLOC(tagList->list.array, tagList->list.size);
3203    if(!tagList->list.array)
3204    {
3205       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
3206       return RFAILED;
3207    }
3208
3209    for(idx=0; idx<tagList->list.count; idx++)
3210    {
3211       tagList->list.array[idx] = NULLP;
3212       DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
3213       if(!tagList->list.array[idx])
3214       {
3215          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
3216          return RFAILED;
3217       }
3218    }
3219
3220    idx = 0;
3221    tagList->list.array[idx]->tag_Id = TAG_ID;
3222    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
3223
3224    return ROK;
3225 }
3226
3227 /*******************************************************************
3228  *
3229  * @brief Builds PHR Config
3230  *
3231  * @details
3232  *
3233  *    Function : BuildPhrConfig
3234  *
3235  *    Functionality: Builds phrConfig in MacCellGroupConfig
3236  *
3237  * @params[in] PHR Config *
3238  *
3239  * @return ROK     - success
3240  *         RFAILED - failure
3241  *
3242  * ****************************************************************/
3243 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
3244 {
3245
3246    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
3247    phrConfig->choice.setup = NULLP;
3248    DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
3249    if(!phrConfig->choice.setup)
3250    {
3251       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
3252       return RFAILED;
3253    }
3254
3255    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
3256    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
3257    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
3258    phrConfig->choice.setup->multiplePHR              = false;
3259    phrConfig->choice.setup->dummy                    = false;
3260    phrConfig->choice.setup->phr_Type2OtherCell       = false;
3261    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
3262
3263    return ROK;
3264 }
3265
3266 /*******************************************************************
3267  *
3268  * @brief Builds BSR Config
3269  *
3270  * @details
3271  *
3272  *    Function : BuildBsrConfig
3273  *
3274  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
3275  *
3276  * @params[in] BSR_Config *bsrConfig
3277  *
3278  * @return ROK     - success
3279  *         RFAILED - failure
3280  *
3281  * ****************************************************************/
3282 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
3283 {
3284    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
3285    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
3286    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
3287
3288    return ROK;
3289 }
3290
3291 /*******************************************************************
3292  *
3293  * @brief Builds scheduling request config
3294  *
3295  * @details
3296  *
3297  *    Function : BuildSchedulingReqConfig
3298  *
3299  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
3300  *
3301  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
3302  *
3303  * @return ROK     - success
3304  *         RFAILED - failure
3305  *
3306  * ****************************************************************/
3307 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
3308 {
3309    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
3310    uint8_t                     idx, elementCnt;
3311
3312    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
3313    DU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
3314          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
3315    if(!schedulingRequestConfig->schedulingRequestToAddModList)
3316    {
3317       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3318       return RFAILED;
3319    }
3320
3321    elementCnt = 1; //ODU_VALUE_ONE;
3322    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
3323    schReqList->list.count = elementCnt;
3324    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
3325
3326    schReqList->list.array = NULLP;
3327    DU_ALLOC(schReqList->list.array, schReqList->list.size);
3328    if(!schReqList->list.array)
3329    {
3330       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3331       return RFAILED;
3332    }
3333
3334    for(idx=0;idx<schReqList->list.count; idx++)
3335    {
3336       schReqList->list.array[idx] = NULLP;
3337       DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
3338       if(!schReqList->list.array[idx])
3339       {
3340          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3341          return RFAILED;
3342       }
3343    }
3344
3345    idx = 0;
3346    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
3347
3348    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
3349    DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
3350    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
3351    {
3352       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3353       return RFAILED;
3354    }
3355    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
3356    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
3357    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
3358
3359    return ROK;
3360 }
3361
3362 /*******************************************************************
3363  *
3364  * @brief Builds RLC Config
3365  *
3366  * @details
3367  *
3368  *    Function : BuildRlcConfig
3369  *
3370  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
3371  *
3372  * @params[in] RLC_Config *rlcConfig
3373  *
3374  * @return ROK     - success
3375  *         RFAILED - failure
3376  *
3377  * ****************************************************************/
3378 uint8_t BuildRlcConfig(struct RLC_Config *rlcConfig)
3379 {
3380
3381    rlcConfig->present = RLC_Config_PR_am;
3382
3383    rlcConfig->choice.am = NULLP;
3384    DU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
3385    if(!rlcConfig->choice.am)
3386    {
3387       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3388       return RFAILED;
3389    }
3390
3391    /* UL */
3392    rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
3393    DU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3394    if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
3395    {
3396       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3397       return RFAILED;
3398    }
3399    *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3400    rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
3401    rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
3402    rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
3403    rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
3404
3405    /* DL */
3406    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
3407    DU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3408    if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
3409    {
3410       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3411       return RFAILED;
3412    }
3413    *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3414    rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
3415    rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
3416
3417    return ROK;
3418 }
3419
3420 /*******************************************************************
3421  *
3422  * @brief Builds MAC LC Config
3423  *
3424  * @details
3425  *
3426  *    Function : BuildMacLCConfig
3427  *
3428  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
3429  *
3430  * @params[in] struct LogicalChannelConfig macLcConfig
3431  *
3432  * @return ROK     - success
3433  *         RFAILED - failure
3434  *
3435  * ****************************************************************/
3436 uint8_t BuildMacLCConfig(struct LogicalChannelConfig *macLcConfig)
3437 {
3438
3439    macLcConfig->ul_SpecificParameters = NULLP;
3440    DU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
3441    if(!macLcConfig->ul_SpecificParameters)
3442    {
3443       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3444       return RFAILED;
3445    }
3446
3447    macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
3448    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     PRIORTISIED_BIT_RATE;
3449    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     BUCKET_SIZE_DURATION;
3450    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
3451    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
3452    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
3453    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
3454
3455    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
3456    DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
3457    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
3458    {
3459       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3460       return RFAILED;
3461    }
3462    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
3463
3464    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
3465    DU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
3466    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
3467    {
3468       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3469       return RFAILED;
3470    }
3471    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
3472
3473    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
3474    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
3475    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
3476
3477    return ROK;
3478 }
3479
3480 /*******************************************************************
3481  *
3482  * @brief Builds RLC Bearer to Add/Mod list
3483  *
3484  * @details
3485  *
3486  *    Function :BuildRlcBearerToAddModList
3487  *
3488  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
3489  *
3490  * @params[in] rlc_BearerToAddModList
3491  *
3492  * @return ROK     - success
3493  *         RFAILED - failure
3494  *
3495  * ****************************************************************/
3496 uint8_t BuildRlcBearerToAddModList(struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
3497 {
3498    uint8_t                     idx, elementCnt;
3499
3500    elementCnt = 1;
3501    rlcBearerList->list.count = elementCnt;
3502    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
3503
3504    rlcBearerList->list.array = NULLP;
3505    DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
3506    if(!rlcBearerList->list.array)
3507    {
3508       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3509       return RFAILED;
3510    }
3511
3512    for(idx=0; idx<rlcBearerList->list.count; idx++)
3513    {
3514       rlcBearerList->list.array[idx] = NULLP;
3515       DU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
3516       if(!rlcBearerList->list.array[idx])
3517       {
3518          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3519          return RFAILED;
3520       }
3521    }
3522
3523    idx = 0;
3524    rlcBearerList->list.array[idx]->logicalChannelIdentity = SRB1_LCID;
3525
3526    DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, \
3527       sizeof(struct RLC_BearerConfig__servedRadioBearer));
3528    if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3529    {
3530       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3531       return RFAILED;
3532    }
3533
3534    rlcBearerList->list.array[idx]->servedRadioBearer->present = \
3535       RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
3536    rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = \
3537       SRB1_LCID;
3538
3539    rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3540    rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3541    DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3542    if(!rlcBearerList->list.array[idx]->rlc_Config)
3543    {
3544       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3545       return RFAILED;
3546    }
3547
3548    if(BuildRlcConfig(rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3549    {
3550       DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3551       return RFAILED;
3552    }
3553
3554    rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3555    DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, \
3556       sizeof(struct LogicalChannelConfig));
3557    if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3558    {
3559       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3560       return RFAILED;
3561    }
3562
3563    if(BuildMacLCConfig(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3564    {
3565       DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3566       return RFAILED;
3567    }
3568
3569    return ROK;
3570 }
3571
3572 /*******************************************************************
3573  *
3574  * @brief Build Control resource set to add/modify list
3575  *
3576  * @details
3577  *
3578  *    Function : BuildControlRSetToAddModList
3579  *
3580  *    Functionality: Build Control resource set to add/modify list
3581  *
3582  * @params[in]
3583  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3584  *
3585  * @return ROK     - success
3586  *         RFAILED - failure
3587  *
3588  * ****************************************************************/
3589    uint8_t BuildControlRSetToAddModList
3590 (
3591  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3592  )
3593 {
3594    uint8_t idx;
3595    uint8_t elementCnt;
3596    uint8_t numBytes, bitsUnused;
3597    struct ControlResourceSet *controlRSet;
3598    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3599    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3600
3601
3602    elementCnt = 1;
3603    controlRSetList->list.count = elementCnt;
3604    controlRSetList->list.size = \
3605                                 elementCnt * sizeof(struct ControlResourceSet *);
3606
3607    controlRSetList->list.array = NULLP;
3608    DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3609    if(!controlRSetList->list.array)
3610    {
3611       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3612       return RFAILED;
3613    }
3614
3615    for(idx = 0; idx < elementCnt; idx++)
3616    {
3617       controlRSetList->list.array[idx] = NULLP;
3618       DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3619       if(!controlRSetList->list.array[idx])
3620       {
3621          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3622          return RFAILED;
3623       }
3624    }
3625
3626    idx=0;
3627    controlRSet = controlRSetList->list.array[idx];
3628
3629    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3630
3631    /* size 6 bytes
3632     * 3 LSBs unsued
3633     * Bit string stored ff0000000000
3634     */
3635    numBytes = 6;
3636    bitsUnused = 3;
3637    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3638
3639    controlRSet->frequencyDomainResources.buf = NULLP;
3640    DU_ALLOC(controlRSet->frequencyDomainResources.buf, \
3641          controlRSet->frequencyDomainResources.size);
3642    if(!controlRSet->frequencyDomainResources.buf)
3643    {
3644       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3645       return RFAILED;
3646    }
3647
3648    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3649    coreset0EndPrb = CORESET0_END_PRB;
3650    coreset1StartPrb = coreset0EndPrb + 6;
3651    coreset1NumPrb = CORESET1_NUM_PRB;
3652    /* calculate the PRBs */
3653    fillCoresetFeqDomAllocMap(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3654    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3655    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3656
3657    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3658    controlRSet->cce_REG_MappingType.present = \
3659                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3660
3661    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3662    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3663    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3664    controlRSet->tci_PresentInDCI = NULLP;
3665 #if 0
3666    uint8_t tciStateIdx;
3667
3668    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3669          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3670    if(!controlRset->tci_StatesPDCCH_ToAddList)
3671    {
3672       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3673       return RFAILED;
3674    }
3675
3676    elementCnt = 1;
3677    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3678    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3679    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3680          controlRset->tci_StatesPDCCH_ToAddList->list.size)
3681       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3682       {
3683          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3684          return RFAILED;
3685       }
3686
3687    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3688    {
3689       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3690       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3691       {
3692          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3693          return RFAILED;
3694       }
3695    }
3696
3697    tciStateIdx = 0;
3698    /* TODO */
3699    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3700
3701    DU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3702    if(!controlRset->tci_PresentInDCI)
3703    {
3704       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3705       return RFAILED;
3706    }
3707    /* TODO */
3708    *(controlRset->tci_PresentInDCI);
3709 #endif
3710
3711    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3712    DU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3713    if(!controlRSet->pdcch_DMRS_ScramblingID)
3714    {
3715       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3716       return RFAILED;
3717    }
3718    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3719
3720    return ROK;
3721 } /* End BuildControlRSetToAddModList */
3722
3723 /*******************************************************************
3724  *
3725  * @brief Build search space to add/modify list
3726  *
3727  * @details
3728  *
3729  *    Function : BuildSearchSpcToAddModList
3730  *
3731  *    Functionality: Build search space to add/modify list
3732  *
3733  * @params[in]
3734  * @return ROK     - success
3735  *         RFAILED - failure
3736  *
3737  * ****************************************************************/
3738    uint8_t BuildSearchSpcToAddModList
3739 (
3740  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
3741  )
3742 {
3743    uint8_t idx;
3744    uint8_t numBytes;
3745    uint8_t byteIdx;
3746    uint8_t bitsUnused;
3747    uint8_t elementCnt;
3748    struct SearchSpace *searchSpc;
3749
3750    elementCnt = 1;
3751    searchSpcList->list.count = elementCnt;
3752    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3753
3754    searchSpcList->list.array = NULLP;
3755    DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3756    if(!searchSpcList->list.array)
3757    {
3758       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3759       return RFAILED;
3760    }
3761
3762    for(idx = 0; idx < elementCnt; idx++)
3763    {
3764       searchSpcList->list.array[idx] = NULLP;
3765       DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3766       if(!searchSpcList->list.array[idx])
3767       {
3768          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3769          return RFAILED;
3770       }
3771    }
3772
3773    idx = 0;
3774    searchSpc = searchSpcList->list.array[idx];
3775
3776    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3777
3778    searchSpc->controlResourceSetId = NULLP;
3779    DU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3780    if(!searchSpc->controlResourceSetId)
3781    {
3782       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3783       return RFAILED;
3784    }
3785    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3786
3787    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3788    DU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
3789          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3790    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3791    {
3792       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3793       return RFAILED;
3794    }
3795    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
3796                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3797
3798    searchSpc->duration = NULLP;
3799    searchSpc->monitoringSymbolsWithinSlot = NULLP;
3800    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3801    if(!searchSpc->monitoringSymbolsWithinSlot)
3802    {
3803       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3804       return RFAILED;
3805    }
3806
3807    /* Values taken from reference logs :
3808     * size 2 bytes
3809     * 2 LSBs unsued
3810     * Bit string stores 8000
3811     */
3812    numBytes = 2;
3813    bitsUnused = 2;
3814
3815    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3816    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3817    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
3818          searchSpc->monitoringSymbolsWithinSlot->size);
3819    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3820    {
3821       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3822       return RFAILED;
3823    }
3824
3825    byteIdx = 0;
3826    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
3827                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3828    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3829    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3830
3831    searchSpc->nrofCandidates = NULLP;
3832    DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3833    if(!searchSpc->nrofCandidates)
3834    {
3835       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3836       return RFAILED;
3837    }
3838
3839    searchSpc->nrofCandidates->aggregationLevel1 = \
3840                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3841    searchSpc->nrofCandidates->aggregationLevel2 = \
3842                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3843    searchSpc->nrofCandidates->aggregationLevel4 = \
3844                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3845    searchSpc->nrofCandidates->aggregationLevel8 = \
3846                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3847    searchSpc->nrofCandidates->aggregationLevel16 = \
3848                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3849
3850    searchSpc->searchSpaceType = NULLP;
3851    DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3852    if(!searchSpc->searchSpaceType)
3853    {
3854       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3855       return RFAILED;
3856    }
3857
3858    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3859
3860    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3861    DU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
3862          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3863    if(!searchSpc->searchSpaceType->choice.ue_Specific)
3864    {
3865       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3866       return RFAILED;
3867    }
3868    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
3869                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3870
3871    return ROK;
3872 }/* End BuildSearchSpcToAddModList */
3873
3874 /*******************************************************************
3875  *
3876  * @brief Builds BWP DL dedicated PDCCH config
3877  *
3878  * @details
3879  *
3880  *    Function : BuildBWPDlDedPdcchCfg
3881  *
3882  *    Functionality: Builds BWP DL dedicated PDCCH config
3883  *
3884  * @params[in] struct PDCCH_Config *pdcchCfg
3885  *
3886  * @return ROK     - success
3887  *         RFAILED - failure
3888  *
3889  * ****************************************************************/
3890 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
3891 {
3892    pdcchCfg->controlResourceSetToAddModList = NULLP;
3893    DU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
3894          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3895    if(!pdcchCfg->controlResourceSetToAddModList)
3896    {
3897       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3898       return RFAILED;
3899    }
3900
3901    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
3902    {
3903       return RFAILED;
3904    }
3905
3906    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3907
3908    pdcchCfg->searchSpacesToAddModList = NULLP;
3909    DU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3910          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3911    if(!pdcchCfg->searchSpacesToAddModList)
3912    {
3913       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3914       return RFAILED;
3915    }
3916
3917    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3918    {
3919       return RFAILED;
3920    }
3921
3922    pdcchCfg->searchSpacesToReleaseList = NULLP;
3923    pdcchCfg->downlinkPreemption = NULLP;
3924    pdcchCfg->tpc_PUSCH = NULLP;
3925    pdcchCfg->tpc_PUCCH = NULLP;
3926    pdcchCfg->tpc_SRS = NULLP;
3927
3928    return ROK;
3929 }
3930
3931 /*******************************************************************
3932  *
3933  * @brief Builds DMRS DL PDSCH Mapping type A
3934  *
3935  * @details
3936  *
3937  *    Function : BuildDMRSDLPdschMapTypeA
3938  *
3939  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3940  *
3941  * @params[in]
3942  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3943  * @return ROK     - success
3944  *         RFAILED - failure
3945  *
3946  * ****************************************************************/
3947    uint8_t BuildDMRSDLPdschMapTypeA
3948 (
3949  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3950  )
3951 {
3952    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3953    dmrsDlCfg->choice.setup = NULLP;
3954    DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3955    if(!dmrsDlCfg->choice.setup)
3956    {
3957       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3958       return RFAILED;
3959    }
3960
3961    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3962    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3963    DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3964    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3965    {
3966       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3967       return RFAILED;
3968    }
3969    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3970
3971    dmrsDlCfg->choice.setup->maxLength = NULLP;
3972    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3973    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3974    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3975
3976    return ROK;
3977 }
3978
3979 /*******************************************************************
3980  *
3981  * @brief Builds TCI states to add/modify list
3982  *
3983  * @details
3984  *
3985  *    Function : BuildTCIStatesToAddModList
3986  *
3987  *    Functionality:Builds TCI states to add/modify list
3988  *
3989  * @params[in]
3990  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3991  *
3992  * @return ROK     - success
3993  *         RFAILED - failure
3994  *
3995  * ****************************************************************/
3996 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3997 {
3998    return ROK;
3999 }
4000
4001 /*******************************************************************
4002  *
4003  * @brief Builds PDSCH time domain allocation list
4004  *
4005  * @details
4006  *
4007  *    Function : BuildPdschTimeDomAllocList
4008  *
4009  *    Functionality: Builds PDSCH time domain allocation list
4010  *
4011  * @params[in]
4012  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
4013  *
4014  * @return ROK     - success
4015  *         RFAILED - failure
4016  *
4017  * ****************************************************************/
4018    uint8_t BuildPdschTimeDomAllocList
4019 (
4020  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
4021  )
4022 {
4023    uint8_t idx;
4024    uint8_t elementCnt;
4025    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
4026
4027    timeDomAllocList->present = \
4028                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
4029
4030    timeDomAllocList->choice.setup = NULLP;
4031    DU_ALLOC(timeDomAllocList->choice.setup, \
4032          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
4033    if(!timeDomAllocList->choice.setup)
4034    {
4035       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4036       return RFAILED;
4037    }
4038
4039    elementCnt = 2;
4040    timeDomAllocList->choice.setup->list.count = elementCnt;
4041    timeDomAllocList->choice.setup->list.size = \
4042                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
4043
4044    timeDomAllocList->choice.setup->list.array = NULLP;
4045    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
4046          timeDomAllocList->choice.setup->list.size);
4047    if(!timeDomAllocList->choice.setup->list.array)
4048    {
4049       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4050       return RFAILED;
4051    }
4052
4053    for(idx = 0; idx < elementCnt; idx++)
4054    {
4055       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4056       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
4057             sizeof(struct PDSCH_TimeDomainResourceAllocation));
4058       if(!timeDomAllocList->choice.setup->list.array[idx])
4059       {
4060          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4061          return RFAILED;
4062       }
4063    }
4064
4065    idx = 0;
4066    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4067    DU_ALLOC(timeDomAlloc->k0, sizeof(long));
4068    if(!timeDomAlloc->k0)
4069    {
4070       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4071       return RFAILED;
4072    }
4073    *(timeDomAlloc->k0) = 0;
4074    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
4075    timeDomAlloc->startSymbolAndLength = \
4076                                         calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
4077
4078    idx++;
4079    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4080    DU_ALLOC(timeDomAlloc->k0, sizeof(long));
4081    if(!timeDomAlloc->k0)
4082    {
4083       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
4084       return RFAILED;
4085    }
4086    *(timeDomAlloc->k0) = 1;
4087    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
4088    timeDomAlloc->startSymbolAndLength = calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
4089
4090    return ROK;
4091 }
4092
4093 /*******************************************************************
4094  *
4095  * @brief Builds PDSCH PRB Bundling type
4096  *
4097  * @details
4098  *
4099  *    Function : BuildPdschPrbBundlingType
4100  *
4101  *    Functionality: Builds PDSCH PRB Bundling type
4102  *
4103  * @params[in]
4104  * struct PDSCH_Config__prb_BundlingType *prbBndlType
4105  *
4106  * @return ROK     - success
4107  *         RFAILED - failure
4108  *
4109  * ****************************************************************/
4110    uint8_t BuildPdschPrbBundlingType
4111 (
4112  struct PDSCH_Config__prb_BundlingType *prbBndlType
4113  )
4114 {
4115    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
4116
4117    prbBndlType->choice.staticBundling = NULLP;
4118    DU_ALLOC(prbBndlType->choice.staticBundling, \
4119          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
4120    if(!prbBndlType->choice.staticBundling)
4121    {
4122       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
4123       return RFAILED;
4124    }
4125    prbBndlType->choice.staticBundling->bundleSize = NULLP;
4126
4127    return ROK;
4128 }
4129
4130 /*******************************************************************
4131  *
4132  * @brief Builds BWP DL dedicated PDSCH config
4133  *
4134  * @details
4135  *
4136  *    Function : BuildBWPDlDedPdschCfg
4137  *
4138  *    Functionality: Builds BWP DL dedicated PDSCH config
4139  *
4140  * @params[in] struct PDSCH_Config *pdschCfg
4141  *
4142  * @return ROK     - success
4143  *         RFAILED - failure
4144  *
4145  * ****************************************************************/
4146 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
4147 {
4148    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
4149
4150    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
4151    DU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
4152          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
4153    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
4154    {
4155       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4156       return RFAILED;
4157    }
4158
4159    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
4160    {
4161       return RFAILED;
4162    }
4163
4164    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
4165    pdschCfg->tci_StatesToAddModList = NULLP;
4166    pdschCfg->tci_StatesToReleaseList = NULLP;
4167    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
4168 #if 0
4169    DU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
4170    if(!pdschCfg->tci_StatesToAddModList)
4171    {
4172       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4173       return RFAILED;
4174    }
4175    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
4176    {
4177       return RFAILED;
4178    }
4179 #endif
4180
4181    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
4182
4183    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
4184    DU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
4185          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
4186    if(!pdschCfg->pdsch_TimeDomainAllocationList)
4187    {
4188       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4189       return RFAILED;
4190    }
4191
4192    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
4193    {
4194       return RFAILED;
4195    }
4196
4197    pdschCfg->pdsch_AggregationFactor = NULLP;
4198    pdschCfg->rateMatchPatternToAddModList = NULLP;
4199    pdschCfg->rateMatchPatternToReleaseList = NULLP;
4200    pdschCfg->rateMatchPatternGroup1 = NULLP;
4201    pdschCfg->rateMatchPatternGroup2 = NULLP;
4202    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
4203    pdschCfg->mcs_Table = NULLP;
4204
4205    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
4206    DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
4207    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
4208    {
4209       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4210       return RFAILED;
4211    }
4212    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
4213
4214    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
4215    {
4216       return RFAILED;
4217    }
4218
4219    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
4220    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
4221    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4222    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4223    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4224    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4225    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
4226
4227    return ROK;
4228 }
4229
4230 /*******************************************************************
4231  *
4232  * @brief Builds intitial DL BWP
4233  * @details
4234  *
4235  *    Function : BuildInitialDlBWP
4236  *
4237  *    Functionality: Builds intitial DL BWP in spCellCfgDed
4238  *
4239  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4240  *
4241  * @return ROK     - success
4242  *         RFAILED - failure
4243  *
4244  * ****************************************************************/
4245 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
4246 {
4247    dlBwp->pdcch_Config = NULLP;
4248    DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
4249    if(!dlBwp->pdcch_Config)
4250    {
4251       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4252       return RFAILED;
4253    }
4254    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
4255
4256    dlBwp->pdcch_Config->choice.setup = NULLP;
4257    DU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
4258    if(!dlBwp->pdcch_Config->choice.setup)
4259    {
4260       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4261       return RFAILED;
4262    }
4263    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
4264    {
4265       return RFAILED;
4266    }
4267
4268    dlBwp->pdsch_Config = NULLP;
4269    DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
4270    if(!dlBwp->pdsch_Config)
4271    {
4272       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4273       return RFAILED;
4274    }
4275    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
4276
4277    dlBwp->pdsch_Config->choice.setup = NULLP;
4278    DU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
4279    if(!dlBwp->pdsch_Config->choice.setup)
4280    {
4281       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4282       return RFAILED;
4283    }
4284
4285    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
4286    {
4287       return RFAILED;
4288    }
4289
4290    dlBwp->sps_Config = NULLP;
4291    dlBwp->radioLinkMonitoringConfig = NULLP;
4292    return ROK;
4293 }
4294
4295 /*******************************************************************
4296  *
4297  * @brief Builds DMRS UL Pusch Mapping type A
4298  *
4299  * @details
4300  *
4301  *    Function : BuildDMRSULPuschMapTypeA
4302  *
4303  *    Functionality: Builds DMRS UL Pusch Mapping type A
4304  *
4305  * @params[in]
4306  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4307  * @return ROK     - success
4308  *         RFAILED - failure
4309  *
4310  * ****************************************************************/
4311    uint8_t BuildDMRSULPuschMapTypeA
4312 (
4313  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4314  )
4315 {
4316    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
4317    dmrsUlCfg->choice.setup= NULLP;
4318    DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
4319    if(!dmrsUlCfg->choice.setup)
4320    {
4321       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4322       return RFAILED;
4323    }
4324
4325    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
4326    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
4327    DU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
4328    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4329    {
4330       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4331       return RFAILED;
4332    }
4333    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
4334
4335    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
4336    dmrsUlCfg->choice.setup->maxLength = NULLP;
4337    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
4338    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
4339          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4340    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4341    {
4342       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4343       return RFAILED;
4344    }
4345
4346    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
4347    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4348          sizeof(long));
4349    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
4350    {
4351       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4352       return RFAILED;
4353    }
4354    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
4355
4356    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
4357    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
4358    return ROK;
4359 }
4360
4361 /*******************************************************************
4362  *
4363  * @brief Build PUSCH time domain allocation list
4364  *
4365  * @details
4366  *
4367  *    Function : BuildPuschTimeDomAllocList
4368  *
4369  *    Functionality: Build PUSCH time domain allocation list
4370  *
4371  * @params[in]
4372  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4373  *
4374  * @return ROK     - success
4375  *         RFAILED - failure
4376  *
4377  * ****************************************************************/
4378    uint8_t BuildPuschTimeDomAllocList
4379 (
4380  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4381  )
4382 {
4383    uint8_t idx;
4384    uint8_t elementCnt;
4385    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
4386
4387    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
4388    timeDomAllocList->choice.setup = NULLP;
4389    DU_ALLOC(timeDomAllocList->choice.setup, \
4390          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4391    if(!timeDomAllocList->choice.setup)
4392    {
4393       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4394       return RFAILED;
4395    }
4396
4397    elementCnt = 2;
4398    timeDomAllocList->choice.setup->list.count = elementCnt;
4399    timeDomAllocList->choice.setup->list.size = \
4400                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
4401    timeDomAllocList->choice.setup->list.array = NULLP;
4402    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
4403          timeDomAllocList->choice.setup->list.size);
4404    if(!timeDomAllocList->choice.setup->list.array)
4405    {
4406       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4407       return RFAILED;
4408    }
4409
4410    for(idx = 0; idx < elementCnt; idx++)
4411    {
4412       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4413       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
4414             sizeof(PUSCH_TimeDomainResourceAllocation_t));
4415       if(!timeDomAllocList->choice.setup->list.array[idx])
4416       {
4417          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4418          return RFAILED;
4419       }
4420    }
4421
4422    idx = 0;
4423    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4424    DU_ALLOC(timeDomAlloc->k2, sizeof(long));
4425    if(!timeDomAlloc->k2)
4426    {
4427       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4428       return RFAILED;
4429    }
4430    *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
4431    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4432    timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
4433
4434    idx++;
4435    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4436    DU_ALLOC(timeDomAlloc->k2, sizeof(long));
4437    if(!timeDomAlloc->k2)
4438    {
4439       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4440       return RFAILED;
4441    }
4442    *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
4443    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4444    timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
4445
4446    return ROK;
4447 }
4448
4449 /*******************************************************************
4450  *
4451  * @brief Builds BWP UL dedicated PUSCH Config
4452  *
4453  * @details
4454  *
4455  *    Function : BuildBWPUlDedPuschCfg
4456  *
4457  *    Functionality:
4458  *      Builds BWP UL dedicated PUSCH Config
4459  *
4460  * @params[in] : PUSCH_Config_t *puschCfg
4461  *
4462  * @return ROK     - success
4463  *         RFAILED - failure
4464  *
4465  * ****************************************************************/
4466 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
4467 {
4468    puschCfg->dataScramblingIdentityPUSCH = NULLP;
4469    DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4470    if(!puschCfg->dataScramblingIdentityPUSCH)
4471    {
4472       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4473       return RFAILED;
4474    }
4475    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
4476
4477    puschCfg->txConfig = NULLP;
4478    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4479    DU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4480          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4481    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4482    {
4483       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4484       return RFAILED;
4485    }
4486
4487    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4488    {
4489       return RFAILED;
4490    }
4491
4492    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4493    puschCfg->pusch_PowerControl = NULLP;
4494    puschCfg->frequencyHopping = NULLP;
4495    puschCfg->frequencyHoppingOffsetLists = NULLP;
4496    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4497
4498    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4499    DU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
4500          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4501    if(!puschCfg->pusch_TimeDomainAllocationList)
4502    {
4503       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4504       return RFAILED;
4505    }
4506
4507    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
4508    {
4509       return RFAILED;
4510    }
4511
4512    puschCfg->pusch_AggregationFactor = NULLP;
4513    puschCfg->mcs_Table = NULLP;
4514    puschCfg->mcs_TableTransformPrecoder = NULLP;
4515    puschCfg->transformPrecoder = NULLP;
4516    DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4517    if(!puschCfg->transformPrecoder)
4518    {
4519       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4520       return RFAILED;
4521    }
4522    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4523
4524    puschCfg->codebookSubset = NULLP;
4525    puschCfg->maxRank = NULLP;
4526    puschCfg->rbg_Size = NULLP;
4527    puschCfg->uci_OnPUSCH = NULLP;
4528    puschCfg->tp_pi2BPSK = NULLP;
4529
4530    return ROK;
4531 }
4532
4533 /*******************************************************************
4534  *
4535  * @brief Builds BWP UL dedicated PUCCH Config
4536  *
4537  * @details
4538  *
4539  *    Function : BuildBWPUlDedPucchCfg
4540  *
4541  *    Functionality:
4542  *      Builds BWP UL dedicated PUCCH Config
4543  *
4544  * @params[in] : PUCCH_Config_t *pucchCfg
4545  *
4546  * @return ROK     - success
4547  *         RFAILED - failure
4548  *
4549  * ****************************************************************/
4550 uint8_t BuildBWPUlDedPucchCfg(PUCCH_Config_t *pucchCfg)
4551 {
4552    uint8_t arrIdx, elementCnt;
4553    uint8_t rsrcIdx, rsrcSetIdx;
4554    PUCCH_ResourceSet_t *rsrcSet = NULLP;
4555    PUCCH_Resource_t *rsrc = NULLP;
4556
4557    //RESOURCE SET
4558    elementCnt = 1;
4559    DU_ALLOC(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
4560    if(pucchCfg->resourceSetToAddModList == NULL)
4561    {
4562       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4563       return RFAILED;
4564    }
4565
4566    pucchCfg->resourceSetToAddModList->list.count = elementCnt;
4567    pucchCfg->resourceSetToAddModList->list.size = elementCnt * sizeof(PUCCH_ResourceSet_t *);
4568    DU_ALLOC(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
4569    if(pucchCfg->resourceSetToAddModList->list.array == NULLP)
4570    {
4571       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4572       return RFAILED;
4573    }
4574    for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
4575    {
4576       DU_ALLOC(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
4577       if(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx] == NULLP)
4578       {
4579          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4580          return RFAILED;
4581       }
4582    }
4583    rsrcSetIdx = 0;
4584    rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
4585    rsrcSet->pucch_ResourceSetId = 1;
4586    elementCnt = 1;
4587    rsrcSet->resourceList.list.count = elementCnt;
4588    rsrcSet->resourceList.list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
4589    DU_ALLOC(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
4590    if(rsrcSet->resourceList.list.array == NULLP)
4591    {
4592       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4593       return RFAILED;
4594    }
4595    for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
4596    {
4597       DU_ALLOC(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
4598       if(rsrcSet->resourceList.list.array[rsrcIdx] == NULLP)
4599       {
4600          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4601          return RFAILED;
4602       }
4603    }
4604    rsrcIdx = 0;
4605    *(rsrcSet->resourceList.list.array[rsrcIdx]) = 1;
4606
4607    //RESOURCE
4608    elementCnt = 1;
4609    DU_ALLOC(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
4610    if(pucchCfg->resourceToAddModList == NULLP)
4611    {
4612       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4613       return RFAILED;
4614    }
4615    pucchCfg->resourceToAddModList->list.count = elementCnt;
4616    pucchCfg->resourceToAddModList->list.size = elementCnt * sizeof(PUCCH_Resource_t *);
4617    DU_ALLOC(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
4618    if(pucchCfg->resourceToAddModList->list.array == NULLP)
4619    {
4620       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4621       return RFAILED;
4622    }
4623    for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
4624    {
4625       DU_ALLOC(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
4626       if(pucchCfg->resourceToAddModList->list.array[rsrcIdx] == NULLP)
4627       {
4628          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4629          return RFAILED;
4630       }
4631    }
4632    rsrcIdx = 0;
4633    rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
4634    rsrc->pucch_ResourceId = 1;
4635    rsrc->startingPRB = 0;
4636    rsrc->format.present = PUCCH_Resource__format_PR_format1;
4637    DU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
4638    if(rsrc->format.choice.format1 == NULLP)
4639    {
4640       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4641       return RFAILED;
4642    }
4643    rsrc->format.choice.format1->initialCyclicShift = 0;
4644    rsrc->format.choice.format1->nrofSymbols = 4;
4645    rsrc->format.choice.format1->startingSymbolIndex = 0;
4646    rsrc->format.choice.format1->timeDomainOCC = 0;
4647
4648    //PUCCH Format 1
4649    DU_ALLOC(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
4650    if(pucchCfg->format1 == NULLP)
4651    {
4652       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4653       return RFAILED;
4654    }
4655    pucchCfg->format1->present = PUCCH_Config__format1_PR_setup;
4656    DU_ALLOC(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
4657    if(pucchCfg->format1->choice.setup == NULLP)
4658    {
4659       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4660       return RFAILED;
4661    }
4662    DU_ALLOC(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
4663    if(pucchCfg->format1->choice.setup->nrofSlots == NULLP)
4664    {
4665       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4666       return RFAILED;
4667    }
4668    *(pucchCfg->format1->choice.setup->nrofSlots) = PUCCH_FormatConfig__nrofSlots_n4;
4669
4670    //DL DATA TO UL ACK
4671    DU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
4672    if(pucchCfg->dl_DataToUL_ACK == NULLP)
4673    {
4674       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4675       return RFAILED;
4676    }
4677
4678    elementCnt = 2;
4679    pucchCfg->dl_DataToUL_ACK->list.count = elementCnt;
4680    pucchCfg->dl_DataToUL_ACK->list.size = elementCnt * sizeof(long *);
4681    DU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
4682    if(pucchCfg->dl_DataToUL_ACK->list.array == NULLP)
4683    {
4684       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4685       return RFAILED;
4686    }
4687
4688    for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
4689    {
4690       DU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
4691       if(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx] == NULLP)
4692       {
4693           DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4694           return RFAILED;
4695       }
4696    }
4697
4698    arrIdx = 0;
4699    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx++]) = 1;
4700    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx]) = 2;
4701    return ROK;
4702 }
4703
4704 /*******************************************************************
4705  *
4706  * @brief Fills SRS resource to add/modify list
4707  *
4708  * @details
4709  *
4710  *    Function : BuildSrsRsrcAddModList
4711  *
4712  *    Functionality: Fills SRS resource to add/modify list
4713  *
4714  * @params[in]
4715  * @return ROK     - success
4716  *         RFAILED - failure
4717  *
4718  * ****************************************************************/
4719 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
4720 {
4721    uint8_t   elementCnt;
4722    uint8_t   rsrcIdx;
4723
4724    elementCnt = 1;
4725    resourceList->list.count = elementCnt;
4726    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
4727    resourceList->list.array = NULLP;
4728    DU_ALLOC(resourceList->list.array, resourceList->list.size);
4729    if(!resourceList->list.array)
4730    {
4731       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4732       return RFAILED;
4733    }
4734
4735    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4736    {
4737       DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4738       if(!resourceList->list.array[rsrcIdx])
4739       {
4740          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4741          return RFAILED;
4742       }
4743    }
4744
4745    rsrcIdx = 0;
4746    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
4747    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
4748    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
4749
4750    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
4751    DU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
4752          sizeof(struct SRS_Resource__transmissionComb__n2));
4753    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
4754    {
4755       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4756       return RFAILED;
4757    }
4758    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
4759       = SRS_COMB_OFFSET_N2;
4760    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
4761       = SRS_CYCLIC_SHIFT_N2;
4762
4763    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
4764                                                                       PUSCH_START_SYMBOL;
4765    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
4766                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
4767    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
4768                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
4769
4770    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
4771    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
4772    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
4773    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
4774    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
4775    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
4776                                                                SRS_Resource__groupOrSequenceHopping_neither;
4777
4778    /* Setting resource type to aperiodic for intergration purposes */
4779    resourceList->list.array[rsrcIdx]->resourceType.present = \
4780                                                              SRS_Resource__resourceType_PR_aperiodic;
4781    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
4782    DU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
4783          sizeof(struct SRS_Resource__resourceType__aperiodic));
4784    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
4785    {
4786       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4787       return RFAILED;
4788    }
4789    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
4790
4791    return ROK;
4792 }
4793
4794 /*******************************************************************
4795  *
4796  * @brief Build SRS resource set Add/mod list
4797  *
4798  * @details
4799  *
4800  *    Function : BuildSrsRsrcSetAddModList
4801  *
4802  *    Functionality: Build SRS resource set Add/mod list
4803  *
4804  * @params[in]
4805  * @return ROK     - success
4806  *         RFAILED - failure
4807  *
4808  * ****************************************************************/
4809    uint8_t BuildSrsRsrcSetAddModList
4810 (
4811  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
4812  )
4813 {
4814    uint8_t  elementCnt;
4815    uint8_t  rSetIdx;
4816    uint8_t  rsrcIdx;
4817    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
4818
4819    elementCnt = 1;
4820    rsrcSetList->list.count = elementCnt;
4821    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
4822    rsrcSetList->list.array = NULLP;
4823    DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
4824    if(!rsrcSetList->list.array)
4825    {
4826       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4827       return RFAILED;
4828    }
4829
4830    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4831    {
4832       DU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4833       if(!rsrcSetList->list.array[rSetIdx])
4834       {
4835          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4836          return RFAILED;
4837       }
4838    }
4839
4840    rSetIdx = 0;
4841    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
4842
4843    /* Fill Resource Id list in resource set */
4844    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
4845    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4846          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4847    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4848    {
4849       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4850       return RFAILED;
4851    }
4852
4853    elementCnt = 1;
4854    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4855    rsrcIdList->list.count = elementCnt;
4856    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
4857    rsrcIdList->list.array = NULLP;
4858    DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
4859    if(!rsrcIdList->list.array)
4860    {
4861       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4862       return RFAILED;
4863    }
4864
4865    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4866    {
4867       DU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4868       if(!rsrcIdList->list.array[rsrcIdx])
4869       {
4870          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4871          return RFAILED;
4872       }
4873    }
4874
4875    rsrcIdx = 0;
4876    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
4877
4878    /* Fill resource type */
4879    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
4880                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
4881
4882    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
4883    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4884          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4885    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
4886    {
4887       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4888       return RFAILED;
4889    }
4890    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
4891       = APERIODIC_SRS_RESRC_TRIGGER;
4892
4893    /* TODO : Fill values for below IEs as expected by Viavi */
4894    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
4895    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
4896
4897
4898    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
4899    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
4900    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
4901    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
4902    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
4903
4904    return ROK;
4905 }
4906
4907 /*******************************************************************
4908  *
4909  * @brief Builds BWP UL dedicated SRS Config
4910  *
4911  * @details
4912  *
4913  *    Function : BuildBWPUlDedSrsCfg
4914  *
4915  *    Functionality: Builds BWP UL dedicated SRS Config
4916  *
4917  * @params[in] SRS Config
4918  * @return ROK     - success
4919  *         RFAILED - failure
4920  *
4921  * ****************************************************************/
4922 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
4923 {
4924    srsCfg->srs_ResourceSetToReleaseList = NULLP;
4925    srsCfg->srs_ResourceSetToAddModList = NULLP;
4926    DU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
4927          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4928    if(!srsCfg->srs_ResourceSetToAddModList)
4929    {
4930       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4931       return RFAILED;
4932    }
4933    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
4934    {
4935       return RFAILED;
4936    }
4937
4938    srsCfg->srs_ResourceToReleaseList = NULLP;
4939
4940    /* Resource to Add/Modify list */
4941    srsCfg->srs_ResourceToAddModList = NULLP;
4942    DU_ALLOC(srsCfg->srs_ResourceToAddModList, \
4943          sizeof(struct SRS_Config__srs_ResourceToAddModList));
4944    if(!srsCfg->srs_ResourceToAddModList)
4945    {
4946       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4947       return RFAILED;
4948    }
4949
4950    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
4951    {
4952       return RFAILED;
4953    }
4954
4955    srsCfg->tpc_Accumulation = NULLP;
4956
4957    return ROK;
4958 }
4959
4960
4961
4962 /*******************************************************************
4963  *
4964  * @brief Builds Pusch Serving cell Config
4965  *
4966  * @details
4967  *
4968  *    Function : BuildPuschSrvCellCfg
4969  *
4970  *    Functionality: Builds Pusch Serving cell Config
4971  *
4972  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
4973  *
4974  * @return ROK     - success
4975  *         RFAILED - failure
4976  *
4977  * ****************************************************************/
4978 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
4979 {
4980    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
4981    puschCfg->choice.setup = NULLP;
4982    DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4983    if(!puschCfg->choice.setup)
4984    {
4985       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4986       return RFAILED;
4987    }
4988
4989    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4990    puschCfg->choice.setup->rateMatching = NULLP;
4991    puschCfg->choice.setup->xOverhead = NULLP;
4992    puschCfg->choice.setup->ext1 = NULLP;
4993    DU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
4994    if(!puschCfg->choice.setup->ext1)
4995    {
4996       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4997       return RFAILED;
4998    }
4999
5000    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
5001    DU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
5002    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
5003    {
5004       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5005       return RFAILED;
5006    }
5007    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
5008
5009    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
5010    DU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
5011    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
5012    {
5013       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
5014       return RFAILED;
5015    }
5016    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
5017    return ROK;
5018 }
5019
5020 /*******************************************************************
5021  *
5022  * @brief Builds inital UL BWP
5023  *
5024  * @details
5025  *
5026  *    Function : BuildInitialUlBWP
5027  *
5028  *    Functionality: Builds initial UL BWP
5029  *
5030  * @params[in] BWP_UplinkDedicated_t *ulBwp
5031  * @return ROK     - success
5032  *         RFAILED - failure
5033  *
5034  * ****************************************************************/
5035 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5036 {
5037    ulBwp->pucch_Config = NULLP;
5038    DU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
5039    if(!ulBwp->pucch_Config)
5040    {
5041       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5042       return RFAILED;
5043    }
5044
5045    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
5046    ulBwp->pucch_Config->choice.setup = NULLP;
5047    DU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
5048    if(!ulBwp->pucch_Config->choice.setup)
5049    {
5050       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5051       return RFAILED;
5052    }
5053
5054    if(BuildBWPUlDedPucchCfg(ulBwp->pucch_Config->choice.setup) != ROK)
5055    {
5056       return RFAILED;
5057    }
5058
5059    /* Fill BWP UL dedicated PUSCH config */
5060    ulBwp->pusch_Config = NULLP;
5061    DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5062    if(!ulBwp->pusch_Config)
5063    {
5064       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5065       return RFAILED;
5066    }
5067
5068    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
5069    ulBwp->pusch_Config->choice.setup = NULLP;
5070    DU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5071    if(!ulBwp->pusch_Config->choice.setup)
5072    {
5073       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5074       return RFAILED;
5075    }
5076
5077    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
5078    {
5079       return RFAILED;
5080    }
5081
5082    ulBwp->configuredGrantConfig = NULLP;
5083
5084    /* Fill BPW UL dedicated SRS config */
5085    ulBwp->srs_Config = NULLP;
5086    DU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5087    if(!ulBwp->srs_Config)
5088    {
5089       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5090       return RFAILED;
5091    }
5092
5093    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
5094    ulBwp->srs_Config->choice.setup = NULLP;
5095    DU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5096    if(!ulBwp->srs_Config->choice.setup)
5097    {
5098       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
5099       return RFAILED;
5100    }
5101
5102    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
5103    {
5104       return RFAILED;
5105    }
5106
5107    ulBwp->beamFailureRecoveryConfig = NULLP;
5108
5109    return ROK;
5110 }
5111
5112 /*******************************************************************
5113  *
5114  * @brief Builds UL config
5115  * @details
5116  *
5117  *    Function : BuildUlCfg
5118  *
5119  *    Functionality: Builds UL config in spCellCfgDed
5120  *
5121  * @params[in] UplinkConfig_t *ulCfg
5122  *
5123  * @return ROK     - success
5124  *         RFAILED - failure
5125  *
5126  * ****************************************************************/
5127 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
5128 {
5129    ulCfg->initialUplinkBWP = NULLP;
5130    DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5131    if(!ulCfg->initialUplinkBWP)
5132    {
5133       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5134       return RFAILED;
5135    }
5136
5137    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
5138    {
5139       return RFAILED;
5140    }
5141
5142    ulCfg->uplinkBWP_ToReleaseList = NULLP;
5143    ulCfg->uplinkBWP_ToAddModList = NULLP;
5144    ulCfg->firstActiveUplinkBWP_Id = NULLP;
5145    DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5146    if(!ulCfg->firstActiveUplinkBWP_Id)
5147    {
5148       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5149       return RFAILED;
5150    }
5151    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
5152
5153    ulCfg->pusch_ServingCellConfig = NULLP;
5154    DU_ALLOC(ulCfg->pusch_ServingCellConfig, \
5155          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5156    if(!ulCfg->pusch_ServingCellConfig)
5157    {
5158       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
5159       return RFAILED;
5160    }
5161
5162    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
5163    {
5164       return RFAILED;
5165    }
5166
5167    ulCfg->carrierSwitching = NULLP;
5168    ulCfg->ext1 = NULLP;
5169    return ROK;
5170 }
5171
5172 /*******************************************************************
5173  *
5174  * @brief Builds PDSCH serving cell config
5175  * @details
5176  *
5177  *    Function : BuildPdschSrvCellCfg
5178  *
5179  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
5180  *
5181  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
5182  *
5183  * @return ROK     - success
5184  *         RFAILED - failure
5185  *
5186  * ****************************************************************/
5187 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
5188 {
5189    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
5190    pdschCfg->choice.setup = NULLP;
5191    DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5192    if(!pdschCfg->choice.setup)
5193    {
5194       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5195       return RFAILED;
5196    }
5197
5198    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
5199    pdschCfg->choice.setup->xOverhead = NULLP;
5200    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
5201    DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
5202    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
5203    {
5204       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5205       return RFAILED;
5206    }
5207    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
5208    pdschCfg->choice.setup->pucch_Cell = NULLP;
5209    pdschCfg->choice.setup->ext1 = NULLP;
5210
5211    return ROK;
5212 }
5213
5214 /*******************************************************************
5215  *
5216  * @brief Builds CSI Meas config
5217  * @details
5218  *
5219  *    Function : BuildCsiMeasCfg
5220  *
5221  *    Functionality: Builds CSI Meas config in spCellCfgDed
5222  *
5223  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
5224  *
5225  * @return ROK     - success
5226  *         RFAILED - failure
5227  *
5228  * ****************************************************************/
5229 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
5230 {
5231
5232    return ROK;
5233 }
5234
5235 /*******************************************************************
5236  *
5237  * @brief Builds Spcell config dedicated
5238  * @details
5239  *
5240  *    Function : BuildSpCellCfgDed
5241  *
5242  *    Functionality: Builds sp cell config dedicated in spCellCfg
5243  *
5244  * @params[in] ServingCellConfig_t srvCellCfg
5245  *
5246  * @return ROK     - success
5247  *         RFAILED - failure
5248  *
5249  * ****************************************************************/
5250 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
5251 {
5252    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
5253    DU_ALLOC(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
5254    if(!srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
5255    {
5256       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5257       return RFAILED;
5258    }
5259
5260    srvCellCfg->initialDownlinkBWP = NULLP;
5261    DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
5262    if(!srvCellCfg->initialDownlinkBWP)
5263    {
5264       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5265       return RFAILED;
5266    }
5267
5268    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
5269    {
5270       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
5271       return RFAILED;
5272    }
5273    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
5274    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
5275
5276    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
5277    DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
5278    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
5279    {
5280       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5281       return RFAILED;
5282    }
5283    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
5284
5285    srvCellCfg->bwp_InactivityTimer = NULLP;
5286
5287    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
5288    DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
5289    if(!srvCellCfg->defaultDownlinkBWP_Id)
5290    {
5291       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5292       return RFAILED;
5293    }
5294    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
5295
5296    srvCellCfg->uplinkConfig = NULLP;
5297    DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
5298    if(!srvCellCfg->uplinkConfig)
5299    {
5300       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5301       return RFAILED;
5302    }
5303
5304    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
5305    {
5306       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
5307       return RFAILED;
5308    }
5309    srvCellCfg->supplementaryUplink = NULLP;
5310    srvCellCfg->pdcch_ServingCellConfig = NULLP;
5311
5312    srvCellCfg->pdsch_ServingCellConfig = NULLP;
5313    DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
5314    if(!srvCellCfg->pdsch_ServingCellConfig)
5315    {
5316       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5317       return RFAILED;
5318    }
5319
5320    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
5321    {
5322       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
5323       return RFAILED;
5324    }
5325
5326    srvCellCfg->csi_MeasConfig = NULLP;
5327 #if 0
5328    DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
5329       if(!srvCellCfg->csi_MeasConfig)
5330       {
5331          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5332          return RFAILED;
5333       }
5334
5335    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
5336    {
5337       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
5338       return RFAILED;
5339    }
5340 #endif
5341    srvCellCfg->sCellDeactivationTimer = NULLP;
5342    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
5343    srvCellCfg->tag_Id = TAG_ID;
5344    srvCellCfg->dummy = NULLP;
5345    srvCellCfg->pathlossReferenceLinking = NULLP;
5346    srvCellCfg->servingCellMO = NULLP;
5347    srvCellCfg->ext1 = NULLP;
5348
5349    return ROK;
5350 }
5351 /*******************************************************************
5352  *
5353  * @brief Builds Spcell config
5354  *
5355  * @details
5356  *
5357  *    Function : BuildSpCellCfg
5358  *
5359  *    Functionality: Builds sp cell config in DuToCuRrcContainer
5360  *
5361  * @params[in] SpCellConfig_t spCellCfg
5362  *
5363  * @return ROK     - success
5364  *         RFAILED - failure
5365  *
5366  * ****************************************************************/
5367 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
5368 {
5369
5370    spCellCfg->servCellIndex = NULLP;
5371    DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
5372    if(!spCellCfg->servCellIndex)
5373    {
5374       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5375       return RFAILED;
5376    }
5377    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
5378
5379    spCellCfg->reconfigurationWithSync = NULLP;
5380    spCellCfg->rlf_TimersAndConstants = NULLP;
5381    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
5382    DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5383    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
5384    {
5385       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5386       return RFAILED;
5387    }
5388    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
5389
5390    spCellCfg->spCellConfigDedicated = NULLP;
5391    DU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5392    if(!spCellCfg->spCellConfigDedicated)
5393    {
5394       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5395       return RFAILED;
5396    }
5397    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
5398    {
5399       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
5400       return RFAILED;
5401    }
5402    return ROK;
5403 }
5404 /*******************************************************************
5405  *
5406  * @brief Builds Phy cell group config
5407  *
5408  * @details
5409  *
5410  *    Function : BuildPhyCellGrpCfg
5411  *
5412  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
5413  *
5414  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
5415  *
5416  * @return ROK     - success
5417  *         RFAILED - failure
5418  *
5419  * ****************************************************************/
5420 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
5421 {
5422    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
5423    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
5424
5425    phyCellGrpCfg->p_NR_FR1 = NULLP;
5426    DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5427    if(!phyCellGrpCfg->p_NR_FR1)
5428    {
5429       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
5430       return RFAILED;
5431    }
5432    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
5433    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
5434    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
5435    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
5436    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
5437    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
5438    phyCellGrpCfg->cs_RNTI = NULLP;
5439    phyCellGrpCfg->ext1 = NULLP;
5440    phyCellGrpCfg->ext2 = NULLP;
5441
5442    return ROK;
5443 }
5444 /*******************************************************************
5445  *
5446  * @brief Builds Mac cell group config
5447  *
5448  * @details
5449  *
5450  *    Function : BuildMacCellGrpCfg
5451  *
5452  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
5453  *
5454  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
5455  *
5456  * @return ROK     - success
5457  *         RFAILED - failure
5458  *
5459  * ****************************************************************/
5460 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
5461 {
5462    macCellGrpCfg->drx_Config = NULLP;
5463    macCellGrpCfg->schedulingRequestConfig = NULLP;
5464    DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5465    if(!macCellGrpCfg->schedulingRequestConfig)
5466    {
5467       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5468       return RFAILED;
5469    }
5470
5471    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
5472    {
5473       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
5474       return RFAILED;
5475    }
5476
5477    macCellGrpCfg->bsr_Config = NULLP;
5478    DU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5479    if(!macCellGrpCfg->bsr_Config)
5480    {
5481       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5482       return RFAILED;
5483    }
5484
5485    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
5486    {
5487       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
5488       return RFAILED;
5489    }
5490
5491    macCellGrpCfg->tag_Config = NULLP;
5492    DU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
5493    if(!macCellGrpCfg->tag_Config)
5494    {
5495       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5496       return RFAILED;
5497    }
5498
5499    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
5500    {
5501       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
5502       return RFAILED;
5503    }
5504
5505    macCellGrpCfg->phr_Config = NULLP;
5506    DU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
5507    if(!macCellGrpCfg->phr_Config)
5508    {
5509       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5510       return RFAILED;
5511    }
5512
5513    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
5514    {
5515       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
5516       return RFAILED;
5517    }
5518
5519    macCellGrpCfg->skipUplinkTxDynamic = false;
5520    macCellGrpCfg->ext1 = NULLP;
5521
5522    return ROK;
5523 }
5524 /*******************************************************************
5525  *
5526  * @brief Frees memeory allocated for SearchSpcToAddModList
5527  *
5528  * @details
5529  *
5530  *    Function : FreeSearchSpcToAddModList
5531  *
5532  *    Functionality: Deallocating memory of SearchSpcToAddModList
5533  *
5534  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
5535  *
5536  * @return void
5537  *
5538  4221 * ****************************************************************/
5539 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
5540 {
5541    uint8_t idx1=0;
5542    uint8_t idx2=0;
5543    struct  SearchSpace *searchSpc=NULLP;
5544
5545    if(searchSpcList->list.array)
5546    {
5547       if(searchSpcList->list.array[idx2])
5548       {
5549          searchSpc = searchSpcList->list.array[idx2];
5550          if(searchSpc->controlResourceSetId)
5551          {
5552             if(searchSpc->monitoringSlotPeriodicityAndOffset)
5553             {
5554                if(searchSpc->monitoringSymbolsWithinSlot)
5555                {
5556                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
5557                   {
5558                      if(searchSpc->nrofCandidates)
5559                      {
5560                         if(searchSpc->searchSpaceType)
5561                         {
5562                            DU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
5563                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
5564                            DU_FREE(searchSpc->searchSpaceType, sizeof(struct
5565                                     SearchSpace__searchSpaceType));
5566                         }
5567                         DU_FREE(searchSpc->nrofCandidates,
5568                               sizeof(struct SearchSpace__nrofCandidates));
5569                      }
5570                      DU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
5571                            searchSpc->monitoringSymbolsWithinSlot->size);
5572                   }
5573                   DU_FREE(searchSpc->monitoringSymbolsWithinSlot,
5574                         sizeof(BIT_STRING_t));
5575                }
5576                DU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
5577                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
5578             }
5579             DU_FREE(searchSpc->controlResourceSetId,
5580                   sizeof(ControlResourceSetId_t));
5581          }
5582       }
5583       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
5584       {
5585          DU_FREE(searchSpcList->list.array[idx1],
5586                sizeof(struct SearchSpace));
5587       }
5588       DU_FREE(searchSpcList->list.array,searchSpcList->list.size);
5589    }
5590 }
5591 /*******************************************************************
5592  *
5593  * @brief Frees memory allocated for PdschTimeDomAllocList
5594  *
5595  * @details
5596  *
5597  *    Function : FreePdschTimeDomAllocList
5598  *
5599  *    Functionality: Deallocating memory of PdschTimeDomAllocList
5600  *
5601  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
5602  *
5603  * @return void
5604  *
5605  * ****************************************************************/
5606 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
5607 {
5608    uint8_t idx1=0;
5609
5610    if(timeDomAllocList->choice.setup)
5611    {
5612       if(timeDomAllocList->choice.setup->list.array)
5613       {
5614          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
5615          {
5616             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1]->k0, sizeof(long));
5617             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
5618                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
5619          }
5620          DU_FREE(timeDomAllocList->choice.setup->list.array, \
5621                timeDomAllocList->choice.setup->list.size);
5622       }
5623       DU_FREE(timeDomAllocList->choice.setup,\
5624             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
5625    }
5626 }
5627 /*******************************************************************
5628  *
5629  * @brief Frees memory allocated for PuschTimeDomAllocList
5630  *
5631  *@details
5632  *
5633  *    Function : FreePuschTimeDomAllocList
5634  *
5635  *    Functionality: Deallocating memory of PuschTimeDomAllocList
5636  *
5637  * @params[in] PUSCH_Config_t *puschCfg
5638  *
5639  * @return void
5640  *
5641  * ****************************************************************/
5642 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
5643 {
5644    uint8_t rsrcListIdx=0;
5645    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
5646
5647    if(puschCfg->pusch_TimeDomainAllocationList)
5648    {
5649       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
5650       if(timeDomAllocList_t->choice.setup)
5651       {
5652          if(timeDomAllocList_t->choice.setup->list.array)
5653          {
5654             for(rsrcListIdx = 0; rsrcListIdx<timeDomAllocList_t->choice.setup->list.count; rsrcListIdx++)
5655             {
5656                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx]->k2, sizeof(long));
5657                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx],\
5658                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
5659             }
5660             DU_FREE(timeDomAllocList_t->choice.setup->list.array, \
5661                   timeDomAllocList_t->choice.setup->list.size);
5662          }
5663          DU_FREE(timeDomAllocList_t->choice.setup, \
5664                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
5665       }
5666       DU_FREE(puschCfg->transformPrecoder, sizeof(long));
5667       DU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
5668             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
5669    }
5670
5671 }
5672
5673 /*******************************************************************
5674  *
5675  * @brief Frees memory allocated for Dedicated PUCCH config
5676  *
5677  * @details
5678  *
5679  *    Function : FreeBWPUlDedPucchCfg
5680  *
5681  *    Functionality: Deallocating memory of Dedicated PUCCH cfg
5682  *
5683  * @params[in] BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg
5684  *
5685  * @return void
5686  *
5687  * ****************************************************************/
5688 void FreeBWPUlDedPucchCfg(struct BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg)
5689 {
5690    uint8_t k1Idx, rsrcIdx, rsrcSetIdx;
5691    PUCCH_Config_t *pucchCfg = NULLP;
5692    PUCCH_ResourceSet_t *rsrcSet = NULLP;
5693    PUCCH_Resource_t *rsrc = NULLP;
5694
5695    if(ulBwpPucchCfg)
5696    {
5697       if(ulBwpPucchCfg->choice.setup)
5698       {
5699          pucchCfg = ulBwpPucchCfg->choice.setup;
5700
5701          //Free resource set list
5702          if(pucchCfg->resourceSetToAddModList)
5703          {
5704             if(pucchCfg->resourceSetToAddModList->list.array)
5705             {
5706                for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
5707                {
5708                   rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
5709                   if(rsrcSet->resourceList.list.array)
5710                   {
5711                      for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
5712                      {
5713                         DU_FREE(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
5714                      }
5715                      DU_FREE(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
5716                   }
5717                   DU_FREE(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
5718                }
5719                DU_FREE(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
5720             }
5721             DU_FREE(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
5722          }
5723
5724          //Free resource list
5725          if(pucchCfg->resourceToAddModList)
5726          {
5727             if(pucchCfg->resourceToAddModList->list.array)
5728             {
5729                for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
5730                {
5731                   rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
5732                   DU_FREE(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
5733                   DU_FREE(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
5734                }
5735                DU_FREE(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
5736             }
5737             DU_FREE(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
5738          }
5739
5740          //PUCCH Format 1
5741          if(pucchCfg->format1)
5742          {
5743             if(pucchCfg->format1->choice.setup)
5744             {
5745                DU_FREE(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
5746                DU_FREE(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
5747             }
5748             DU_FREE(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
5749          }
5750
5751          //DL DATA TO UL ACK
5752          if(pucchCfg->dl_DataToUL_ACK)
5753          {
5754             if(pucchCfg->dl_DataToUL_ACK->list.array)
5755             {
5756                for(k1Idx = 0; k1Idx <  pucchCfg->dl_DataToUL_ACK->list.count; k1Idx++)
5757                {
5758                   DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[k1Idx], sizeof(long));
5759                }
5760                DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
5761             }
5762             DU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
5763          }
5764
5765          DU_FREE(ulBwpPucchCfg->choice.setup, sizeof(PUCCH_Config_t));
5766       }
5767       DU_FREE(ulBwpPucchCfg, sizeof(struct BWP_UplinkDedicated__pucch_Config));
5768    }
5769 }
5770
5771 /*******************************************************************
5772  *
5773  * @brief Frees memory allocated for InitialUlBWP
5774  *
5775  * @details
5776  *
5777  *    Function : FreeInitialUlBWP
5778  *
5779  *    Functionality: Deallocating memory of InitialUlBWP
5780  *
5781  * @params[in] BWP_UplinkDedicated_t *ulBwp
5782  *
5783  * @return void
5784  *
5785  * ****************************************************************/
5786 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5787 {
5788    uint8_t  rSetIdx, rsrcIdx;
5789    SRS_Config_t   *srsCfg = NULLP;
5790    PUSCH_Config_t *puschCfg = NULLP;
5791    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
5792    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
5793    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
5794    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
5795
5796    FreeBWPUlDedPucchCfg(ulBwp->pucch_Config);
5797
5798    if(ulBwp->pusch_Config)
5799    {
5800       if(ulBwp->pusch_Config->choice.setup)
5801       {
5802          puschCfg=ulBwp->pusch_Config->choice.setup;
5803          if(puschCfg->dataScramblingIdentityPUSCH)
5804          {
5805             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
5806             {
5807                FreePuschTimeDomAllocList(puschCfg);
5808                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
5809                if(dmrsUlCfg->choice.setup)
5810                {
5811                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
5812                   {
5813                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
5814                      {
5815                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
5816                               sizeof(long));
5817                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
5818                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
5819                      }
5820                      DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
5821                            sizeof(long));
5822                   }
5823                   DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
5824                }
5825                DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
5826                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
5827             }
5828             DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
5829          }
5830          DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5831       }
5832       DU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5833
5834       /* Free SRS-Config */
5835       if(ulBwp->srs_Config)
5836       {
5837          if(ulBwp->srs_Config->choice.setup)
5838          {
5839             srsCfg = ulBwp->srs_Config->choice.setup;
5840
5841             /* Free Resource Set to add/mod list */
5842             if(srsCfg->srs_ResourceSetToAddModList)
5843             {
5844                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
5845                if(rsrcSetList->list.array)
5846                {
5847                   rSetIdx = 0;
5848
5849                   /* Free SRS resource Id list in this SRS resource set */
5850                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5851                   {
5852                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5853
5854                      if(rsrcIdList->list.array)
5855                      {
5856                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5857                         {
5858                            DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5859                         }
5860                         DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
5861                      }
5862                      DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5863                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5864                   }
5865
5866                   /* Free resource type info for this SRS resource set */
5867                   DU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5868                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5869
5870                   /* Free memory for each resource set */
5871                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5872                   {
5873                      DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5874                   }
5875                   DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
5876                }
5877                DU_FREE(srsCfg->srs_ResourceSetToAddModList, \
5878                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5879             }
5880
5881             /* Free resource to add/modd list */
5882             if(srsCfg->srs_ResourceToAddModList)
5883             {
5884                resourceList = srsCfg->srs_ResourceToAddModList;
5885                if(resourceList->list.array)
5886                {
5887                   rsrcIdx = 0;
5888                   DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
5889                         sizeof(struct SRS_Resource__transmissionComb__n2));
5890                   DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
5891                         sizeof(struct SRS_Resource__resourceType__aperiodic));
5892
5893                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5894                   {
5895                      DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5896                   }
5897                   DU_FREE(resourceList->list.array, resourceList->list.size);
5898                }
5899                DU_FREE(srsCfg->srs_ResourceToAddModList, \
5900                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
5901             }
5902
5903             DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5904          }
5905          DU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5906       }
5907    }
5908 }
5909 /*******************************************************************
5910  *
5911  * @brief Frees memory allocated for initialUplinkBWP
5912  *
5913  * @details
5914  *
5915  *    Function : FreeinitialUplinkBWP
5916  *
5917  *    Functionality: Deallocating memory of initialUplinkBWP
5918  *
5919  * @params[in] UplinkConfig_t *ulCfg
5920  *
5921  * @return void
5922  *
5923  *
5924  * ****************************************************************/
5925 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
5926 {
5927    BWP_UplinkDedicated_t *ulBwp=NULLP;
5928    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
5929
5930    if(ulCfg->initialUplinkBWP)
5931    {
5932       ulBwp=ulCfg->initialUplinkBWP;
5933       if(ulCfg->firstActiveUplinkBWP_Id)
5934       {
5935          if(ulCfg->pusch_ServingCellConfig)
5936          {
5937             puschCfg=ulCfg->pusch_ServingCellConfig;
5938             if(puschCfg->choice.setup)
5939             {
5940                if(puschCfg->choice.setup->ext1)
5941                {
5942                   DU_FREE(puschCfg->choice.setup->ext1->\
5943                         processingType2Enabled,sizeof(BOOLEAN_t));
5944                   DU_FREE(puschCfg->choice.setup->ext1->\
5945                         maxMIMO_Layers,sizeof(long));
5946                   DU_FREE(puschCfg->choice.setup->ext1, \
5947                         sizeof(struct PUSCH_ServingCellConfig__ext1));
5948                }
5949                DU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5950             }
5951             DU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5952          }
5953          DU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5954       }
5955       FreeInitialUlBWP(ulBwp);
5956       DU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5957    }
5958 }
5959 /*******************************************************************
5960  *
5961  * @brief Frees emmory allocated for BWPDlDedPdschCfg
5962  *
5963  * @details
5964  *
5965  *    Function : FreeBWPDlDedPdschCfg
5966  *
5967  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
5968  *
5969  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5970  *
5971  * @return void
5972  *
5973  *
5974  * ****************************************************************/
5975 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
5976 {
5977    struct PDSCH_Config *pdschCfg=NULLP;
5978    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
5979    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
5980    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
5981
5982    if(dlBwp->pdsch_Config->choice.setup)
5983    {
5984       pdschCfg=dlBwp->pdsch_Config->choice.setup;
5985       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
5986       {
5987          if(pdschCfg->pdsch_TimeDomainAllocationList)
5988          {
5989             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
5990             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
5991             {
5992                prbBndlType=&pdschCfg->prb_BundlingType;
5993                DU_FREE(prbBndlType->choice.staticBundling,\
5994                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
5995                DU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
5996             }
5997             FreePdschTimeDomAllocList(timeDomAllocList);
5998             DU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
5999                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
6000          }
6001          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
6002          if(dmrsDlCfg->choice.setup)
6003          {
6004             DU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
6005                   sizeof(long));
6006             DU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
6007          }
6008          DU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
6009                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
6010       }
6011       DU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
6012    }
6013 }
6014 /*******************************************************************
6015  *
6016  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
6017  *
6018  * @details
6019  *
6020  *    Function : FreeBWPDlDedPdcchCfg
6021  *
6022  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
6023  *
6024  * @params[in] BWP_DownlinkDedicated_t *dlBwp
6025  *
6026  * @return void
6027  *
6028  *
6029  * ****************************************************************/
6030 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
6031 {
6032    uint8_t idx1=0;
6033    uint8_t idx2=0;
6034    struct PDCCH_Config *pdcchCfg=NULLP;
6035    struct ControlResourceSet *controlRSet=NULLP;
6036    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
6037
6038    if(dlBwp->pdcch_Config->choice.setup)
6039    {
6040       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
6041       if(pdcchCfg->controlResourceSetToAddModList)
6042       {
6043          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
6044          if(controlRSetList->list.array)
6045          {
6046             controlRSet = controlRSetList->list.array[idx2];
6047             if(controlRSet)
6048             {
6049                if(controlRSet->frequencyDomainResources.buf)
6050                {
6051                   if(controlRSet->pdcch_DMRS_ScramblingID)
6052                   {
6053                      if(pdcchCfg->searchSpacesToAddModList)
6054                      {
6055                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
6056                         DU_FREE(pdcchCfg->searchSpacesToAddModList, \
6057                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
6058                      }
6059                      DU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
6060                   }
6061                   DU_FREE(controlRSet->frequencyDomainResources.buf, \
6062                         controlRSet->frequencyDomainResources.size);
6063                }
6064             }
6065             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
6066             {
6067                DU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
6068             }
6069             DU_FREE(controlRSetList->list.array, controlRSetList->list.size);
6070          }
6071          DU_FREE(pdcchCfg->controlResourceSetToAddModList, \
6072                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
6073       }
6074       DU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
6075    }
6076 }
6077
6078 /*******************************************************************
6079  *
6080  * @brief Frees emmory allocated for DUToCURRCContainer
6081  *
6082  * @details
6083  *
6084  *    Function : FreeMemDuToCuRrcCont
6085  *
6086  *    Functionality: Deallocating memory of DuToCuRrcContainer
6087  *
6088  * @params[in] DuToCuRRCContainer, DuToCuRRCContainer
6089  *
6090  * @return ROK     - success
6091  *         RFAILED - failure
6092  *
6093  * ****************************************************************/
6094 uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg)
6095 {
6096    uint8_t idx=0;
6097    SpCellConfig_t *spCellCfg=NULLP;
6098    ServingCellConfig_t *srvCellCfg=NULLP;
6099    BWP_DownlinkDedicated_t *dlBwp=NULLP;
6100    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
6101    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
6102    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
6103    struct RLC_Config *rlcConfig=NULLP;
6104    struct LogicalChannelConfig *macLcConfig=NULLP;
6105    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
6106    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
6107    struct TAG_Config *tagConfig=NULLP;
6108    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
6109    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
6110    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
6111
6112    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6113    if(rlcBearerList)
6114    {
6115       if(rlcBearerList->list.array)
6116       {
6117          for(idx=0; idx<rlcBearerList->list.count; idx++)
6118          {
6119             if(rlcBearerList->list.array[idx])
6120             {
6121                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
6122                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
6123                if(rlcConfig)
6124                {
6125                   if(rlcConfig->choice.am)
6126                   {
6127                      DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6128                      DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
6129                      DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
6130                   }
6131                   DU_FREE(rlcConfig, sizeof(struct RLC_Config));
6132                }
6133                DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
6134                if(macLcConfig)
6135                {
6136                   if(macLcConfig->ul_SpecificParameters)
6137                   {
6138                      DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
6139                      DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
6140                      DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
6141                   }
6142                   DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
6143                }
6144                DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
6145             }
6146          }
6147          DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
6148       }
6149       DU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
6150    }
6151
6152    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
6153    if(macCellGrpCfg)
6154    {
6155       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
6156       if(schedulingRequestConfig)
6157       {
6158          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
6159          if(schReqList)
6160          {
6161             if(schReqList->list.array)
6162             {
6163                for(idx=0;idx<schReqList->list.count; idx++)
6164                {
6165                   if(schReqList->list.array[idx])
6166                   {
6167                      DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
6168                      DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
6169                   }
6170                }
6171                DU_FREE(schReqList->list.array, schReqList->list.size);
6172             }
6173             DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
6174                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
6175             DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
6176       }
6177       if(macCellGrpCfg->bsr_Config)
6178       {
6179          DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
6180       }
6181       tagConfig = macCellGrpCfg->tag_Config;
6182       if(tagConfig)
6183       {
6184          tagList = tagConfig->tag_ToAddModList;
6185          if(tagList)
6186          {
6187             if(tagList->list.array)
6188             {
6189                for(idx=0; idx<tagList->list.count; idx++)
6190                {
6191                   DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
6192                }
6193                DU_FREE(tagList->list.array, tagList->list.size);
6194             }
6195             DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
6196          }
6197          DU_FREE(tagConfig, sizeof(struct TAG_Config));
6198       }
6199
6200       phrConfig = macCellGrpCfg->phr_Config;
6201       if(phrConfig)
6202       {
6203          DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
6204          DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
6205       }
6206
6207       DU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
6208    }
6209
6210    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
6211    if(phyCellGrpCfg)
6212    {
6213       DU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
6214       DU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
6215    }
6216
6217    spCellCfg = cellGrpCfg->spCellConfig;
6218    if(spCellCfg)
6219    {
6220       if(spCellCfg->servCellIndex)
6221       {
6222          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
6223          {
6224             if(spCellCfg->spCellConfigDedicated)
6225             {
6226                srvCellCfg = spCellCfg->spCellConfigDedicated;
6227                if(srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
6228                {
6229                   if(srvCellCfg->initialDownlinkBWP)
6230                   {
6231                      dlBwp = srvCellCfg->initialDownlinkBWP;
6232                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
6233                      {
6234                         if(srvCellCfg->defaultDownlinkBWP_Id)
6235                         {
6236                            if(srvCellCfg->uplinkConfig)
6237                            {
6238                               if(srvCellCfg->pdsch_ServingCellConfig)
6239                               {
6240                                  pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
6241                                  if(pdschCfg->choice.setup)
6242                                  {
6243                                     DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
6244                                     DU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
6245                                  }
6246                                  DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
6247                                           ServingCellConfig__pdsch_ServingCellConfig));
6248                               }
6249                               FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
6250                               DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
6251                            }
6252                            DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
6253                         }
6254                         DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
6255                      }
6256                      if(dlBwp->pdcch_Config)
6257                      {
6258                         if(dlBwp->pdsch_Config)
6259                         {
6260                            FreeBWPDlDedPdschCfg(dlBwp);
6261                            DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
6262                         }
6263                         FreeBWPDlDedPdcchCfg(dlBwp);
6264                         DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
6265                      }
6266                      DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
6267                   }
6268                   DU_FREE(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
6269                }
6270                DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
6271             }
6272             DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
6273          }
6274          DU_FREE(spCellCfg->servCellIndex, sizeof(long));
6275       }
6276       DU_FREE(spCellCfg,sizeof(SpCellConfig_t));
6277    }
6278    return ROK;
6279 }
6280 /*******************************************************************
6281  *
6282  * @brief Builds DU To CU RRC Container
6283  *
6284  * @details
6285  *
6286  *    Function : BuildDuToCuRrcContainer
6287  *
6288  *    Functionality: Builds DuToCuRrcContainer
6289  *
6290  * @params[in] idx, index in F1AP msg
6291  *             DuToCuRRCContainer, DuToCuRRCContainer
6292  *
6293  * @return ROK     - success
6294  *         RFAILED - failure
6295  *
6296  * ****************************************************************/
6297 uint8_t BuildDuToCuRrcContainer(DUtoCURRCContainer_t *duToCuRrcContainer)
6298 {
6299    uint8_t  ret = ROK;
6300    CellGroupConfigRrc_t  cellGrpCfg;
6301    asn_enc_rval_t        encRetVal;
6302    memset(&cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
6303    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
6304
6305    while(true)
6306    {
6307       cellGrpCfg.cellGroupId = CELL_GRP_ID;
6308
6309       cellGrpCfg.rlc_BearerToAddModList = NULLP;
6310       DU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
6311       if(!cellGrpCfg.rlc_BearerToAddModList)
6312       {
6313          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6314          ret = RFAILED;
6315          break;
6316       }
6317       if(BuildRlcBearerToAddModList(cellGrpCfg.rlc_BearerToAddModList) != ROK)
6318       {
6319          DU_LOG("\nERROR  -->  F1AP : BuildRlcBearerToAddModList failed");
6320          ret = RFAILED;
6321          break;
6322       }
6323
6324       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
6325       cellGrpCfg.mac_CellGroupConfig = NULLP;
6326       DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
6327       if(!cellGrpCfg.mac_CellGroupConfig)
6328       {
6329          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6330          ret = RFAILED;
6331          break;
6332       }
6333       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
6334       {
6335          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
6336          ret = RFAILED;
6337          break;
6338       }
6339
6340       cellGrpCfg.physicalCellGroupConfig = NULLP;
6341       DU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
6342       if(!cellGrpCfg.physicalCellGroupConfig)
6343       {
6344          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6345          ret = RFAILED;
6346          break;
6347       }
6348       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
6349       {
6350          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
6351          ret = RFAILED;
6352          break;
6353       }
6354
6355       cellGrpCfg.spCellConfig = NULLP;
6356       DU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
6357       if(!cellGrpCfg.spCellConfig)
6358       {
6359          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6360          ret = RFAILED;
6361          break;
6362       }
6363       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
6364       {
6365          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
6366          ret = RFAILED;
6367          break;
6368       }
6369
6370       cellGrpCfg.sCellToAddModList = NULLP;
6371       cellGrpCfg.sCellToReleaseList = NULLP;
6372       cellGrpCfg.ext1 = NULLP;
6373
6374       /* encode cellGrpCfg into duToCuRrcContainer */
6375       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
6376       memset(encBuf, 0, ENC_BUF_MAX_LEN);
6377       encBufSize = 0;
6378       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
6379       /* Encode results */
6380       if(encRetVal.encoded == ENCODE_FAIL)
6381       {
6382          DU_LOG( "\nERROR  --> F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
6383                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6384          ret = RFAILED;
6385          break;
6386       }
6387       else
6388       {
6389          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
6390          for(int i=0; i< encBufSize; i++)
6391          {
6392             printf("%x",encBuf[i]);
6393          }
6394       }
6395
6396       duToCuRrcContainer->size = encBufSize;
6397       DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
6398       if(!duToCuRrcContainer->buf)
6399       {
6400          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
6401          ret = RFAILED;
6402          break;
6403       }
6404       if(ret == ROK)
6405       {
6406          memcpy(duToCuRrcContainer->buf, encBuf, duToCuRrcContainer->size);
6407       }
6408       break;
6409    }
6410    FreeMemDuToCuRrcCont(&cellGrpCfg);
6411    return ret;
6412 }
6413
6414 /*******************************************************************
6415  *
6416  * @brief Free memory allocated in InitialULRRCMessage
6417  *
6418  * @details
6419  *
6420  *    Function : freeInitUlRrcMsgTransfer
6421  *
6422  *    Functionality: Free memory allocated in InitialULRRCMessage
6423  *
6424  * @params[in]F1AP_PDU_t  *f1apMsg)
6425  *
6426  * @return ROK     - success
6427  *         RFAILED - failure
6428  *
6429  * ****************************************************************/
6430
6431 uint8_t freeInitUlRrcMsgTransfer(F1AP_PDU_t  *f1apMsg)
6432 {
6433    uint8_t ieIdx, arrIdx;
6434    InitialULRRCMessageTransfer_t *initULRRCMsg=NULLP;
6435
6436    if(f1apMsg)
6437    {
6438       if(f1apMsg->choice.initiatingMessage)
6439       {
6440          initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.\
6441             choice.InitialULRRCMessageTransfer;
6442          if(initULRRCMsg->protocolIEs.list.array)
6443          {
6444             for(ieIdx = 0; ieIdx < initULRRCMsg->protocolIEs.list.count; ieIdx++)
6445             {
6446                switch(initULRRCMsg->protocolIEs.list.array[ieIdx]->id)
6447                {
6448                   case ProtocolIE_ID_id_NRCGI:
6449                   {
6450                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf)
6451                      {
6452                         if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf)
6453                         {
6454                            DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf,\
6455                            initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.size);
6456                         }
6457                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf,\
6458                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.size);
6459                      }
6460                      break;
6461                   }
6462                   case ProtocolIE_ID_id_RRCContainer:
6463                   {
6464                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
6465                      {
6466                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,\
6467                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
6468                      }
6469                      break;
6470                   }
6471                   case ProtocolIE_ID_id_DUtoCURRCContainer:
6472                   {
6473                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf)
6474                      {
6475                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf,
6476                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.size);
6477                      }
6478                      break;
6479                   }
6480                   default:
6481                      break;
6482                }
6483              }
6484              for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
6485              {
6486                 if(initULRRCMsg->protocolIEs.list.array[arrIdx])
6487                 {
6488                    DU_FREE(initULRRCMsg->protocolIEs.list.array[arrIdx],\
6489                       sizeof(InitialULRRCMessageTransferIEs_t));
6490                 }
6491              }
6492              DU_FREE(initULRRCMsg->protocolIEs.list.array, initULRRCMsg->protocolIEs.list.size);
6493           }
6494          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
6495       }
6496       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
6497    }
6498    else
6499    {
6500       DU_LOG("\nERROR  -->  DU_APP : Recevied F1ap Pdu is null at freeInitUlRrcMsgTransfer()");
6501       return RFAILED;
6502    }
6503    return ROK;
6504 }
6505
6506 /*******************************************************************
6507  *
6508  * @brief Builds and sends the InitialULRRCMessage
6509  *
6510  * @details
6511  *
6512  *    Function : BuildAndSendInitialRrcMsgTransfer
6513  *
6514  *    Functionality: Constructs the Initial UL RRC Message Transfer and sends
6515  *                   it to the CU through SCTP.
6516  *
6517  * @params[in]
6518  *
6519  * @return ROK     - success
6520  *         RFAILED - failure
6521  *
6522  * ****************************************************************/
6523 uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti,
6524       uint16_t rrcContSize, uint8_t *rrcContainer)
6525 {
6526    uint8_t   ret;
6527    uint8_t   elementCnt;
6528    uint8_t   ieIdx;
6529    asn_enc_rval_t  encRetVal;
6530    F1AP_PDU_t  *f1apMsg = NULLP;
6531    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
6532    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
6533
6534    while(true)
6535    {
6536       DU_LOG("\n INFO   -->  F1AP : Building RRC Setup Request\n");
6537       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
6538       if(f1apMsg == NULLP)
6539       {
6540          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
6541          break;
6542       }
6543       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
6544       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
6545       if(f1apMsg->choice.initiatingMessage == NULLP)
6546       {
6547          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
6548          break;
6549       }
6550       f1apMsg->choice.initiatingMessage->procedureCode =\
6551                                                         ProcedureCode_id_InitialULRRCMessageTransfer;
6552       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
6553       f1apMsg->choice.initiatingMessage->value.present = \
6554                                                          InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
6555       initULRRCMsg =\
6556                     &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
6557       elementCnt = 5;
6558       initULRRCMsg->protocolIEs.list.count = elementCnt;
6559       initULRRCMsg->protocolIEs.list.size = \
6560                                             elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *);
6561       /* Initialize the F1Setup members */
6562       DU_ALLOC(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
6563       if(initULRRCMsg->protocolIEs.list.array == NULLP)
6564       {
6565          DU_LOG(" ERROR  -->  F1AP : Memory allocation for\
6566                RRCSetupRequestMessageTransferIEs failed");
6567          break;
6568       }
6569       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
6570       {
6571          DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx],\
6572                sizeof(InitialULRRCMessageTransferIEs_t));
6573          if(initULRRCMsg->protocolIEs.list.array[ieIdx] == NULLP)
6574          {
6575             break;
6576          }
6577       }
6578       ieIdx = 0;
6579       /*GNB DU UE F1AP ID*/
6580       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6581                                                         ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
6582       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  = Criticality_reject;
6583       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
6584                                                                   InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
6585       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
6586
6587
6588       /*NRCGI*/
6589       ieIdx++;
6590       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6591                                                         ProtocolIE_ID_id_NRCGI;
6592       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  =Criticality_reject;
6593       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
6594                                                                   InitialULRRCMessageTransferIEs__value_PR_NRCGI;
6595
6596       ret =\
6597            BuildNrcgi(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
6598       if(ret!=ROK)
6599       {
6600          break;
6601       }
6602
6603       /*CRNTI*/
6604       ieIdx++;
6605       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6606                                                         ProtocolIE_ID_id_C_RNTI;
6607       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6608       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6609                                                                  InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
6610       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.C_RNTI = crnti;
6611
6612       /*RRCContainer*/
6613       ieIdx++;
6614       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6615                                                         ProtocolIE_ID_id_RRCContainer;
6616       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6617       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6618                                                                  InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
6619
6620       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = rrcContSize;
6621       DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
6622             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size)
6623       if(!initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
6624       {
6625          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
6626          break;
6627
6628       }
6629       memcpy(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, rrcContainer,
6630             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
6631
6632
6633       /*DUtoCURRCContainer*/
6634       ieIdx++;
6635       initULRRCMsg->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCContainer;
6636       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6637       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6638                                                                  InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
6639
6640       ret = BuildDuToCuRrcContainer(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer);
6641       if(ret != ROK)
6642       {
6643          break;
6644       }
6645
6646       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
6647
6648       /* Encode the F1SetupRequest type as APER */
6649       memset(encBuf, 0, ENC_BUF_MAX_LEN);
6650       encBufSize = 0;
6651       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
6652       /* Encode results */
6653       if(encRetVal.encoded == ENCODE_FAIL)
6654       {
6655          DU_LOG( "\nERROR  --> F1AP : Could not encode Initial UL RRC Message Transfer\
6656                structure (at %s)\n",encRetVal.failed_type ? \
6657                encRetVal.failed_type->name : "unknown");
6658          ret = RFAILED;
6659          break;
6660       }
6661       else
6662       {
6663
6664          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for Initial UL RRC\
6665                Message transfer\n");
6666          for(int i=0; i< encBufSize; i++)
6667          {
6668             printf("%x",encBuf[i]);
6669          }
6670       }
6671       /* Sending  msg  */
6672       if(sendF1APMsg() != ROK)
6673       {
6674          DU_LOG("\nERROR  -->  F1AP : Sending Initial UL RRC Message Transfer Failed");
6675          ret = RFAILED;
6676          break;
6677       }
6678       break;
6679    }
6680    freeInitUlRrcMsgTransfer(f1apMsg);
6681    return ret;
6682 }/* End of BuildAndSendInitialRrcMsgTransfer*/
6683
6684 /*****  UE SETUP REQUEST *****/
6685
6686 /*******************************************************************
6687  *
6688  * @brief Free Qos And Snssai Drb Info
6689  *
6690  * @details
6691  *
6692  *    Function : freeDrbQosAndSnssaiInfo
6693  *
6694  *    Functionality: Free Qos And Snssai Drb Info
6695  *
6696  * @params[in] LcCfg *lcCfg,
6697  * @return void
6698  *
6699  * ****************************************************************/
6700 void freeDrbQosAndSnssaiInfo(LcCfg *lcCfg)
6701 {
6702    if(lcCfg->snssai)
6703    {
6704       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6705    }
6706    if(lcCfg->drbQos)
6707    {
6708       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
6709    }
6710 }
6711
6712 /******************************************************************
6713 *
6714 * @brief Function to delete the RLC Lc cfg from UE APP DB
6715 *
6716 * @details
6717 *
6718 *  Function : freeRlcLcCfg
6719 *
6720 *  Functionality: Function to delete the RLC Lc cfg from UE APP DB
6721 *
6722 *
6723  *****************************************************************/
6724
6725 void freeRlcLcCfg(RlcBearerCfg *lcCfg)
6726 {
6727    switch(lcCfg->rlcMode)
6728    {
6729       case RLC_AM :
6730          {
6731             if(lcCfg->u.amCfg)
6732             {
6733                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.amCfg, sizeof(AmBearerCfg));
6734             }
6735             break;
6736          }
6737       case RLC_UM_BI_DIRECTIONAL :
6738          {
6739             if(lcCfg->u.umBiDirCfg)
6740             {
6741                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
6742             }
6743             break;
6744          }
6745       case RLC_UM_UNI_DIRECTIONAL_UL :
6746          {
6747             if(lcCfg->u.umUniDirUlCfg)
6748             {
6749                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
6750             }
6751             break;
6752
6753          }
6754       case RLC_UM_UNI_DIRECTIONAL_DL :
6755          {
6756             if(lcCfg->u.umUniDirDlCfg)
6757             {
6758                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
6759             }
6760             break;
6761          }
6762       default:
6763          DU_LOG("\nERROR  -->  DU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
6764          break;
6765    }
6766    DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6767 }
6768
6769 /*******************************************************************
6770  *
6771  * @brief Function to free MacLcCfg
6772  *
6773  * @details
6774  *
6775  *    Function : freeMacLcCfg
6776  *
6777  *    Functionality: Function to free MacLcCfg
6778  *
6779  * @params[in] LcCfg *lcCfg,
6780  * @return void
6781  *
6782  * ****************************************************************/
6783
6784 void  freeMacLcCfg(LcCfg *lcCfg)
6785 {
6786     /* Deleting DRBQOS */
6787    if(lcCfg->drbQos)
6788    {
6789       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
6790    }
6791    /* Deleting SNSSAI */
6792    if(lcCfg->snssai)
6793    {
6794       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6795    }
6796 }
6797 /*******************************************************************
6798  *
6799  * @brief Free UE NR Capability received in UE Context setup request
6800  *
6801  * @details
6802  *
6803  *    Function : freeAperDecodeUeNrCapability
6804  *
6805  *    Functionality:
6806  *       Free UE NR Capability received in UE Context setup request
6807  *
6808  * @params[in]
6809  * @return ROK     - success
6810  *         RFAILED - failure
6811  *
6812  * ****************************************************************/
6813 void freeAperDecodeUeNrCapability(void *ueNrCapability)
6814 {
6815    uint8_t arrIdx =0;
6816    FeatureSets_t *featureSets =NULLP;
6817    UE_NR_Capability_t *ueNrCap = (UE_NR_Capability_t *)ueNrCapability;
6818
6819    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
6820    {
6821       for(arrIdx = 0; arrIdx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; arrIdx++)
6822       {
6823          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx])
6824             free(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx]);
6825       }
6826       free(ueNrCap->rf_Parameters.supportedBandListNR.list.array);
6827    }
6828
6829    if(ueNrCap->featureSets)
6830    {
6831       featureSets = ueNrCap->featureSets;
6832       if(featureSets->featureSetsDownlinkPerCC)
6833       {
6834          if(featureSets->featureSetsDownlinkPerCC->list.array)
6835          {
6836             for(arrIdx = 0; arrIdx < featureSets->featureSetsDownlinkPerCC->list.count; arrIdx++)
6837             {
6838                if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx])
6839                {
6840                   if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL)
6841                      free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL);
6842                   free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]);
6843                }
6844             }
6845             free(featureSets->featureSetsDownlinkPerCC->list.array);
6846          }
6847          free(featureSets->featureSetsDownlinkPerCC);
6848       }
6849       if(featureSets->featureSetsUplinkPerCC)
6850       {
6851          if(featureSets->featureSetsUplinkPerCC->list.array)
6852          {
6853             for(arrIdx = 0; arrIdx < featureSets->featureSetsUplinkPerCC->list.count; arrIdx++)
6854             {
6855                if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx])
6856                {
6857                   if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL)
6858                      free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL);
6859                   free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]);
6860                }
6861             }
6862             free(featureSets->featureSetsUplinkPerCC->list.array);
6863          }
6864          free(featureSets->featureSetsUplinkPerCC);
6865       }
6866       free(ueNrCap->featureSets);
6867    }
6868 }
6869
6870 /*******************************************************************
6871 *
6872 * @brief Function to free PdcchSearchSpcToAddModList
6873          where memory allocated by aper_decoder
6874 *
6875 * @details
6876 *
6877 *    Function : freeAperDecodePdcchSearchSpcToAddModList
6878 *
6879 *    Functionality: Function to free PdcchSearchSpcToAddModList
6880 *
6881 * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
6882 * @return void
6883 *
6884 * ****************************************************************/
6885
6886 void freeAperDecodePdcchSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
6887 {
6888    uint8_t searchSpcArrIdx=0;
6889    uint8_t searchSpcArrIdx1=0;
6890    struct  SearchSpace *searchSpc=NULLP;
6891
6892
6893    if(searchSpcList->list.array)
6894    {
6895       if(searchSpcList->list.array[searchSpcArrIdx1])
6896       {
6897          searchSpc = searchSpcList->list.array[searchSpcArrIdx1];
6898          if(searchSpc->controlResourceSetId)
6899          {
6900             if(searchSpc->monitoringSlotPeriodicityAndOffset)
6901             {
6902                if(searchSpc->monitoringSymbolsWithinSlot)
6903                {
6904                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
6905                   {
6906                      if(searchSpc->nrofCandidates)
6907                      {
6908                         if(searchSpc->searchSpaceType)
6909                         {
6910                            free(searchSpc->searchSpaceType->choice.ue_Specific);
6911                            free(searchSpc->searchSpaceType);
6912                         }
6913                         free(searchSpc->nrofCandidates);
6914                      }
6915                      free(searchSpc->monitoringSymbolsWithinSlot->buf);
6916                   }
6917                   free(searchSpc->monitoringSymbolsWithinSlot);
6918                }
6919                free(searchSpc->monitoringSlotPeriodicityAndOffset);
6920             }
6921             free(searchSpc->controlResourceSetId);
6922          }
6923       }
6924       for(searchSpcArrIdx = 0; searchSpcArrIdx < searchSpcList->list.count; searchSpcArrIdx++)
6925       {
6926          free(searchSpcList->list.array[searchSpcArrIdx]);
6927       }
6928       free(searchSpcList->list.array);
6929    }
6930 }
6931 /*******************************************************************
6932 *
6933 * @brief Function for free part for the memory allocated by aper_decoder
6934 *
6935 * @details
6936 *
6937 *    Function : freeAperDecodeBWPDlDedPdcchConfig
6938 *
6939 *    Functionality: Function to free BWPDlDedPdcchConfig
6940 *
6941 * @params[in]
6942 * @return void
6943 *
6944 * ****************************************************************/
6945
6946
6947 void freeAperDecodeBWPDlDedPdcchConfig(BWP_DownlinkDedicated_t *dlBwp)
6948 {
6949    uint8_t arrIdx1=0;
6950    uint8_t arrIdx2=0;
6951    struct PDCCH_Config *pdcchCfg=NULLP;
6952    struct ControlResourceSet *controlRSet=NULLP;
6953    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
6954
6955    if(dlBwp->pdcch_Config->choice.setup)
6956    {
6957       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
6958       if(pdcchCfg->controlResourceSetToAddModList)
6959       {
6960          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
6961          if(controlRSetList->list.array)
6962          {
6963             controlRSet = controlRSetList->list.array[arrIdx2];
6964             if(controlRSet)
6965             {
6966                if(controlRSet->frequencyDomainResources.buf)
6967                {
6968                   if(controlRSet->pdcch_DMRS_ScramblingID)
6969                   {
6970                      if(pdcchCfg->searchSpacesToAddModList)
6971                      {
6972                         freeAperDecodePdcchSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
6973                         free(pdcchCfg->searchSpacesToAddModList);
6974                      }
6975                      free(controlRSet->pdcch_DMRS_ScramblingID);
6976                   }
6977                   free(controlRSet->frequencyDomainResources.buf);
6978                }
6979             }
6980             for(arrIdx1 = 0; arrIdx1 <controlRSetList->list.count; arrIdx1++)
6981             {
6982                free(controlRSetList->list.array[arrIdx1]);
6983             }
6984             free(controlRSetList->list.array);
6985          }
6986          free(pdcchCfg->controlResourceSetToAddModList);
6987       }
6988       free(dlBwp->pdcch_Config->choice.setup);
6989    }
6990 }
6991 /*******************************************************************
6992 *
6993 * @brief Function to free PdschTimeDomAllocationList
6994 *     where the memory allocated by aper_decoder
6995 *
6996 * @details
6997 *
6998 *    Function : freeAperDecodePdschTimeDomAllocationList
6999 *
7000 *    Functionality: Function to free PdschTimeDomAllocationList
7001 *
7002 * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
7003 * @return void
7004 *
7005 * ****************************************************************/
7006
7007
7008 void freeAperDecodePdschTimeDomAllocationList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
7009 {
7010    uint8_t arrIdx=0;
7011
7012    if(timeDomAllocList->choice.setup)
7013    {
7014       if(timeDomAllocList->choice.setup->list.array)
7015       {
7016          for(arrIdx = 0; arrIdx <timeDomAllocList->choice.setup->list.count ; arrIdx++)
7017          {
7018             free(timeDomAllocList->choice.setup->list.array[arrIdx]);
7019          }
7020          free(timeDomAllocList->choice.setup->list.array);
7021       }
7022       free(timeDomAllocList->choice.setup);
7023    }
7024 }
7025
7026 /*******************************************************************
7027 *
7028 * @brief Function to free BWPDlDedPdschConfig
7029 *        where the memory allocated by aper_decoder
7030 *
7031 * @details
7032 *
7033 *    Function : freeAperDecodeBWPDlDedPdschConfig
7034 *
7035 *    Functionality: Function to free BWPDlDedPdschConfig
7036 *
7037 * @params[in] BWP_DownlinkDedicated_t *dlBwp
7038 * @return void
7039 *
7040 * ****************************************************************/
7041
7042
7043 void freeAperDecodeBWPDlDedPdschConfig(BWP_DownlinkDedicated_t *dlBwp)
7044 {
7045    struct PDSCH_Config *pdschCfg=NULLP;
7046    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
7047    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
7048    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
7049
7050    if(dlBwp->pdsch_Config->choice.setup)
7051    {
7052       pdschCfg=dlBwp->pdsch_Config->choice.setup;
7053       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
7054       {
7055          if(pdschCfg->pdsch_TimeDomainAllocationList)
7056          {
7057             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
7058             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
7059             {
7060                prbBndlType=&pdschCfg->prb_BundlingType;
7061                free(prbBndlType->choice.staticBundling);
7062                free(pdschCfg->maxNrofCodeWordsScheduledByDCI);
7063             }
7064             freeAperDecodePdschTimeDomAllocationList(timeDomAllocList);
7065             free(pdschCfg->pdsch_TimeDomainAllocationList);
7066          }
7067          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
7068          if(dmrsDlCfg->choice.setup)
7069          {
7070             free(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition);
7071             free(dmrsDlCfg->choice.setup);
7072          }
7073          free(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA);
7074       }
7075       free(dlBwp->pdsch_Config->choice.setup);
7076    }
7077 }
7078 /*******************************************************************
7079 *
7080 * @brief Function to free PuschTimeDomAllocListCfg
7081                  where the memory allocated by aper_decoder
7082 *
7083 * @details
7084 *
7085 *    Function : freeAperDecodePuschTimeDomAllocListCfg
7086 *
7087 *    Functionality: Function to free PuschTimeDomAllocListCfg
7088 *
7089 * @params[in] PUSCH_Config_t *puschCfg
7090 * @return void
7091 *
7092 * ****************************************************************/
7093
7094
7095 void freeAperDecodePuschTimeDomAllocListCfg(PUSCH_Config_t *puschCfg)
7096 {
7097    uint8_t arrIdx=0;
7098    uint8_t arrIdx1=0;
7099    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
7100
7101    if(puschCfg->pusch_TimeDomainAllocationList)
7102    {
7103       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
7104       if(timeDomAllocList_t->choice.setup)
7105       {
7106          if(timeDomAllocList_t->choice.setup->list.array)
7107          {
7108             free(timeDomAllocList_t->choice.setup->list.array[arrIdx1]->k2);
7109             for(arrIdx = 0; arrIdx<timeDomAllocList_t->choice.setup->list.count; arrIdx++)
7110             {
7111                free(timeDomAllocList_t->choice.setup->list.array[arrIdx]);
7112             }
7113             free(timeDomAllocList_t->choice.setup->list.array);
7114          }
7115          free(timeDomAllocList_t->choice.setup);
7116       }
7117       free(puschCfg->transformPrecoder);
7118       free(puschCfg->pusch_TimeDomainAllocationList);
7119    }
7120 }
7121 /*******************************************************************
7122 *
7123 * @brief Function to free InitialUlBWPConfig where memory allocated by aper_decoder
7124 *
7125 * @details
7126 *
7127 *    Function : freeAperDecodeInitialUlBWPConfig
7128 *
7129 *    Functionality: Function to free InitialUlBWPConfig
7130 *
7131 * @params[in]  BWP_UplinkDedicated_t *ulBwp
7132 * @return void
7133 *
7134 * ****************************************************************/
7135
7136
7137 void freeAperDecodeInitialUlBWPConfig(BWP_UplinkDedicated_t *ulBwp)
7138 {
7139    uint8_t  rSetIdx =0;
7140    uint8_t  rsrcIdx =0;
7141    SRS_Config_t   *srsCfg = NULLP;
7142    PUSCH_Config_t *puschCfg = NULLP;
7143    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
7144    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
7145    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
7146    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
7147
7148    if(ulBwp->pusch_Config)
7149    {
7150       if(ulBwp->pusch_Config->choice.setup)
7151       {
7152          puschCfg=ulBwp->pusch_Config->choice.setup;
7153          if(puschCfg->dataScramblingIdentityPUSCH)
7154          {
7155             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
7156             {
7157                freeAperDecodePuschTimeDomAllocListCfg(puschCfg);
7158                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
7159                if(dmrsUlCfg->choice.setup)
7160                {
7161                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
7162                   {
7163                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
7164                      {
7165                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0);
7166                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled);
7167                      }
7168                      free(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition);
7169                   }
7170                   free(dmrsUlCfg->choice.setup);
7171                }
7172                free(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA);
7173             }
7174             free(puschCfg->dataScramblingIdentityPUSCH);
7175          }
7176          free(ulBwp->pusch_Config->choice.setup);
7177       }
7178       free(ulBwp->pusch_Config);
7179
7180       /* Free SRS-Config */
7181       if(ulBwp->srs_Config)
7182       {
7183          if(ulBwp->srs_Config->choice.setup)
7184          {
7185             srsCfg = ulBwp->srs_Config->choice.setup;
7186
7187             /* Free Resource Set to add/mod list */
7188             if(srsCfg->srs_ResourceSetToAddModList)
7189             {
7190                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
7191                if(rsrcSetList->list.array)
7192                {
7193                   rSetIdx = 0;
7194
7195                   /* Free SRS resource Id list in this SRS resource set */
7196                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
7197                   {
7198                      rsrcIdList =
7199                         rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
7200
7201                      if(rsrcIdList->list.array)
7202                      {
7203                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count;
7204                               rsrcIdx++)
7205                         {
7206                            free(rsrcIdList->list.array[rsrcIdx]);
7207                         }
7208                         free(rsrcIdList->list.array);
7209                      }
7210                      free(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList);
7211                   }
7212
7213                   /* Free resource type info for this SRS resource set */
7214
7215                   free(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic);
7216
7217                   /* Free memory for each resource set */
7218                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
7219                   {
7220                      free(rsrcSetList->list.array[rSetIdx]);
7221                   }
7222                   free(rsrcSetList->list.array);
7223                }
7224                free(srsCfg->srs_ResourceSetToAddModList);
7225             }
7226
7227             /* Free resource to add/modd list */
7228             if(srsCfg->srs_ResourceToAddModList)
7229             {
7230                resourceList = srsCfg->srs_ResourceToAddModList;
7231                if(resourceList->list.array)
7232                {
7233                   rsrcIdx = 0;
7234
7235                   free(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2);
7236                   free(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic);
7237
7238                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
7239                   {
7240                      free(resourceList->list.array[rsrcIdx]);
7241                   }
7242                   free(resourceList->list.array);
7243                }
7244                free(srsCfg->srs_ResourceToAddModList);
7245             }
7246
7247             free(ulBwp->srs_Config->choice.setup);
7248          }
7249          free(ulBwp->srs_Config);
7250       }
7251    }
7252 }
7253 /*******************************************************************
7254 *
7255 * @brief Function to free initialUplinkBWPConfig where memory allocated by aper_decoder
7256 *
7257 * @details
7258 *
7259 *    Function : freeAperDecodeinitialUplinkBWPConfig
7260 *
7261 *    Functionality: Function to free initialUplinkBWPConfig
7262 *
7263 * @params[in] UplinkConfig_t *ulCfg
7264 * @return void
7265 *
7266 * ****************************************************************/
7267
7268
7269 void freeAperDecodeinitialUplinkBWPConfig(UplinkConfig_t *ulCfg)
7270 {
7271    BWP_UplinkDedicated_t *ulBwp=NULLP;
7272    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
7273
7274    if(ulCfg->initialUplinkBWP)
7275    {
7276       ulBwp=ulCfg->initialUplinkBWP;
7277       if(ulCfg->firstActiveUplinkBWP_Id)
7278       {
7279          if(ulCfg->pusch_ServingCellConfig)
7280          {
7281             puschCfg=ulCfg->pusch_ServingCellConfig;
7282             if(puschCfg->choice.setup)
7283             {
7284                if(puschCfg->choice.setup->ext1)
7285                {
7286                   free(puschCfg->choice.setup->ext1->processingType2Enabled);
7287                   free(puschCfg->choice.setup->ext1->maxMIMO_Layers);
7288                   free(puschCfg->choice.setup->ext1);
7289                }
7290                free(puschCfg->choice.setup);
7291             }
7292             free(ulCfg->pusch_ServingCellConfig);
7293          }
7294          free(ulCfg->firstActiveUplinkBWP_Id);
7295       }
7296       freeAperDecodeInitialUlBWPConfig(ulBwp);
7297       free(ulCfg->initialUplinkBWP);
7298    }
7299 }
7300
7301 /*******************************************************************
7302  *
7303  * @brief Function to free DuUeCfg
7304  *
7305  * @details
7306  *
7307  *    Function : freeDuUeCfg
7308  *
7309  *    Functionality: Function to free DuUeCfg
7310  *
7311  * @params[in] DuUeCfg *ueCfg
7312  * @return void
7313  *
7314  * ****************************************************************/
7315 void freeDuUeCfg(DuUeCfg *ueCfg)
7316 {
7317    uint8_t lcIdx = 0;
7318    uint8_t arrIdx = 0;
7319    SpCellConfig_t *spCellCfg = NULLP;
7320    ServingCellConfig_t *srvCellCfg = NULLP;
7321    BWP_DownlinkDedicated_t *dlBwp = NULLP;
7322    MAC_CellGroupConfig_t *macCellGrpCfg = NULLP;
7323    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
7324    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList = NULLP;
7325    struct RLC_Config *rlcConfig = NULLP;
7326    struct LogicalChannelConfig *macLcConfig = NULLP;
7327    struct SchedulingRequestConfig *schedulingRequestConfig = NULLP;
7328    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList = NULLP;
7329    struct TAG_Config *tagConfig = NULLP;
7330    struct TAG_Config__tag_ToAddModList *tagList = NULLP;
7331    struct MAC_CellGroupConfig__phr_Config *phrConfig = NULLP;
7332    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg = NULLP;
7333    CellGroupConfigRrc_t *cellGrpCfg = ueCfg->cellGrpCfg;
7334
7335    if(ueCfg->ueNrCapability)
7336    {
7337       freeAperDecodeUeNrCapability(ueCfg->ueNrCapability);
7338       DU_FREE(ueCfg->ueNrCapability, sizeof(UE_NR_Capability_t));
7339       ueCfg->ueNrCapability = NULLP;
7340    }
7341
7342    if(ueCfg->cellGrpCfg)
7343    {
7344
7345       rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
7346       if(rlcBearerList)
7347       {
7348          if(rlcBearerList->list.array)
7349          {
7350             for(arrIdx=0; arrIdx<rlcBearerList->list.count; arrIdx++)
7351             {
7352                if(rlcBearerList->list.array[arrIdx])
7353                {
7354                   rlcConfig   = rlcBearerList->list.array[arrIdx]->rlc_Config;
7355                   macLcConfig = rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig;
7356
7357                   if(rlcBearerList->list.array[arrIdx]->servedRadioBearer)
7358                   {
7359                      free(rlcBearerList->list.array[arrIdx]->servedRadioBearer);
7360                   }
7361                   if(rlcConfig)
7362                   {
7363                      if(rlcConfig->choice.am)
7364                      {
7365                         free(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength);
7366                         free(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength);
7367                         free(rlcConfig->choice.am);
7368                      }
7369                      free(rlcBearerList->list.array[arrIdx]->rlc_Config);
7370                   }
7371                   if(macLcConfig)
7372                   {
7373                      if(macLcConfig->ul_SpecificParameters)
7374                      {
7375                         free(macLcConfig->ul_SpecificParameters->schedulingRequestID);
7376                         free(macLcConfig->ul_SpecificParameters->logicalChannelGroup);
7377                         free(macLcConfig->ul_SpecificParameters);
7378                      }
7379                      free(rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig);
7380                   }
7381                   free(rlcBearerList->list.array[arrIdx]);
7382                }
7383             }
7384             free(rlcBearerList->list.array);
7385          }
7386          free(cellGrpCfg->rlc_BearerToAddModList);
7387       }
7388
7389       macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
7390       if(macCellGrpCfg)
7391       {
7392          schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
7393          if(schedulingRequestConfig)
7394          {
7395             schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
7396             if(schReqList)
7397             {
7398                if(schReqList->list.array)
7399                {
7400                   for(arrIdx=0;arrIdx<schReqList->list.count; arrIdx++)
7401                   {
7402                      if(schReqList->list.array[arrIdx])
7403                      {
7404                         free(schReqList->list.array[arrIdx]->sr_ProhibitTimer);
7405                         free(schReqList->list.array[arrIdx]);
7406                      }
7407                   }
7408                   free(schReqList->list.array);
7409                }
7410                free(schedulingRequestConfig->schedulingRequestToAddModList);
7411             }
7412             free(macCellGrpCfg->schedulingRequestConfig);
7413          }
7414          if(macCellGrpCfg->bsr_Config)
7415          {
7416             free(macCellGrpCfg->bsr_Config);
7417          }
7418          tagConfig = macCellGrpCfg->tag_Config;
7419          if(tagConfig)
7420          {
7421             tagList = tagConfig->tag_ToAddModList;
7422             if(tagList)
7423             {
7424                if(tagList->list.array)
7425                {
7426                   for(arrIdx=0; arrIdx<tagList->list.count; arrIdx++)
7427                   {
7428                      free(tagList->list.array[arrIdx]);
7429                   }
7430                   free(tagList->list.array);
7431                }
7432                free(tagConfig->tag_ToAddModList);
7433             }
7434             free(tagConfig);
7435          }
7436
7437          phrConfig = macCellGrpCfg->phr_Config;
7438          if(phrConfig)
7439          {
7440             free(phrConfig->choice.setup);
7441             free(phrConfig);
7442          }
7443
7444          free(macCellGrpCfg);
7445       }
7446
7447       phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
7448       if(phyCellGrpCfg)
7449       {
7450          free(phyCellGrpCfg->p_NR_FR1);
7451          free(phyCellGrpCfg);
7452       }
7453
7454       spCellCfg = cellGrpCfg->spCellConfig;
7455       if(spCellCfg)
7456       {
7457          if(spCellCfg->servCellIndex)
7458          {
7459             if(spCellCfg->rlmInSyncOutOfSyncThreshold)
7460             {
7461                if(spCellCfg->spCellConfigDedicated)
7462                {
7463                   srvCellCfg = spCellCfg->spCellConfigDedicated;
7464                   if(srvCellCfg->initialDownlinkBWP)
7465                   {
7466                      dlBwp = srvCellCfg->initialDownlinkBWP;
7467                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
7468                      {
7469                         if(srvCellCfg->defaultDownlinkBWP_Id)
7470                         {
7471                            if(srvCellCfg->uplinkConfig)
7472                            {
7473
7474                               if(srvCellCfg->pdsch_ServingCellConfig)
7475                               {
7476                                  pdschCfg=
7477                                     srvCellCfg->pdsch_ServingCellConfig;
7478                                  if(pdschCfg->choice.setup)
7479                                  {
7480
7481                                     free(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH);
7482                                     free(pdschCfg->choice.setup);
7483                                  }
7484
7485                                  free(srvCellCfg->pdsch_ServingCellConfig);
7486                               }
7487
7488                               freeAperDecodeinitialUplinkBWPConfig(srvCellCfg->uplinkConfig);
7489                               free(srvCellCfg->uplinkConfig);
7490                            }
7491                            free(srvCellCfg->defaultDownlinkBWP_Id);
7492                         }
7493
7494                         free(srvCellCfg->firstActiveDownlinkBWP_Id);
7495                      }
7496                      if(dlBwp->pdcch_Config)
7497                      {
7498                         if(dlBwp->pdsch_Config)
7499                         {
7500                            freeAperDecodeBWPDlDedPdschConfig(dlBwp);
7501                            free(dlBwp->pdsch_Config);
7502                         }
7503                         freeAperDecodeBWPDlDedPdcchConfig(dlBwp);
7504                         free(dlBwp->pdcch_Config);
7505                      }
7506                      free(srvCellCfg->initialDownlinkBWP);
7507                   }
7508
7509                   free(spCellCfg->spCellConfigDedicated);
7510                }
7511                free(spCellCfg->rlmInSyncOutOfSyncThreshold);
7512             }
7513             free(spCellCfg->servCellIndex);
7514          }
7515          free(spCellCfg);
7516       }
7517       DU_FREE(ueCfg->cellGrpCfg, sizeof(CellGroupConfigRrc_t));
7518       ueCfg->cellGrpCfg = NULLP;
7519    }
7520    if(ueCfg->ambrCfg)
7521    {
7522       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->ambrCfg, sizeof(AmbrCfg));
7523    }
7524    for(lcIdx = 0; lcIdx < ueCfg->numRlcLcs; lcIdx++)
7525    {
7526       freeRlcLcCfg(&ueCfg->rlcLcCfg[lcIdx]);
7527    }
7528    for(lcIdx = 0; lcIdx < ueCfg->numMacLcs; lcIdx++)
7529    {
7530       freeMacLcCfg(&ueCfg->macLcCfg[lcIdx]);
7531    }
7532    for(lcIdx = 0; lcIdx < ueCfg->numDrb; lcIdx++)
7533    {
7534       DU_FREE(ueCfg->upTnlInfo[lcIdx].tnlCfg1, sizeof(GtpTnlCfg));
7535    }
7536 }
7537
7538 /*******************************************************************
7539  *
7540  * @brief Function to free UecontextSetupDb
7541  *
7542  * @details
7543  *
7544  *    Function : freeF1UeDb
7545  *
7546  *    Functionality: Function to free UecontextSetupDb
7547  *
7548  * @params[in] UecontextSetupDb *
7549  * @return void
7550  *
7551  * ****************************************************************/
7552
7553 void freeF1UeDb(F1UeContextSetupDb *f1UeDb)
7554 {
7555
7556    if(f1UeDb->dlRrcMsg)
7557    {
7558       if(f1UeDb->dlRrcMsg->rrcMsgPdu)
7559       {
7560         //DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,\
7561                f1UeDb->dlRrcMsg->rrcMsgPdu, f1UeDb->dlRrcMsg->rrcMsgSize);
7562       }
7563       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
7564    }
7565    freeDuUeCfg(&f1UeDb->duUeCfg);
7566    memset(f1UeDb, 0, sizeof(F1UeContextSetupDb));
7567    DU_FREE(f1UeDb, sizeof(F1UeContextSetupDb));
7568 }
7569
7570 /*******************************************************************
7571  *
7572  * @brief Function to build Am cfg Info
7573  *
7574  * @details
7575  *
7576  *    Function : extractRlcAmCfg
7577  *
7578  *    Functionality: Function to build Am cfg Info
7579  *
7580  * @params[in] AmBearerCfg *
7581  *             void *
7582  *
7583  * @return ROK/RFAILED
7584  *
7585  * ****************************************************************/
7586
7587 void extractRlcAmCfg(AmBearerCfg *amCfgToSet, struct RLC_Config__am *rlcAmCfg)
7588 {
7589    if(rlcAmCfg)
7590    {
7591       /* UL AM */
7592       if(rlcAmCfg->dl_AM_RLC.sn_FieldLength)
7593       {
7594          amCfgToSet->ulAmCfg.snLenUl = *(rlcAmCfg->dl_AM_RLC.sn_FieldLength);
7595          /*TODO: Check the timer value when sent by real CU */
7596          amCfgToSet->ulAmCfg.reAssemTmr = rlcAmCfg->dl_AM_RLC.t_Reassembly;
7597          amCfgToSet->ulAmCfg.statProhTmr = rlcAmCfg->dl_AM_RLC.t_StatusProhibit;
7598       }
7599
7600       /* DL AM */
7601       if(rlcAmCfg->ul_AM_RLC.sn_FieldLength)
7602       {
7603          amCfgToSet->dlAmCfg.snLenDl = *(rlcAmCfg->ul_AM_RLC.sn_FieldLength);
7604          amCfgToSet->dlAmCfg.pollRetxTmr = rlcAmCfg->ul_AM_RLC.t_PollRetransmit;
7605          amCfgToSet->dlAmCfg.pollPdu   = rlcAmCfg->ul_AM_RLC.pollPDU;
7606          amCfgToSet->dlAmCfg.pollByte  = rlcAmCfg->ul_AM_RLC.pollByte;
7607          amCfgToSet->dlAmCfg.maxRetxTh = rlcAmCfg->ul_AM_RLC.maxRetxThreshold;
7608       }
7609    }
7610 }
7611
7612 /*******************************************************************
7613  *
7614  * @brief Function to build Um Bi Info
7615  *
7616  * @details
7617  *
7618  *    Function : extractRlcUmBiCfg
7619  *
7620  *    Functionality: Function to build Um Bi Info
7621  *
7622  * @params[in] UmBiDirBearerCfg *
7623  *             void *
7624  *
7625  * @return ROK/RFAILED
7626  *
7627  * ****************************************************************/
7628
7629 void extractRlcUmBiCfg(UmBiDirBearerCfg *umBiCfgToSet, struct RLC_Config__um_Bi_Directional *rlcBiCfg)
7630 {
7631    if(rlcBiCfg)
7632    {
7633       /* UL UM BI DIR Cfg */
7634       if(rlcBiCfg->dl_UM_RLC.sn_FieldLength)
7635       {
7636          umBiCfgToSet->ulUmCfg.snLenUlUm  = *(rlcBiCfg->dl_UM_RLC.sn_FieldLength);
7637          umBiCfgToSet->ulUmCfg.reAssemTmr = rlcBiCfg->dl_UM_RLC.t_Reassembly;
7638       }
7639
7640       /* DL UM BI DIR Cfg */
7641       if(rlcBiCfg->ul_UM_RLC.sn_FieldLength)
7642          umBiCfgToSet->dlUmCfg.snLenDlUm  = *(rlcBiCfg->ul_UM_RLC.sn_FieldLength);
7643    }
7644 }
7645
7646 /*******************************************************************
7647  *
7648  * @brief Function to build Um Ul Info
7649  *
7650  * @details
7651  *
7652  *    Function : extractRlcUmUlCfg
7653  *
7654  *    Functionality: Function to build Um Ul Info
7655  *
7656  * @params[in] UmUniDirUlBearerCfg *
7657  *             void *
7658  *
7659  * @return ROK/RFAILED
7660  *
7661  * ****************************************************************/
7662
7663 void extractRlcUmUlCfg(UmUniDirUlBearerCfg *umUlCfgToSet, struct RLC_Config__um_Uni_Directional_DL *umUlCfg)
7664 {
7665    if(umUlCfg)
7666    {
7667       if(umUlCfg->dl_UM_RLC.sn_FieldLength)
7668       {
7669          umUlCfgToSet->ulUmCfg.snLenUlUm  = *(umUlCfg->dl_UM_RLC.sn_FieldLength);
7670          umUlCfgToSet->ulUmCfg.reAssemTmr = umUlCfg->dl_UM_RLC.t_Reassembly;
7671       }
7672    }
7673 }
7674
7675 /*******************************************************************
7676  *
7677  * @brief Function to build Um Uni Dl Info
7678  *
7679  * @details
7680  *
7681  *    Function : extractRlcUmDlCfg
7682  *
7683  *    Functionality: Function to build Um Uni Dl Info
7684  *
7685  * @params[in] UmUniDirDlBearerCfg *
7686  *             void *
7687  *
7688  * @return ROK/RFAILED
7689  *
7690  * ****************************************************************/
7691 void extractRlcUmDlCfg(UmUniDirDlBearerCfg *umDlCfgToSet, struct RLC_Config__um_Uni_Directional_UL *umDlCfg)
7692 {
7693    if(umDlCfg)
7694    {
7695       if(umDlCfg->ul_UM_RLC.sn_FieldLength)
7696          umDlCfgToSet->dlUmCfg.snLenDlUm  = *(umDlCfg->ul_UM_RLC.sn_FieldLength);
7697    }
7698 }
7699
7700 /*******************************************************************
7701  *
7702  * @brief Function to extractRlcModeCfg
7703  *
7704  * @details
7705  *
7706  *    Function : extractRlcModeCfg
7707  *
7708  *    Functionality: Function to extractRlcModeCfg
7709  *
7710  * @params[in] RLC_Config_t *
7711  *             RlcBearerCfg *
7712  *             void  *
7713  * @return ROK/RFAILED
7714  *
7715  * ****************************************************************/
7716 void extractRlcModeCfg(uint8_t rlcMode, RlcBearerCfg *rlcDbCfg, RLC_Config_t *lcCfg)
7717 {
7718    if(lcCfg)
7719    {
7720       switch(rlcMode)
7721       {
7722          case RLC_AM :
7723             {
7724                if(lcCfg->choice.am)
7725                {
7726                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.amCfg, sizeof(AmBearerCfg));
7727                   if(rlcDbCfg->u.amCfg)
7728                      extractRlcAmCfg(rlcDbCfg->u.amCfg, lcCfg->choice.am);
7729                }
7730                break;
7731             }
7732          case RLC_UM_BI_DIRECTIONAL :
7733             {
7734                if(lcCfg->choice.um_Bi_Directional)
7735                {
7736                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
7737                   if(rlcDbCfg->u.umBiDirCfg)
7738                      extractRlcUmBiCfg(rlcDbCfg->u.umBiDirCfg, lcCfg->choice.um_Bi_Directional);
7739                }
7740                break;
7741             }
7742          case RLC_UM_UNI_DIRECTIONAL_UL :
7743             {
7744                if(lcCfg->choice.um_Uni_Directional_DL)
7745                {
7746                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
7747                   if(rlcDbCfg->u.umUniDirUlCfg)
7748                      extractRlcUmUlCfg(rlcDbCfg->u.umUniDirUlCfg, lcCfg->choice.um_Uni_Directional_DL);
7749                }
7750                break;
7751             }
7752          case RLC_UM_UNI_DIRECTIONAL_DL :
7753             {
7754                if(lcCfg->choice.um_Uni_Directional_UL)
7755                {
7756                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
7757                   if(rlcDbCfg->u.umUniDirDlCfg)
7758                      extractRlcUmDlCfg(rlcDbCfg->u.umUniDirDlCfg, lcCfg->choice.um_Uni_Directional_UL);
7759                }
7760                break;
7761             }
7762          default:
7763             DU_LOG("\nERROR  -->  DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
7764             break;
7765       }
7766    }
7767 }
7768
7769 /*******************************************************************
7770  *
7771  * @brief Function to extract extractUlLcCfg
7772  *
7773  * @details
7774  *
7775  *    Function : extractUlLcCfg
7776  *
7777  *    Functionality: Function to extract extractUlLcCfg
7778  *
7779  * @params[in] UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg
7780  * @return void
7781  *
7782  * ****************************************************************/
7783
7784 void extractUlLcCfg(UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg)
7785 {
7786    if(ulLcCfg)
7787    {
7788       if(ulLcCfg->ul_SpecificParameters)
7789       {
7790          f1UlLcCfg->priority = \
7791             ulLcCfg->ul_SpecificParameters->priority;
7792       if(ulLcCfg->ul_SpecificParameters->logicalChannelGroup)
7793       {
7794          f1UlLcCfg->lcGroup = \
7795            *(ulLcCfg->ul_SpecificParameters->logicalChannelGroup);
7796       }
7797       if(ulLcCfg->ul_SpecificParameters->schedulingRequestID)
7798       {
7799          f1UlLcCfg->schReqId = \
7800            *(ulLcCfg->ul_SpecificParameters->schedulingRequestID);
7801       }
7802       f1UlLcCfg->pbr = \
7803          ulLcCfg->ul_SpecificParameters->prioritisedBitRate;
7804       f1UlLcCfg->bsd = \
7805          ulLcCfg->ul_SpecificParameters->bucketSizeDuration;
7806       }
7807    }
7808 }
7809
7810 /*******************************************************************
7811 *
7812 * @brief Function to extract Snssai Cfg Info from CU
7813 *
7814 * @details
7815 *
7816 *    Function : extractDrbSnssaiCfg
7817 *
7818 *    Functionality: Function to extract Drb Snssai Cfg Info from CU
7819 *
7820 * @params[in] DRB_Information_t *drbInfo, Snssai  *snssai
7821 * @return ROK/RFAILED
7822 *
7823 * ****************************************************************/
7824
7825 uint8_t extractDrbSnssaiCfg(SNSSAI_t *RecvSnssai, Snssai **snssaiToBeShared)
7826 {
7827    if(!(*snssaiToBeShared))
7828    {
7829       DU_ALLOC_SHRABL_BUF((*snssaiToBeShared), sizeof(Snssai));
7830       if(snssaiToBeShared == NULLP)
7831       {
7832          DU_LOG("\nERROR  -->  DUAPP : extractDrbSnssaiCfg(): Memory failed at allocating for SNSSAI ");
7833          return RFAILED;
7834       }
7835    }
7836    if(RecvSnssai)
7837    {
7838       memcpy(&(*snssaiToBeShared)->sst, RecvSnssai->sST.buf, RecvSnssai->sST.size);
7839       if(RecvSnssai->sD)
7840       {
7841          memcpy((*snssaiToBeShared)->sd, RecvSnssai->sD->buf,  RecvSnssai->sD->size);
7842       }
7843       else
7844       {
7845          DU_LOG("\nERROR  -->  DUAPP : extractDrbSnssaiCfg(): Received Null pointer of Snssai->SD");
7846          return RFAILED;
7847       }
7848    }
7849    return ROK;
7850 }
7851
7852 /*******************************************************************
7853  *
7854  * @brief Function to procRlcLcCfg
7855  *
7856  * @details
7857  *
7858  *    Function : procRlcLcCfg
7859  *
7860  *    Functionality: Function to procRlcLcCfg
7861  *
7862  * @params[in] rbId, lcId, rbType, rlcMod
7863  *             RLC_Config_t *, RlcBearerCfg * ,
7864  * @return void
7865  *
7866  * ****************************************************************/
7867
7868 void procRlcLcCfg(uint8_t rbId, uint8_t lcId, uint8_t rbType, uint8_t rlcMode,\
7869    uint8_t configType, RLC_Config_t *f1RlcCfg, RlcBearerCfg *lcCfg, QoSInformation_t *qoSInformation)
7870 {
7871    DRB_Information_t *drbInfo;
7872
7873    lcCfg->rbId   = rbId;
7874    lcCfg->configType = configType;
7875
7876    if(rbType == RB_TYPE_SRB)
7877    {
7878       lcCfg->rbType = RB_TYPE_SRB;
7879       lcCfg->lcId   = rbId;
7880       lcCfg->lcType = LCH_DCCH;
7881       lcCfg->rlcMode = RLC_AM;
7882    }
7883    else if(rbType == RB_TYPE_DRB)
7884    {
7885       lcCfg->rbType = RB_TYPE_DRB;
7886       lcCfg->lcId   = lcId;
7887       lcCfg->lcType = LCH_DTCH;
7888       lcCfg->rlcMode = rlcMode;
7889    }
7890    if(f1RlcCfg) /* rlc mode config recived */
7891    {
7892       extractRlcModeCfg(lcCfg->rlcMode, lcCfg, f1RlcCfg);
7893    }
7894    if(qoSInformation != NULLP)
7895    {
7896       if(qoSInformation->present == QoSInformation_PR_choice_extension)
7897       {
7898          if(qoSInformation->choice.choice_extension->value.present ==\
7899                QoSInformation_ExtIEs__value_PR_DRB_Information)
7900          {
7901             drbInfo = &qoSInformation->choice.choice_extension->value.choice.DRB_Information;
7902             if(extractDrbSnssaiCfg(&drbInfo->sNSSAI, &lcCfg->snssai) != ROK)
7903             {
7904                DU_LOG("\nERROR  -->  DUAPP: Unable to extract Snssai information at procRlcLcCfg()");
7905                return RFAILED;
7906             }
7907          }
7908       }
7909    }
7910 }
7911
7912 /*******************************************************************
7913  *
7914  * @brief Fills DrbQos Info received by CU
7915  *
7916  * @details
7917  *
7918  *    Function : extractQosInfo
7919  *
7920  *    Functionality: Fills DrbQos Info received  by CU
7921  *
7922  * @params[in] DrbQosInfo *qosToAdd,
7923  *             QoSFlowLevelQoSParameters_t *qosFlowCfg
7924  * @return void
7925  *
7926  * ****************************************************************/
7927
7928 void extractQosInfo(DrbQosInfo *qosToAdd, QoSFlowLevelQoSParameters_t *qosFlowCfg)
7929 {
7930    uint8_t qosCntIdx = 0;
7931    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
7932
7933    qosToAdd->fiveQiType = qosFlowCfg->qoS_Characteristics.present;
7934    qosToAdd->u.nonDyn5Qi.fiveQi     =\
7935                                      qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
7936    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow)
7937    {
7938       qosToAdd->u.nonDyn5Qi.avgWindow = \
7939                                         *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
7940    }
7941    qosToAdd->u.nonDyn5Qi.maxDataBurstVol = \
7942                                            *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
7943    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel)
7944    {
7945       qosToAdd->u.nonDyn5Qi.priorLevel = \
7946                                          *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel);
7947    }
7948    qosToAdd->ngRanRetPri.priorityLevel = \
7949                                          qosFlowCfg->nGRANallocationRetentionPriority.priorityLevel;
7950    qosToAdd->ngRanRetPri.preEmptionCap = \
7951                                          qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionCapability;
7952    qosToAdd->ngRanRetPri.preEmptionVul = \
7953                                          qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionVulnerability;
7954    if(qosFlowCfg->gBR_QoS_Flow_Information)
7955    {
7956       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateDl, \
7957             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.buf, \
7958             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.size);
7959       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateUl, \
7960             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.buf, \
7961             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.size);
7962       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateDl,\
7963             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.buf, \
7964             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.size);
7965       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateUl,\
7966             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.buf, \
7967             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.size);
7968    }
7969    /*Extracting PDU_SESSION_ID*/
7970    qosIeExt = (ProtocolExtensionContainer_4624P74_t *)qosFlowCfg->iE_Extensions;
7971    if(qosIeExt)
7972    {
7973       for(qosCntIdx = 0; qosCntIdx < qosIeExt->list.count; qosCntIdx++)
7974       {
7975          if(qosIeExt->list.array[qosCntIdx]->extensionValue.present == \
7976                QoSFlowLevelQoSParameters_ExtIEs__extensionValue_PR_PDUSessionID)
7977          {
7978             qosToAdd->pduSessionId = qosIeExt->list.array[qosCntIdx]->extensionValue.choice.PDUSessionID;
7979             DU_LOG("\nDEBUG -->  DU_F1AP : extractQosInfo: PDU SessionID:%d",qosToAdd->pduSessionId);
7980          }
7981       }
7982    }
7983    qosToAdd->ulPduSessAggMaxBitRate = 0;
7984 }
7985
7986 /*******************************************************************
7987  *
7988  * @brief Function to extract GTP Tunnel Info from CU
7989  *
7990  * @details
7991  *
7992  *    Function : extractUpTnlInfo
7993  *
7994  *    Functionality: Function to extract GTP Tunnel Info from CU
7995  *
7996  * @params[in] F1AP message
7997  * @return ROK/RFAILED
7998  *
7999  * ****************************************************************/
8000
8001 uint8_t extractUpTnlInfo(uint8_t drbId, uint8_t configType,\
8002    ULUPTNLInformation_ToBeSetup_List_t *tnlInfo, UpTnlCfg *upTnlInfo)
8003 {
8004    uint8_t tnlIdx;
8005    uint32_t ipv4_du = 0;
8006    GTPTunnel_t *gtpTunnel = NULLP;
8007
8008    upTnlInfo->drbId = drbId;
8009    upTnlInfo->configType = configType;
8010 #ifdef O1_ENABLE
8011    cmInetAddr((S8*)g_cfg.DU_IPV4_Addr, &ipv4_du);
8012 #else
8013    cmInetAddr((char *)DU_IP_V4_ADDR, &ipv4_du);
8014 #endif
8015
8016    for(tnlIdx=0; tnlIdx < tnlInfo->list.count; tnlIdx++)
8017    {
8018       if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
8019       {
8020          if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel)
8021          {
8022             gtpTunnel = tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel;
8023             DU_ALLOC(upTnlInfo->tnlCfg1, sizeof(GtpTnlCfg));
8024             if(upTnlInfo->tnlCfg1 == NULLP)
8025             {
8026                DU_LOG("\nERROR  -->  F1AP : extractUpTnlInfo: Failed to allocate mmeory for tunnel cfg 1");
8027                return RFAILED;
8028             }
8029             bitStringToInt(&gtpTunnel->transportLayerAddress, &upTnlInfo->tnlCfg1->ulTnlAddress);
8030             upTnlInfo->tnlCfg1->dlTnlAddress = ipv4_du;
8031             if(gtpTunnel->gTP_TEID.size > 0)
8032             {
8033                teIdStringToInt(gtpTunnel->gTP_TEID.buf, &upTnlInfo->tnlCfg1->teId);
8034             }
8035          }
8036          break;
8037       }
8038    }
8039    return ROK;
8040 }
8041
8042 /*******************************************************************
8043 *
8044 * @brief Function to extract Drb Qos Cfg Info from CU
8045 *
8046 * @details
8047 *
8048 *    Function : extractDrbQosCfg
8049 *
8050 *    Functionality: Function to extract Drb Qos Cfg Info from CU
8051 *
8052 * @params[in] DRB_Information_t *drbInfo, LcCfg *macLcToAdd
8053 * @return ROK/RFAILED
8054 *
8055 * ****************************************************************/
8056
8057 uint8_t extractDrbQosCfg(DRB_Information_t *drbInfo, LcCfg *macLcToAdd )
8058 {
8059    if(!macLcToAdd->drbQos)
8060    {
8061       DU_ALLOC_SHRABL_BUF(macLcToAdd->drbQos, sizeof(DrbQosInfo));
8062       if(macLcToAdd->drbQos == NULLP)
8063       {
8064          DU_LOG("\nERROR  -->  DUAPP:Memory failed at allocating DrbQos at extractDrbQosCfg()");
8065          return RFAILED;
8066       }
8067
8068    }
8069    if(drbInfo->dRB_QoS.qoS_Characteristics.present == QoS_Characteristics_PR_non_Dynamic_5QI)
8070    {
8071       extractQosInfo(macLcToAdd->drbQos, &drbInfo->dRB_QoS);
8072       macLcToAdd->dlLcCfg.lcp = macLcToAdd->drbQos->ngRanRetPri.priorityLevel;
8073    }
8074    if(extractDrbSnssaiCfg(&drbInfo->sNSSAI, &macLcToAdd->snssai) != ROK)
8075    {
8076       DU_LOG("\nERROR  -->  DUAPP: Unable to extract Snssai information  at extractDrbQosCfg()");
8077       return RFAILED;
8078    }
8079    return ROK;
8080 }
8081 /*******************************************************************
8082  *
8083  * @brief Function to extract DRB info received from CU
8084  *
8085  * @details
8086  *
8087  *    Function : extractDrbCfg
8088  *
8089  *    Functionality: Function to extract DRB info received from CU
8090  *
8091  * @params[in] F1AP message
8092  * @return void
8093  *
8094  * ****************************************************************/
8095 uint8_t extractDrbCfg(DRBs_ToBeSetup_Item_t *drbItem, DRBs_ToBeSetupMod_Item_t *drbSetupModItem,\
8096 DRBs_ToBeModified_Item_t *drbModItem,  LcCfg *macLcToAdd, UpTnlCfg *upTnlInfo)
8097 {
8098    DRB_Information_t *drbInfo = NULLP;
8099
8100    if(drbItem != NULLP)
8101    {
8102       if(extractUpTnlInfo(drbItem->dRBID, CONFIG_ADD, &drbItem->uLUPTNLInformation_ToBeSetup_List, upTnlInfo) != ROK)
8103       {
8104          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
8105          return RFAILED;
8106       }
8107       if(drbItem->qoSInformation.present == QoSInformation_PR_choice_extension)
8108       {
8109          if(drbItem->qoSInformation.choice.choice_extension->value.present == QoSInformation_ExtIEs__value_PR_DRB_Information)
8110          {
8111             drbInfo = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
8112             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
8113             {
8114                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
8115                return RFAILED;
8116             }
8117          }
8118       }
8119    }
8120    else if(drbSetupModItem != NULLP)
8121    {
8122       if(extractUpTnlInfo(drbSetupModItem->dRBID, CONFIG_ADD, &drbSetupModItem->uLUPTNLInformation_ToBeSetup_List,\
8123       upTnlInfo) != ROK)
8124       {
8125          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
8126          return RFAILED;
8127       }
8128       if(drbSetupModItem->qoSInformation.present == QoSInformation_PR_choice_extension)
8129       {
8130          if(drbSetupModItem->qoSInformation.choice.choice_extension->value.present ==\
8131          QoSInformation_ExtIEs__value_PR_DRB_Information)
8132          {
8133             drbInfo = &drbSetupModItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
8134             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
8135             {
8136                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
8137                return RFAILED;
8138             }
8139
8140          }
8141       }
8142    }
8143    else if(drbModItem != NULLP)
8144    {
8145       if(extractUpTnlInfo(drbModItem->dRBID, CONFIG_MOD, &drbModItem->uLUPTNLInformation_ToBeSetup_List,\
8146       upTnlInfo) != ROK)
8147       {
8148          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
8149          return RFAILED;
8150       }
8151       if(drbModItem->qoSInformation != NULLP)
8152       {
8153          if(drbModItem->qoSInformation->present == QoSInformation_PR_choice_extension)
8154          {
8155             if(drbModItem->qoSInformation->choice.choice_extension->value.present ==\
8156                   QoSInformation_ExtIEs__value_PR_DRB_Information)
8157             {
8158                drbInfo = &drbModItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information;
8159                if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
8160                {
8161                   DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
8162                   return RFAILED;
8163                }
8164
8165             }
8166          }
8167       }
8168    }
8169    return ROK;
8170 }
8171
8172 /*******************************************************************
8173  *
8174  * @brief Function to extract RB info received from CU
8175  *
8176  * @details
8177  *
8178  *    Function : extractMacRbCfg
8179  *
8180  *    Functionality: Function to extract RB info received from CU
8181  *
8182  * @params[in] F1AP message
8183  * @return ROK/RFAILED
8184  *
8185  * ****************************************************************/
8186
8187 uint8_t extractMacRbCfg(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbCfg,\
8188 DRBs_ToBeSetupMod_Item_t *drbSetupModCfg,  DRBs_ToBeModified_Item_t *drbModCfg, LogicalChannelConfig_t *ulLcCfg, LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
8189 {
8190    if(drbCfg != NULLP)
8191    {
8192       if(extractDrbCfg(drbCfg, NULL, NULL, lcCfg, upTnlInfo) != ROK)
8193       {
8194          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
8195          return RFAILED;
8196       }
8197    }
8198    else if(drbSetupModCfg != NULLP)
8199    {
8200       if(extractDrbCfg(NULL, drbSetupModCfg, NULL, lcCfg, upTnlInfo) != ROK)
8201       {
8202          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
8203          return RFAILED;
8204       }
8205    }
8206    else if(drbModCfg != NULLP)
8207    {
8208       if(extractDrbCfg(NULL, NULL, drbModCfg, lcCfg, upTnlInfo) != ROK)
8209       {
8210          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
8211          return RFAILED;
8212       }
8213    }
8214    else
8215    {
8216       lcCfg->drbQos = NULLP;
8217       lcCfg->snssai = NULLP;
8218       if(lcCfg->lcId == SRB2_LCID)
8219          lcCfg->dlLcCfg.lcp = LC_PRIORITY_3;
8220       else
8221          lcCfg->dlLcCfg.lcp = LC_PRIORITY_1;
8222    }
8223    if(ulLcCfg)
8224    {
8225       lcCfg->ulLcCfgPres = true;
8226       extractUlLcCfg(&lcCfg->ulLcCfg, ulLcCfg);
8227    }
8228    else
8229       lcCfg->ulLcCfgPres = false;
8230    return ROK;
8231 }
8232
8233 /*******************************************************************
8234  *
8235  * @brief Function processing LC config info received from CU
8236  *
8237  * @details
8238  *
8239  *    Function : procMacLcCfg
8240  *
8241  *    Functionality: Function processing LC config info received from CU
8242  *
8243  * @params[in] F1AP message
8244  * @return ROK/RFAILED
8245  *
8246  * ****************************************************************/
8247
8248 uint8_t procMacLcCfg(uint8_t lcId, uint8_t rbType, uint8_t configType, DRBs_ToBeSetup_Item_t *drbItem,\
8249 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, LogicalChannelConfig_t *ulLcCfg,\
8250 LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
8251 {
8252    uint8_t ret = ROK;
8253
8254    lcCfg->lcId = lcId;
8255    lcCfg->configType = configType;
8256    if(rbType == RB_TYPE_SRB)
8257    {
8258       ret = extractMacRbCfg(lcId, NULL, NULL, NULL, ulLcCfg, lcCfg, NULL);
8259    }
8260    else if(rbType == RB_TYPE_DRB)
8261    {
8262       if(drbItem != NULL)
8263         ret = extractMacRbCfg(lcId, drbItem, NULL, NULL, ulLcCfg, lcCfg, upTnlInfo);
8264       else if(drbSetupModItem != NULL)
8265         ret = extractMacRbCfg(lcId, NULL, drbSetupModItem, NULL, ulLcCfg, lcCfg, upTnlInfo);
8266       else if(drbModItem != NULL)
8267         ret = extractMacRbCfg(lcId, NULL, NULL, drbModItem, ulLcCfg, lcCfg, upTnlInfo);
8268    }
8269    return ret;
8270 }
8271
8272 /*******************************************************************
8273  *
8274  * @brief Function to extract Rlc cfg To Add/Mod in CellGrp Info
8275  *
8276  * @details
8277  *
8278  *    Function : extractRlcCfgToAddMod
8279  *
8280  *    Functionality: Function to extract Rlc cfg To Add/Mod in CellGrp Info
8281  *
8282  * @params[in] CellGroupConfigRrc__rlc_BearerTo pointer
8283  *             DuUeCfg Pointer
8284  * @return ROK/RFAILED
8285  *
8286  * ****************************************************************/
8287
8288 uint8_t extractRlcCfgToAddMod(struct CellGroupConfigRrc__rlc_BearerToAddModList *lcCfg, DuUeCfg *ueCfgDb)
8289 {
8290   uint8_t idx, rbId, lcId, rlcMode, rbType;
8291   RLC_Config_t *f1RlcCfg = NULLP;
8292   LogicalChannelConfig_t *macUlLcCfg = NULLP;
8293
8294   for(idx = 0; idx < lcCfg->list.count; idx++)
8295   {
8296      lcId = lcCfg->list.array[idx]->logicalChannelIdentity;
8297      if(lcCfg->list.array[idx]->servedRadioBearer)
8298      {
8299         /* RadioBearer for SRB/DRB */
8300         if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
8301         RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
8302         {
8303            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.srb_Identity;
8304            rbType = RB_TYPE_SRB;
8305         }
8306         else if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
8307         RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
8308         {
8309            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.drb_Identity;
8310            rbType = RB_TYPE_DRB;
8311         }
8312         else
8313         {
8314            DU_LOG("\nERROR  -->  No components present in Bearer config to ADD/MOD");
8315            return RFAILED;
8316         }
8317         /* MAC UL LC Config */
8318         if(lcCfg->list.array[idx]->mac_LogicalChannelConfig)
8319         {
8320            macUlLcCfg = lcCfg->list.array[idx]->mac_LogicalChannelConfig;
8321         }
8322      }
8323      else
8324      {
8325         DU_LOG("\nERROR  -->  DUAPP: Received RadioBearer config is NULL");
8326         return RFAILED;
8327      }
8328      /* RLC Mode Config */
8329      if(lcCfg->list.array[idx]->rlc_Config)
8330      {
8331         rlcMode  = lcCfg->list.array[idx]->rlc_Config->present;
8332         f1RlcCfg = lcCfg->list.array[idx]->rlc_Config;
8333      }
8334
8335      /* Filling RLC/MAC Config*/
8336      memset(&ueCfgDb->macLcCfg[idx], 0, sizeof(LcCfg));
8337      memset(&ueCfgDb->rlcLcCfg[idx], 0, sizeof(RlcBearerCfg));
8338      procRlcLcCfg(rbId, lcId, rbType, rlcMode, CONFIG_UNKNOWN, f1RlcCfg, &(ueCfgDb->rlcLcCfg[idx]), NULLP);
8339      if(procMacLcCfg(lcId, rbType, CONFIG_UNKNOWN, NULL, NULL, NULL, macUlLcCfg, &ueCfgDb->macLcCfg[idx], NULL) != ROK)
8340      {
8341         DU_LOG("\nERROR  -->  DU APP : Failed while filling MAC LC config at extractRlcCfgToAddMod()");
8342         return RFAILED;
8343      }
8344      (ueCfgDb->numRlcLcs)++;
8345      (ueCfgDb->numMacLcs)++;
8346          DU_LOG("\nDEBUG  -> DUAPP: extractRlcCfgToAddMod:RBType:%d, DrbID: %d,lcId:%d, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
8347                             rbType, rbId, lcId, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
8348   }
8349   //TODO: To send the failure cause in UeContextSetupRsp
8350   return ROK;
8351 }
8352
8353 /*******************************************************************
8354  *
8355  * @brief DeAlloc pdsch serv cell config info
8356  *
8357  * @details
8358  *
8359  *    Function : freeMacPdschServCellInfo
8360  *
8361  *    Functionality: DeAlloc pdsch serv cell config info
8362  *
8363  * @params[in] PdschServCellCfg pointer
8364  * @return void
8365  *
8366  * ****************************************************************/
8367
8368 void freeMacPdschServCellInfo(PdschServCellCfg *pdsch)
8369 {
8370    if(pdsch->xOverhead)
8371    {
8372       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->xOverhead, sizeof(PdschXOverhead));
8373    }
8374    if(pdsch->codeBlkGrpFlushInd)
8375    {
8376       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->codeBlkGrpFlushInd, sizeof(bool));
8377    }
8378    if(pdsch->maxCodeBlkGrpPerTb)
8379    {
8380       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
8381    }
8382    if(pdsch->maxMimoLayers)
8383    {
8384       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxMimoLayers, sizeof(uint8_t));
8385    }
8386 }
8387
8388 /*******************************************************************
8389  *
8390  * @brief Free Serving cell Info
8391  *
8392  * @details
8393  *
8394  *    Function : freeMacServingCellInfo
8395  *
8396  *    Functionality: Free Serving cell Info
8397  *
8398  * @params[in] ServCellCfgInfo *srvCellCfg
8399  * @return void
8400  *
8401  * ****************************************************************/
8402 void freeMacServingCellInfo(ServCellCfgInfo *srvCellCfg)
8403 {
8404    uint8_t timeDomRsrcIdx;
8405
8406    if(srvCellCfg->initDlBwp.pdschPresent)
8407    {
8408       for(timeDomRsrcIdx = 0; timeDomRsrcIdx < srvCellCfg->initDlBwp.pdschCfg.numTimeDomRsrcAlloc; timeDomRsrcIdx++)
8409       {
8410          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, \
8411             srvCellCfg->initDlBwp.pdschCfg.timeDomRsrcAllociList[timeDomRsrcIdx].k0, sizeof(uint8_t));
8412       }
8413    }
8414
8415    freeMacPdschServCellInfo(&srvCellCfg->pdschServCellCfg);
8416    if(srvCellCfg->bwpInactivityTmr)
8417    {
8418       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
8419    }
8420
8421    if(srvCellCfg->initUlBwp.pucchPresent)
8422    {
8423       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->initUlBwp.pucchCfg.dlDataToUlAck, sizeof(PucchDlDataToUlAck));
8424    }
8425 }
8426
8427 /*******************************************************************
8428  *
8429  * @brief Free cell Grp Cfg Info
8430  *
8431  * @details
8432  *
8433  *    Function : freeUeReCfgCellGrpInfo
8434  *
8435  *    Functionality: Free cell Grp Cfg Info
8436  *
8437  * @params[in] MacUeCfg*  duUeCfg
8438  * @return void
8439  *
8440  * ****************************************************************/
8441
8442 void freeUeReCfgCellGrpInfo(MacUeCfg *macUeCfg)
8443 {
8444    freeMacServingCellInfo(&macUeCfg->spCellCfg.servCellCfg);
8445 }
8446
8447 /*******************************************************************
8448  *
8449  * @brief Fills Reconfig SchReqReConfig
8450  *
8451  * @details
8452  *
8453  *    Function : extractSchReqReConfig
8454  *
8455  *    Functionality: Fills Reconfig SchReqReConfig
8456  *
8457  * @params[in] SchedulingRequestConfig_t *cuSchedReq
8458  *             SchedReqCfg*  macSchedReq
8459  * @return void
8460  *
8461  * ****************************************************************/
8462 void extractSchReqReConfig(SchedulingRequestConfig_t *cuSchedReq, SchedReqCfg *macSchedReq)
8463 {
8464    uint8_t schReqIdx = 0;
8465    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqListToAdd = NULLP;
8466    struct SchedulingRequestConfig__schedulingRequestToReleaseList *schReqListToRel = NULLP;
8467
8468    if(cuSchedReq->schedulingRequestToAddModList)
8469    {
8470       schReqListToAdd = cuSchedReq->schedulingRequestToAddModList;
8471       if(schReqListToAdd->list.count)
8472       {
8473          macSchedReq->addModListCount = schReqListToAdd->list.count;
8474          for(schReqIdx = 0; schReqIdx < schReqListToAdd->list.count; schReqIdx++)
8475          {
8476             macSchedReq->addModList[schReqIdx].schedReqId = \
8477                schReqListToAdd->list.array[schReqIdx]->schedulingRequestId;
8478             macSchedReq->addModList[schReqIdx].srProhibitTmr = \
8479                *(schReqListToAdd->list.array[schReqIdx]->sr_ProhibitTimer);
8480             macSchedReq->addModList[schReqIdx].srTransMax    =\
8481                schReqListToAdd->list.array[schReqIdx]->sr_TransMax;
8482          }
8483       }
8484    }
8485    /* Scheduling Req To release */
8486    if(cuSchedReq->schedulingRequestToReleaseList)
8487    {
8488       schReqListToRel = cuSchedReq->schedulingRequestToReleaseList;
8489       if(schReqListToRel->list.count)
8490       {
8491          macSchedReq->relListCount = schReqListToRel->list.count;
8492          for(schReqIdx = 0; schReqIdx < schReqListToRel->list.count; schReqIdx++)
8493          {
8494             macSchedReq->relList[schReqIdx] = \
8495                *schReqListToRel->list.array[schReqIdx];
8496          }
8497       }
8498    }
8499 }
8500
8501 /*******************************************************************
8502  *
8503  * @brief Fills TagReconfig
8504  *
8505  * @details
8506  *
8507  *    Function : extractTagReconfig
8508  *
8509  *    Functionality: Fills extractTagReconfig
8510  *
8511  * @params[in] TAG_Config_t *cuTagCfg
8512  *             TagCfg *macTagCfg
8513  * @return void
8514  *
8515  * ****************************************************************/
8516
8517 void extractTagReconfig(TAG_Config_t *cuTagCfg, TagCfg *macTagCfg)
8518 {
8519   uint8_t tagIdx = 0;
8520   struct TAG_Config__tag_ToAddModList  *tagListToAddMod = NULLP;
8521   struct TAG_Config__tag_ToReleaseList *tagListToRel = NULLP;
8522
8523   /* Tag config to AddMod */
8524   if(cuTagCfg->tag_ToAddModList)
8525   {
8526      tagListToAddMod = cuTagCfg->tag_ToAddModList;
8527      if(tagListToAddMod->list.count)
8528      {
8529         macTagCfg->addModListCount = tagListToAddMod->list.count;
8530         for(tagIdx = 0; tagIdx < tagListToAddMod->list.count; tagIdx++)
8531         {
8532            macTagCfg->addModList[tagIdx].tagId =\
8533               tagListToAddMod->list.array[tagIdx]->tag_Id;
8534            macTagCfg->addModList[tagIdx].timeAlignTimer = \
8535
8536               tagListToAddMod->list.array[tagIdx]->timeAlignmentTimer;
8537         }
8538      }
8539   }
8540   /* Tag config to release */
8541   if(cuTagCfg->tag_ToReleaseList)
8542   {
8543      tagListToRel = cuTagCfg->tag_ToReleaseList;
8544      if(tagListToRel->list.count)
8545      {
8546         macTagCfg->relListCount = tagListToRel->list.count;
8547         for(tagIdx = 0; tagIdx < tagListToRel->list.count; tagIdx++)
8548         {
8549            macTagCfg->relList[tagIdx] = *tagListToRel->list.array[tagIdx];
8550         }
8551      }
8552   }
8553 }
8554
8555 /*******************************************************************
8556  *
8557  * @brief Fills PdcchCfg received by CU
8558  *
8559  * @details
8560  *
8561  *    Function : extractPdcchCfg
8562  *
8563  *    Functionality: Fills PdcchCfg received  by CU
8564  *
8565  * @params[in] PDCCH_Config_t *cuPdcchCfg,
8566  *             PdcchConfig *duPdcchCfg
8567  * @return void
8568  *
8569  * ****************************************************************/
8570
8571 void extractPdcchCfg(PDCCH_Config_t *cuPdcchCfg, PdcchConfig *macPdcchCfg)
8572 {
8573    uint8_t cRsetIdx = 0;
8574    uint8_t srchSpcIdx = 0;
8575
8576    struct PDCCH_Config__controlResourceSetToAddModList *cRsetToAddModList = NULLP;
8577    struct PDCCH_Config__controlResourceSetToReleaseList *cRsetToRelList = NULLP;
8578    struct PDCCH_Config__searchSpacesToAddModList *srchSpcToAddModList = NULLP;
8579    struct PDCCH_Config__searchSpacesToReleaseList *srchSpcToRelList = NULLP;
8580
8581
8582    /* Control Resource Set To Add/Mod List */
8583    if(cuPdcchCfg->controlResourceSetToAddModList)
8584    {
8585       cRsetToAddModList = cuPdcchCfg->controlResourceSetToAddModList;
8586       if(cRsetToAddModList->list.count)
8587       {
8588          macPdcchCfg->numCRsetToAddMod = cRsetToAddModList->list.count;
8589          for(cRsetIdx = 0; cRsetIdx < cRsetToAddModList->list.count; cRsetIdx++)
8590          {
8591             macPdcchCfg->cRSetToAddModList[cRsetIdx].cRSetId = \
8592                cRsetToAddModList->list.array[cRsetIdx]->controlResourceSetId;
8593             //freqDomRsrcBitStringToInt(&cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources,\
8594                   macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc);
8595             memcpy(macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc, \
8596                cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources.buf,
8597                cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources.size);
8598
8599             macPdcchCfg->cRSetToAddModList[cRsetIdx].duration = \
8600                 cRsetToAddModList->list.array[cRsetIdx]->duration;
8601
8602             macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType = \
8603                cRsetToAddModList->list.array[cRsetIdx]->cce_REG_MappingType.present;
8604             if(macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType == CCE_REG_MAPPINGTYPE_PR_INTERLEAVED)
8605             {
8606                //TODO: handle the case for Interleaved
8607             }
8608             macPdcchCfg->cRSetToAddModList[cRsetIdx].precoderGranularity = \
8609                 cRsetToAddModList->list.array[cRsetIdx]->precoderGranularity;
8610             if(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID)
8611             {
8612                macPdcchCfg->cRSetToAddModList[cRsetIdx].dmrsScramblingId= \
8613                   *(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID);
8614             }
8615          }
8616       }
8617    }
8618    /* Control Resource Set To Release List */
8619    if(cuPdcchCfg->controlResourceSetToReleaseList)
8620    {
8621       cRsetToRelList = cuPdcchCfg->controlResourceSetToReleaseList;
8622       if(cRsetToRelList->list.count)
8623       {
8624          macPdcchCfg->numCRsetToRel = cRsetToRelList->list.count;
8625          for(cRsetIdx = 0; cRsetIdx < cRsetToRelList->list.count; cRsetIdx++)
8626          {
8627             macPdcchCfg->cRSetToRelList[cRsetIdx] = *(cRsetToRelList->list.array[cRsetIdx]);
8628          }
8629       }
8630    }
8631
8632    /* Search space To Add/Mod List */
8633    if(cuPdcchCfg->searchSpacesToAddModList)
8634    {
8635       srchSpcToAddModList = cuPdcchCfg->searchSpacesToAddModList;
8636       if(srchSpcToAddModList->list.count)
8637       {
8638          macPdcchCfg->numSearchSpcToAddMod = srchSpcToAddModList->list.count;
8639          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToAddModList->list.count; srchSpcIdx++)
8640          {
8641             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceId =\
8642                                                                           srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceId;
8643             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].cRSetId =\
8644                                                                     *(srchSpcToAddModList->list.array[srchSpcIdx]->controlResourceSetId);
8645             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset)
8646             {
8647                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset =\
8648                                                                                          srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset->present;
8649             }
8650             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot)
8651             {
8652                bitStringToInt(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot,\
8653                      macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSymbolsWithinSlot);
8654             }
8655             if(srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates)
8656             {
8657                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel1 = \
8658                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel1;
8659                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel2 = \
8660                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel2;
8661                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel4 = \
8662                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel4;
8663
8664                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel8 = \
8665                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel8;
8666
8667                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel16 = \
8668                                                                                         srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel16;
8669             }
8670             if(srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType)
8671             {
8672                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType =\
8673                                                                                srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->present;
8674                if(macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType == SEARCHSPACETYPE_PR_UE_SPECIFIC)
8675                {
8676                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].ueSpecificDciFormat =\
8677                                                                                       srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->choice.ue_Specific->dci_Formats;
8678                }
8679
8680             }
8681          }
8682       }
8683    }
8684    /* Search space To Rel List */
8685    if(cuPdcchCfg->searchSpacesToReleaseList)
8686    {
8687       srchSpcToRelList = cuPdcchCfg->searchSpacesToReleaseList;
8688       if(srchSpcToRelList->list.count)
8689       {
8690          macPdcchCfg->numSearchSpcToRel = srchSpcToRelList->list.count;
8691          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToRelList->list.count; srchSpcIdx++)
8692          {
8693             macPdcchCfg->searchSpcToRelList[srchSpcIdx] =\
8694                                                          *(srchSpcToRelList->list.array[srchSpcIdx]);
8695          }
8696       }
8697    }
8698 }
8699
8700 /*******************************************************************
8701  *
8702  * @brief Fills PdschCfg received by CU
8703  *
8704  * @details
8705  *
8706  *    Function : extractPdschCfg
8707  *
8708  *    Functionality: Fills PdschCfg received  by CU
8709  *
8710  * @params[in] PDSCH_Config_t *cuPdschCfg = Information which is send by CU,
8711  *                   which we have stored in F1UeContextSetupDb,
8712  *             PdschConfig *macPdschCfg = Used to Store the information which
8713  *                   needs to send in other layer, as well as this can be the variable
8714  *                   which stores the information in DuCb,
8715  *             PdschConfig *storedPdschCfg =  Null in case of sending the
8716  *                   information to other layer else it will have stored pdsch
8717  *                   configuration in copyOfmacUeCfg.
8718  * @return void
8719  *
8720  * ****************************************************************/
8721
8722 void extractPdschCfg(PDSCH_Config_t *cuPdschCfg, PdschConfig *macPdschCfg, PdschConfig *storedPdschCfg)
8723 {
8724    uint8_t timeDomIdx;
8725    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAlloc = NULLP;
8726
8727    if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
8728    {
8729       if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->present == \
8730             PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup)
8731       {
8732          if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup)
8733          {
8734             macPdschCfg->dmrsDlCfgForPdschMapTypeA.addPos = \
8735                *(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_AdditionalPosition);
8736          }
8737       }
8738    }
8739    macPdschCfg->resourceAllocType = cuPdschCfg->resourceAllocation;
8740    if(cuPdschCfg->pdsch_TimeDomainAllocationList)
8741    {
8742       timeDomAlloc = cuPdschCfg->pdsch_TimeDomainAllocationList;
8743       if(timeDomAlloc->present ==\
8744             PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup)
8745       {
8746          if(timeDomAlloc->choice.setup)
8747          {
8748             macPdschCfg->numTimeDomRsrcAlloc  = timeDomAlloc->choice.setup->list.count;
8749             for(timeDomIdx = 0; timeDomIdx < timeDomAlloc->choice.setup->list.count; timeDomIdx++)
8750             {
8751                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 = NULLP;
8752                if(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0)
8753                {
8754                   if(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 == NULL)
8755                   {
8756                      if(storedPdschCfg)
8757                      {
8758                         if(storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
8759                         {
8760                            macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 =\
8761                            storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0;
8762                         }
8763                         else
8764                         {
8765                            DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
8766                         }
8767                      }
8768                      else
8769                      {
8770                         DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
8771                      }
8772                      if(!macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
8773                      {
8774                         DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for k0 at extractPdschCfg()");
8775                         return RFAILED;
8776                      }
8777                   }
8778                   *(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0) = \
8779                   *(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0);
8780                }
8781                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
8782                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
8783                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
8784                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8785             }
8786          }
8787       }
8788    }
8789    macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
8790    if(cuPdschCfg->maxNrofCodeWordsScheduledByDCI)
8791       macPdschCfg->numCodeWordsSchByDci = *(cuPdschCfg->maxNrofCodeWordsScheduledByDCI);
8792    if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_staticBundling)
8793    {
8794       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
8795       if(cuPdschCfg->prb_BundlingType.choice.staticBundling)
8796       {
8797          if(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize)
8798          {
8799             macPdschCfg->bundlingInfo.StaticBundling.size = \
8800                *(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize);
8801          }
8802       }
8803    }
8804    else if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_dynamicBundling)
8805    {
8806       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
8807    }
8808
8809 }
8810
8811 /*******************************************************************
8812  *
8813  * @brief Fills PdschServingCellCfg received by CU
8814  *
8815  * @details
8816  *
8817  *    Function : extractPdschServingCellCfg
8818  *
8819  *    Functionality: Fills PdschCfg received  by CU
8820  *
8821  * @params[in] PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg,
8822  *             PdschServCellCfg *macUePdschSrvCellCfg
8823  * @return ROK/RFAILED
8824  *
8825  * ****************************************************************/
8826
8827 uint8_t extractPdschServingCellCfg(PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg, PdschServCellCfg *macUePdschSrvCellCfg)
8828 {
8829    if(cuPdschSrvCellCfg->codeBlockGroupTransmission)
8830    {
8831       if(cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup)
8832       {
8833          if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
8834          {
8835             *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
8836                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
8837          }
8838          else
8839          {
8840             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
8841             if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
8842             {
8843                *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
8844                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
8845             }
8846             else
8847             {
8848                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
8849                return RFAILED;
8850             }
8851          }
8852          if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
8853          {
8854             *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
8855                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
8856          }
8857          else
8858          {
8859             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->codeBlkGrpFlushInd , sizeof(bool));
8860             if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
8861             {
8862                *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
8863                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
8864             }
8865             else
8866             {
8867                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
8868                return RFAILED;
8869             }
8870          }
8871       }
8872    }
8873    if(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH)
8874    {
8875       macUePdschSrvCellCfg->numHarqProcForPdsch = *(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH);
8876    }
8877    if(cuPdschSrvCellCfg->ext1)
8878    {
8879       if(cuPdschSrvCellCfg->ext1->maxMIMO_Layers)
8880       {
8881         if(macUePdschSrvCellCfg->maxMimoLayers)
8882         {
8883            *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
8884         }
8885         else
8886         {
8887            DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxMimoLayers, sizeof(uint8_t));
8888            if(macUePdschSrvCellCfg->maxMimoLayers)
8889            {
8890               *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
8891            }
8892            else
8893            {
8894               DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
8895               return RFAILED;
8896            }
8897         }
8898       }
8899    }
8900    if(cuPdschSrvCellCfg->xOverhead)
8901    {
8902       if(macUePdschSrvCellCfg->xOverhead)
8903       {
8904          *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
8905       }
8906       else
8907       {
8908          DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->xOverhead, sizeof(PdschXOverhead));
8909          if(macUePdschSrvCellCfg->xOverhead)
8910          {
8911             *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
8912          }
8913          else
8914          {
8915             DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
8916             return RFAILED;
8917          }
8918       }
8919    }
8920    return ROK;
8921 }
8922
8923 /*******************************************************************
8924  *
8925  * @brief Fills PuschCfg received by CU
8926  *
8927  * @details
8928  *
8929  *    Function : extractPuschCfg
8930  *
8931  *    Functionality: Fills PuschCfg received  by CU
8932  *
8933  * @params[in] BWP_UplinkDedicated__pusch_Config *cuPuschCfg,
8934  *             PuschCfg *macPuschCfg
8935  * @return void
8936  *
8937  * ****************************************************************/
8938
8939 void extractPuschCfg(struct BWP_UplinkDedicated__pusch_Config *cuPuschCfg, PuschCfg *macPuschCfg)
8940 {
8941    uint8_t timeDomIdx = 0;
8942    DMRS_UplinkConfig_t *dmrsUlCfg = NULLP;
8943    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList = NULLP;
8944
8945    if(cuPuschCfg->present == BWP_UplinkDedicated__pusch_Config_PR_setup)
8946    {
8947       if(cuPuschCfg->choice.setup)
8948       {
8949          if(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH)
8950          {
8951              macPuschCfg->dataScramblingId = \
8952                 *(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH);
8953          }
8954          if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA)
8955          {
8956             if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->present == PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup)
8957             {
8958                if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup)
8959                {
8960                   dmrsUlCfg = (cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup);
8961                   if(dmrsUlCfg->dmrs_AdditionalPosition)
8962                   {
8963                      macPuschCfg->dmrsUlCfgForPuschMapTypeA.addPos =\
8964                         *(dmrsUlCfg->dmrs_AdditionalPosition);
8965                   }
8966                   if(dmrsUlCfg->transformPrecodingDisabled)
8967                   {
8968                      if(dmrsUlCfg->transformPrecodingDisabled->scramblingID0)
8969                      {
8970                         macPuschCfg->dmrsUlCfgForPuschMapTypeA.transPrecodDisabled.scramblingId0 = \
8971                            *(dmrsUlCfg->transformPrecodingDisabled->scramblingID0);
8972                      }
8973                   }
8974                }
8975             }
8976          }
8977          /*Res Alloc Type for UL */
8978          if(cuPuschCfg->choice.setup->resourceAllocation)
8979          {
8980             macPuschCfg->resourceAllocType = \
8981                cuPuschCfg->choice.setup->resourceAllocation;
8982          }
8983          if(cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList)
8984          {
8985             timeDomAllocList = cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList;
8986             if(timeDomAllocList->present == PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup)
8987             {
8988                if(timeDomAllocList->choice.setup)
8989                {
8990                   macPuschCfg->numTimeDomRsrcAlloc = timeDomAllocList->choice.setup->list.count;
8991                   for(timeDomIdx = 0; timeDomIdx <timeDomAllocList->choice.setup->list.count; timeDomIdx++)
8992                   {
8993                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].k2 = \
8994                         *(timeDomAllocList->choice.setup->list.array[timeDomIdx]->k2);
8995                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].mappingType = \
8996                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->mappingType;
8997                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbolAndLength = \
8998                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8999                   }
9000                }
9001             }
9002          }
9003          if(cuPuschCfg->choice.setup->transformPrecoder)
9004             macPuschCfg->transformPrecoder = *(cuPuschCfg->choice.setup->transformPrecoder);
9005       }
9006    }
9007 }
9008
9009 /*******************************************************************
9010  *
9011  * @brief Function to fill pucch Power Control
9012  *
9013  * @details
9014  *
9015  *    Function : extractPucchPowerControl
9016  *
9017  *    Functionality: Function to fill pucch Power Control
9018  *
9019  * @params[in] PucchPowerControl *pwrCtrl,
9020  *             struct PUCCH_PowerControl *cuPwrCtrlCfg
9021  * @return void
9022  *
9023  * ****************************************************************/
9024
9025 void extractPucchPowerControl(PucchPowerControl *pwrCtrl, struct PUCCH_PowerControl *cuPwrCtrlCfg)
9026 {
9027    uint8_t arrIdx;
9028
9029    if(cuPwrCtrlCfg->deltaF_PUCCH_f0)
9030       pwrCtrl->deltaF_Format0 = *cuPwrCtrlCfg->deltaF_PUCCH_f0;
9031    if(cuPwrCtrlCfg->deltaF_PUCCH_f1)
9032       pwrCtrl->deltaF_Format1 = *cuPwrCtrlCfg->deltaF_PUCCH_f1;
9033    if(cuPwrCtrlCfg->deltaF_PUCCH_f2)
9034       pwrCtrl->deltaF_Format2 = *cuPwrCtrlCfg->deltaF_PUCCH_f2;
9035    if(cuPwrCtrlCfg->deltaF_PUCCH_f3)
9036       pwrCtrl->deltaF_Format3 = *cuPwrCtrlCfg->deltaF_PUCCH_f3;
9037    if(cuPwrCtrlCfg->deltaF_PUCCH_f4)
9038       pwrCtrl->deltaF_Format4 = *cuPwrCtrlCfg->deltaF_PUCCH_f4;
9039    if(cuPwrCtrlCfg->p0_Set)
9040    {
9041       pwrCtrl->p0SetCount = cuPwrCtrlCfg->p0_Set->list.count;
9042       for(arrIdx=0; arrIdx < pwrCtrl->p0SetCount; arrIdx++)
9043       {
9044          pwrCtrl->p0Set[arrIdx].p0PucchId =\
9045             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Id;
9046          pwrCtrl->p0Set[arrIdx].p0PucchVal =\
9047             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Value;
9048       }
9049    }
9050    if(cuPwrCtrlCfg->pathlossReferenceRSs)
9051    {
9052       pwrCtrl->pathLossRefRSListCount = cuPwrCtrlCfg->pathlossReferenceRSs->list.count;
9053       for(arrIdx = 0; arrIdx < pwrCtrl->pathLossRefRSListCount; arrIdx++)
9054       {
9055          pwrCtrl->pathLossRefRSList[arrIdx].pathLossRefRSId =\
9056             cuPwrCtrlCfg->pathlossReferenceRSs->list.array[arrIdx]->pucch_PathlossReferenceRS_Id;
9057       }
9058    }
9059 }
9060
9061  /*******************************************************************
9062  *
9063  * @brief Function to extractResrcSetToAddModList sent by CU
9064  *
9065  * @details
9066  *
9067  *    Function : extractResrcSetToAddModList
9068  *
9069  *    Functionality: Fucntion to extractResrcSetToAddModList
9070  *
9071  * @params[in] PucchResrcSetCfg pointer,
9072  *             struct PUCCH_Config__resourceSetToAddModList pointer
9073  * @return void
9074  *
9075  * ****************************************************************/
9076
9077 void extractResrcSetToAddModList(PucchResrcSetCfg *macRsrcSetList, struct PUCCH_Config__resourceSetToAddModList *cuRsrcSetList)
9078 {
9079    uint8_t arrIdx, rsrcListIdx;
9080
9081    macRsrcSetList->resrcSetToAddModListCount = cuRsrcSetList->list.count;
9082    for(arrIdx = 0; arrIdx < macRsrcSetList->resrcSetToAddModListCount; arrIdx++)
9083    {
9084       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcSetId     =\
9085          cuRsrcSetList->list.array[arrIdx]->pucch_ResourceSetId;
9086       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount =\
9087          cuRsrcSetList->list.array[arrIdx]->resourceList.list.count;
9088       for(rsrcListIdx = 0; rsrcListIdx < macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount; rsrcListIdx++)
9089       {
9090          macRsrcSetList->resrcSetToAddModList[arrIdx].resrcList[rsrcListIdx] =\
9091             *cuRsrcSetList->list.array[arrIdx]->resourceList.list.array[rsrcListIdx];
9092       }
9093
9094       if(cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1)
9095       {
9096          macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize =\
9097             *cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1;
9098       }
9099       else
9100       {
9101          macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize = 0;
9102       }
9103    }
9104 }/* End of extractResrcSetToAddModList */
9105
9106 /*******************************************************************
9107  *
9108  * @brief Fills extractResrcToAddModList sent by CU
9109  *
9110  * @details
9111  *
9112  *    Function : extractResrcToAddModList
9113  *
9114  *    Functionality: Fills extractResrcToAddModList
9115  *
9116  * @params[in] PucchResrcCfg pointer,
9117  *             struct PUCCH_Config__resourceToAddModList pointer
9118  * @return ROk/RFAILED
9119  *
9120  * ****************************************************************/
9121
9122 uint8_t extractResrcToAddModList(PucchResrcCfg *macResrcList, struct PUCCH_Config__resourceToAddModList *cuResrcList)
9123 {
9124    uint8_t arrIdx;
9125
9126    macResrcList->resrcToAddModListCount = cuResrcList->list.count;
9127    for(arrIdx = 0; arrIdx < macResrcList->resrcToAddModListCount; arrIdx++)
9128    {
9129       macResrcList->resrcToAddModList[arrIdx].resrcId      =\
9130         cuResrcList->list.array[arrIdx]->pucch_ResourceId;
9131       macResrcList->resrcToAddModList[arrIdx].startPrb     =\
9132         cuResrcList->list.array[arrIdx]->startingPRB;
9133       if(cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping)
9134       {
9135          macResrcList->resrcToAddModList[arrIdx].intraFreqHop =\
9136            *cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping;
9137       }
9138       if(cuResrcList->list.array[arrIdx]->secondHopPRB)
9139       {
9140          macResrcList->resrcToAddModList[arrIdx].secondPrbHop =\
9141            *cuResrcList->list.array[arrIdx]->secondHopPRB;
9142       }
9143       /* PUCCH RSRC FORMAT */
9144       if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format0)
9145       {
9146          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_0;
9147          if(cuResrcList->list.array[arrIdx]->format.choice.format0)
9148          {
9149             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0, sizeof(PucchFormat0));
9150             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0 == NULLP)
9151             {
9152                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
9153                return RFAILED;
9154             }
9155             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->initialCyclicShift =\
9156                cuResrcList->list.array[arrIdx]->format.choice.format0->initialCyclicShift;
9157             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->numSymbols =\
9158                cuResrcList->list.array[arrIdx]->format.choice.format0->nrofSymbols;
9159             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->startSymbolIdx =\
9160                cuResrcList->list.array[arrIdx]->format.choice.format0->startingSymbolIndex;
9161          }
9162       }
9163       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format1)
9164       {
9165          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_1;
9166          if(cuResrcList->list.array[arrIdx]->format.choice.format1)
9167          {
9168             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1, sizeof(PucchFormat1));
9169             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1 == NULLP)
9170             {
9171                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
9172                return RFAILED;
9173             }
9174             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->initialCyclicShift =\
9175                 cuResrcList->list.array[arrIdx]->format.choice.format1->initialCyclicShift;
9176             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->numSymbols =\
9177                 cuResrcList->list.array[arrIdx]->format.choice.format1->nrofSymbols;
9178             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->startSymbolIdx =\
9179                 cuResrcList->list.array[arrIdx]->format.choice.format1->startingSymbolIndex;
9180             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->timeDomOCC =\
9181                 cuResrcList->list.array[arrIdx]->format.choice.format1->timeDomainOCC;
9182          }
9183       }
9184       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format2)
9185       {
9186          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_2;
9187          if(cuResrcList->list.array[arrIdx]->format.choice.format2)
9188          {
9189             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
9190             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2 == NULLP)
9191             {
9192                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
9193                return RFAILED;
9194             }
9195             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numPrbs =\
9196                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofPRBs;
9197             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numSymbols =\
9198                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofSymbols;
9199             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->startSymbolIdx =\
9200                 cuResrcList->list.array[arrIdx]->format.choice.format2->startingSymbolIndex;
9201          }
9202       }
9203       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format3)
9204       {
9205          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_3;
9206          if(cuResrcList->list.array[arrIdx]->format.choice.format3)
9207          {
9208             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
9209             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3 == NULLP)
9210             {
9211                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
9212                return RFAILED;
9213             }
9214             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numPrbs =\
9215                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofPRBs;
9216             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numSymbols =\
9217                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofSymbols;
9218             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->startSymbolIdx =\
9219                 cuResrcList->list.array[arrIdx]->format.choice.format3->startingSymbolIndex;
9220          }
9221       }
9222       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format4)
9223       {
9224          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_4;
9225          if(cuResrcList->list.array[arrIdx]->format.choice.format4)
9226          {
9227             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4, sizeof(PucchFormat4));
9228             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4 == NULLP)
9229             {
9230                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
9231                return RFAILED;
9232             }
9233             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->numSymbols =\
9234                 cuResrcList->list.array[arrIdx]->format.choice.format4->nrofSymbols;
9235             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occLen =\
9236                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Length;
9237             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occIdx =\
9238                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Index;
9239             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->startSymbolIdx =\
9240                 cuResrcList->list.array[arrIdx]->format.choice.format4->startingSymbolIndex;
9241          }
9242       }
9243    }
9244    return ROK;
9245
9246 }/* End of extractResrcToAddModList */
9247
9248 /*******************************************************************
9249  *
9250  * @brief Fills fillPucchSchedReqPeriodAndOffset sent by CU
9251  *
9252  * @details
9253  *
9254  *    Function : fillPucchSchedReqPeriodAndOffset
9255  *
9256  *    Functionality: To fillPucchSchedReqPeriodAndOffset
9257  *
9258  * @params[in] macPeriodicty,
9259  *     SchedulingRequestResourceConfig__periodicityAndOffset pointer
9260  * @return void
9261  *
9262  * ****************************************************************/
9263
9264 void fillPucchSchedReqPeriodAndOffset(uint8_t macPeriodicty, uint16_t  macOffset,\
9265    struct SchedulingRequestResourceConfig__periodicityAndOffset *cuPeriodicty)
9266 {
9267    macPeriodicty = cuPeriodicty->present;
9268    switch(macPeriodicty)
9269    {
9270       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
9271          {
9272             macOffset     = cuPeriodicty->choice.sym2;
9273             break;
9274          }
9275       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
9276          {
9277             macOffset     = cuPeriodicty->choice.sym6or7;
9278             break;
9279          }
9280       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
9281          {
9282             macOffset     = cuPeriodicty->choice.sl1;
9283             break;
9284          }
9285       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
9286          {
9287             macOffset = cuPeriodicty->choice.sl2;
9288             break;
9289          }
9290       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
9291          {
9292             macOffset = cuPeriodicty->choice.sl4;
9293             break;
9294          }
9295       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
9296          {
9297             macOffset = cuPeriodicty->choice.sl5;
9298             break;
9299          }
9300       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
9301          {
9302             macOffset = cuPeriodicty->choice.sl8;
9303             break;
9304          }
9305       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
9306          {
9307             macOffset = cuPeriodicty->choice.sl10;
9308             break;
9309          }
9310       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
9311          {
9312             macOffset = cuPeriodicty->choice.sl16;
9313             break;
9314          }
9315       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
9316          {
9317             macOffset = cuPeriodicty->choice.sl20;
9318             break;
9319          }
9320       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
9321          {
9322             macOffset = cuPeriodicty->choice.sl40;
9323             break;
9324          }
9325       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
9326          {
9327             macOffset = cuPeriodicty->choice.sl80;
9328             break;
9329          }
9330       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
9331          {
9332             macOffset = cuPeriodicty->choice.sl160;
9333             break;
9334          }
9335       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
9336          {
9337             macOffset = cuPeriodicty->choice.sl320;
9338             break;
9339          }
9340       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
9341          {
9342             macOffset = cuPeriodicty->choice.sl640;
9343             break;
9344          }
9345       default :
9346          DU_LOG("\nERROR  -->  F1AP : Invalid periodicity %d", macPeriodicty);
9347    }
9348 }
9349
9350 /*******************************************************************
9351  *
9352  * @brief Function to extractPucchFormatCfg sent by CU
9353  *
9354  * @details
9355  *
9356  *    Function : extractPucchFormatCfg
9357  *
9358  *    Functionality: Function to extractPucchFormatCfg
9359  *
9360  * @params[in] PucchFormatCfg pointer,
9361  *             PUCCH_FormatConfig_t pointer
9362  * @return void
9363  *
9364  * ****************************************************************/
9365
9366 void extractPucchFormatCfg(PucchFormatCfg *macFormatCfg, PUCCH_FormatConfig_t *cuFormatCfg)
9367  {
9368     if(cuFormatCfg->interslotFrequencyHopping)
9369        macFormatCfg->interSlotFreqHop = *cuFormatCfg->interslotFrequencyHopping;
9370     if(cuFormatCfg->additionalDMRS)
9371        macFormatCfg->addDmrs = *cuFormatCfg->additionalDMRS;
9372     if(cuFormatCfg->maxCodeRate)
9373        macFormatCfg->maxCodeRate = *cuFormatCfg->maxCodeRate;
9374     if(cuFormatCfg->nrofSlots)
9375        macFormatCfg->numSlots = *cuFormatCfg->nrofSlots;
9376     if(cuFormatCfg->pi2BPSK)
9377        macFormatCfg->pi2BPSK = *cuFormatCfg->pi2BPSK;
9378     if(cuFormatCfg->simultaneousHARQ_ACK_CSI)
9379        macFormatCfg->harqAckCSI = *cuFormatCfg->simultaneousHARQ_ACK_CSI;
9380  }/* End of extractPucchFormatCfg */
9381
9382 /*******************************************************************
9383  *
9384  * @brief Function to extractSchedReqCfgToAddMod sent by CU
9385  *
9386  * @details
9387  *
9388  *    Function : extractSchedReqCfgToAddMod
9389  *
9390  *    Functionality: Function to extractSchedReqCfgToAddMod
9391  *
9392  * @params[in] PucchSchedReqCfg pointer,
9393  *      PUCCH_Config__schedulingRequestResourceToAddModList pointer
9394  * @return void
9395  *
9396  * ****************************************************************/
9397
9398 void extractSchedReqCfgToAddMod(PucchSchedReqCfg *macSchedReqCfg, struct PUCCH_Config__schedulingRequestResourceToAddModList *cuSchedReqList)
9399 {
9400    uint8_t arrIdx;
9401
9402    macSchedReqCfg->schedAddModListCount = cuSchedReqList->list.count;
9403    for(arrIdx = 0; arrIdx <  macSchedReqCfg->schedAddModListCount; arrIdx++)
9404    {
9405       macSchedReqCfg->schedAddModList[arrIdx].resrcId =\
9406          cuSchedReqList->list.array[arrIdx]->schedulingRequestResourceId;
9407       macSchedReqCfg->schedAddModList[arrIdx].requestId =\
9408          cuSchedReqList->list.array[arrIdx]->schedulingRequestID;
9409       if(cuSchedReqList->list.array[arrIdx]->periodicityAndOffset)
9410       {
9411          fillPucchSchedReqPeriodAndOffset(macSchedReqCfg->schedAddModList[arrIdx].periodicity,\
9412             macSchedReqCfg->schedAddModList[arrIdx].offset, cuSchedReqList->list.array[arrIdx]->periodicityAndOffset);
9413       }
9414       if(cuSchedReqList->list.array[arrIdx]->resource)
9415       {
9416          macSchedReqCfg->schedAddModList[arrIdx].resrc =\
9417             *cuSchedReqList->list.array[arrIdx]->resource;
9418       }
9419    }
9420
9421 }/* End of extractSchedReqCfgToAddMod */
9422
9423  /*******************************************************************
9424  *
9425  * @brief Fills PucchCfg received by CU
9426  *
9427  * @details
9428  *
9429  *    Function : extractPucchCfg
9430  *
9431  *    Functionality: Fills PucchCfg received  by CU
9432  *
9433  * @params[in] BWP_UplinkDedicated__pucch_Config *cuPucchCfg = Information which
9434  *                is send by CU, which we have stored in F1UeContextSetupDb,
9435  *             PucchCfg *macPucchCfg = Used to Store the information which
9436  *                needs to send in other layer, as well as this can be the variable
9437  *                which stores the information in DuCb,
9438  *             PucchCfg *storedPucchCfg = Null in case of sending the
9439  *                information to other layer else it will have Pucch Cfg which
9440  *                we have stored in copyOfmacUeCfg.
9441  * @return ROK/RFAILED
9442  *
9443  * ****************************************************************/
9444
9445 uint8_t extractPucchCfg(struct BWP_UplinkDedicated__pucch_Config *cuPucchCfg, PucchCfg *macPucchCfg,\
9446 PucchCfg *storedPucchCfg)
9447 {
9448    uint8_t arrIdx;
9449
9450    if(cuPucchCfg->present == BWP_UplinkDedicated__pucch_Config_PR_setup)
9451    {
9452       if(cuPucchCfg->choice.setup)
9453       {
9454          /* Resource Set Cfg */
9455          if(cuPucchCfg->choice.setup->resourceSetToAddModList)
9456          {
9457             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrcSet, sizeof(PucchResrcSetCfg));
9458             if(macPucchCfg->resrcSet == NULLP)
9459             {
9460                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
9461                return RFAILED;
9462             }
9463             memset(macPucchCfg->resrcSet, 0, sizeof(PucchResrcSetCfg));
9464             extractResrcSetToAddModList(macPucchCfg->resrcSet, cuPucchCfg->choice.setup->resourceSetToAddModList);
9465          }
9466
9467          /* Resource Cfg */
9468          if(cuPucchCfg->choice.setup->resourceToAddModList)
9469          {
9470             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrc, sizeof(PucchResrcCfg));
9471             if(macPucchCfg->resrc == NULLP)
9472             {
9473                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
9474                return RFAILED;
9475             }
9476             memset(macPucchCfg->resrc, 0, sizeof(PucchResrcCfg));
9477             extractResrcToAddModList(macPucchCfg->resrc, cuPucchCfg->choice.setup->resourceToAddModList);
9478          }
9479
9480          /* Format 1 Cfg */
9481          if(cuPucchCfg->choice.setup->format1)
9482          {
9483             DU_ALLOC_SHRABL_BUF(macPucchCfg->format1, sizeof(PucchFormatCfg));
9484             if(macPucchCfg->format1 == NULLP)
9485             {
9486                DU_LOG("\nERROR --> F1AP : Failed to extract format 1 Cfg in  extractPucchCfg()");
9487                return RFAILED;
9488             }
9489             memset(macPucchCfg->format1, 0, sizeof(PucchFormatCfg));
9490             extractPucchFormatCfg(macPucchCfg->format1,\
9491                cuPucchCfg->choice.setup->format1->choice.setup);
9492          }
9493
9494          /* Format 2 Cfg */
9495          if(cuPucchCfg->choice.setup->format2)
9496          {
9497             DU_ALLOC_SHRABL_BUF(macPucchCfg->format2, sizeof(PucchFormatCfg));
9498             if(macPucchCfg->format2 == NULLP)
9499             {
9500                DU_LOG("\nERROR --> F1AP : Failed to extract format 2 Cfg in  extractPucchCfg()");
9501                return RFAILED;
9502             }
9503             memset(macPucchCfg->format2, 0, sizeof(PucchFormatCfg));
9504             extractPucchFormatCfg(macPucchCfg->format2,\
9505                cuPucchCfg->choice.setup->format2->choice.setup);
9506          }
9507
9508          /* Format 3 Cfg */
9509          if(cuPucchCfg->choice.setup->format3)
9510          {
9511             DU_ALLOC_SHRABL_BUF(macPucchCfg->format3, sizeof(PucchFormatCfg));
9512             if(macPucchCfg->format3 == NULLP)
9513             {
9514                DU_LOG("\nERROR --> F1AP : Failed to extract format 3 Cfg in  extractPucchCfg()");
9515                return RFAILED;
9516             }
9517             memset(macPucchCfg->format3, 0, sizeof(PucchFormatCfg));
9518             extractPucchFormatCfg(macPucchCfg->format3,\
9519                cuPucchCfg->choice.setup->format3->choice.setup);
9520          }
9521
9522          /* Format 4 Cfg */
9523          if(cuPucchCfg->choice.setup->format4)
9524          {
9525             DU_ALLOC_SHRABL_BUF(macPucchCfg->format4, sizeof(PucchFormatCfg));
9526             if(macPucchCfg->format4 == NULLP)
9527             {
9528                DU_LOG("\nERROR --> F1AP : Failed to extract format 4 Cfg in  extractPucchCfg()");
9529                return RFAILED;
9530             }
9531             memset(macPucchCfg->format4, 0, sizeof(PucchFormatCfg));
9532             extractPucchFormatCfg(macPucchCfg->format4,\
9533                cuPucchCfg->choice.setup->format4->choice.setup);
9534          }
9535
9536          /* Sched Req List */
9537          if(cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList)
9538          {
9539             DU_ALLOC_SHRABL_BUF(macPucchCfg->schedReq, sizeof(PucchSchedReqCfg));
9540             if(macPucchCfg->schedReq == NULLP)
9541             {
9542                DU_LOG("\nERROR --> F1AP : Failed to extract schedReqCfg in  extractPucchCfg()");
9543                return RFAILED;
9544             }
9545             memset(macPucchCfg->schedReq, 0, sizeof(PucchSchedReqCfg));
9546             extractSchedReqCfgToAddMod(macPucchCfg->schedReq,\
9547             cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList);
9548          }
9549
9550          /*TODO: Add support for  Spatial Info */
9551
9552          /* MultiCsiCfg */
9553          if(cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList)
9554          {
9555             DU_ALLOC_SHRABL_BUF(macPucchCfg->multiCsiCfg, sizeof(PucchMultiCsiCfg));
9556             if(macPucchCfg->multiCsiCfg == NULLP)
9557             {
9558                DU_LOG("\nERROR --> F1AP : Failed to extract multiCsiCfg in  extractPucchCfg()");
9559                return RFAILED;
9560             }
9561             memset(macPucchCfg->multiCsiCfg, 0, sizeof(PucchMultiCsiCfg));
9562             macPucchCfg->multiCsiCfg->multiCsiResrcListCount = cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.count;
9563             for(arrIdx =0; arrIdx < macPucchCfg->multiCsiCfg->multiCsiResrcListCount; arrIdx++)
9564             {
9565                macPucchCfg->multiCsiCfg->multiCsiResrcList[arrIdx] =\
9566                  *cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.array[arrIdx];
9567             }
9568          }
9569
9570          /* Dl_DataToUL_ACK */
9571          if(cuPucchCfg->choice.setup->dl_DataToUL_ACK)
9572     {
9573        if(storedPucchCfg)
9574        {
9575           if(storedPucchCfg->dlDataToUlAck)
9576           {
9577              macPucchCfg->dlDataToUlAck = storedPucchCfg->dlDataToUlAck;
9578           }
9579           else
9580           {
9581             DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
9582           }
9583        }
9584        else
9585        {
9586           DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
9587        }
9588        if(macPucchCfg->dlDataToUlAck == NULLP)
9589        {
9590           DU_LOG("\nERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
9591           return RFAILED;
9592        }
9593        memset(macPucchCfg->dlDataToUlAck, 0, sizeof(PucchDlDataToUlAck));
9594        macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount = cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.count;
9595        for(arrIdx = 0; arrIdx < macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount; arrIdx++)
9596        {
9597           macPucchCfg->dlDataToUlAck->dlDataToUlAckList[arrIdx] =\
9598           *cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.array[arrIdx];
9599        }
9600          }
9601
9602          /* Power Control */
9603          if(cuPucchCfg->choice.setup->pucch_PowerControl)
9604          {
9605             DU_ALLOC_SHRABL_BUF(macPucchCfg->powerControl, sizeof(PucchPowerControl));
9606             if(macPucchCfg->powerControl == NULLP)
9607             {
9608                DU_LOG("\nERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
9609                return RFAILED;
9610             }
9611             extractPucchPowerControl(macPucchCfg->powerControl,\
9612                cuPucchCfg->choice.setup->pucch_PowerControl);
9613          }
9614       }
9615    }
9616    return ROK;
9617 }
9618
9619 /*******************************************************************
9620  *
9621  * @brief Fills ServingCellReconfig received by CU
9622  *
9623  * @details
9624  *
9625  *    Function : extractSpCellDedicatedCfg
9626  *
9627  *    Functionality: Fills ServingCellReconfig received  by CU
9628  *
9629  * @params[in] ServingCellConfig_t *cuSrvCellCfg = Information which is send by
9630  *                  CU, which we have stored in F1UeContextSetupDb,
9631  *             ServCellCfgInfo *macSrvCellCfg = Used to Store the information
9632  *                  which  needs to send in other layer, as well as this can be the
9633  *                  variable which stores the information in DuCb,
9634  *             ServCellCfgInfo *storedSrvCellCfg = Null in case of sending the
9635  *                  information to other layer else it will have ServCellCfgInfo which
9636  *                  we have stored in copyOfmacUeCfg.
9637  * @return ROK/RFAILD
9638  *
9639  * ****************************************************************/
9640 uint8_t extractSpCellDedicatedCfg(ServingCellConfig_t *cuSrvCellCfg, ServCellCfgInfo *macSrvCellCfg,\
9641 ServCellCfgInfo *storedSrvCellCfg)
9642 {
9643    uint8_t ret = ROK;
9644    BWP_DownlinkDedicated_t *dlBwp = NULLP;
9645    BWP_UplinkDedicated_t   *ulBwp = NULLP;
9646
9647    if(cuSrvCellCfg->initialDownlinkBWP)
9648    {
9649       dlBwp = ((BWP_DownlinkDedicated_t *)(cuSrvCellCfg->initialDownlinkBWP));
9650       if(dlBwp->pdcch_Config)
9651       {
9652          if(dlBwp->pdcch_Config->choice.setup)
9653          {
9654             macSrvCellCfg->initDlBwp.pdcchPresent = true;
9655             if(storedSrvCellCfg)
9656             {
9657                if(!storedSrvCellCfg->initDlBwp.pdcchPresent)
9658                {
9659                   extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
9660                }
9661                else
9662                {
9663                   extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
9664                }
9665             }
9666             else
9667             {
9668                extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
9669             }
9670          }
9671       }
9672       if(dlBwp->pdsch_Config)
9673       {
9674          if(dlBwp->pdsch_Config->choice.setup)
9675          {
9676             macSrvCellCfg->initDlBwp.pdschPresent = true;
9677
9678             if(storedSrvCellCfg)
9679             {
9680                if(!storedSrvCellCfg->initDlBwp.pdschPresent)
9681                {
9682                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
9683                }
9684                else
9685                {
9686                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg,\
9687                         &storedSrvCellCfg->initDlBwp.pdschCfg);
9688                }
9689             }
9690             else
9691             {
9692                extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
9693             }
9694          }
9695       }
9696    }
9697    if(cuSrvCellCfg->firstActiveDownlinkBWP_Id)
9698       macSrvCellCfg->firstActvDlBwpId = *(cuSrvCellCfg->firstActiveDownlinkBWP_Id);
9699    if(cuSrvCellCfg->defaultDownlinkBWP_Id)
9700       macSrvCellCfg->defaultDlBwpId = *(cuSrvCellCfg->defaultDownlinkBWP_Id);
9701    if(cuSrvCellCfg->bwp_InactivityTimer)
9702    {
9703       if(macSrvCellCfg->bwpInactivityTmr)
9704       {
9705          memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
9706       }
9707       else
9708       {
9709          macSrvCellCfg->bwpInactivityTmr = NULLP;
9710          DU_ALLOC_SHRABL_BUF(macSrvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
9711          if(macSrvCellCfg->bwpInactivityTmr)
9712          {
9713             memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
9714          }
9715          else
9716          {
9717             DU_LOG("\nERROR  --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
9718             return RFAILED;
9719          }
9720       }
9721    }
9722    if(cuSrvCellCfg->pdsch_ServingCellConfig)
9723    {
9724       if(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup)
9725       {
9726          ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
9727          if(ret == RFAILED)
9728          {
9729             DU_LOG("\nERROR --> F1AP : Failed at extractPdschServingCellCfg()");
9730             return RFAILED;
9731          }
9732       }
9733    }
9734    if(cuSrvCellCfg->uplinkConfig)
9735    {
9736       if(cuSrvCellCfg->uplinkConfig->initialUplinkBWP)
9737       {
9738          ulBwp = ((BWP_UplinkDedicated_t *)(cuSrvCellCfg->uplinkConfig->initialUplinkBWP));
9739          if(ulBwp->pusch_Config)
9740          {
9741             macSrvCellCfg->initUlBwp.puschPresent = true;
9742             extractPuschCfg(ulBwp->pusch_Config, &macSrvCellCfg->initUlBwp.puschCfg);
9743          }
9744          if(ulBwp->pucch_Config)
9745          {
9746             macSrvCellCfg->initUlBwp.pucchPresent = true;
9747             memset(&macSrvCellCfg->initUlBwp.pucchCfg, 0, sizeof(PucchCfg));
9748             if(storedSrvCellCfg)
9749             {
9750                if(!storedSrvCellCfg->initUlBwp.pucchPresent)
9751                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
9752                else
9753                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg,\
9754                   &storedSrvCellCfg->initUlBwp.pucchCfg);
9755             }
9756             else
9757             {
9758                extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
9759             }
9760          }
9761       }
9762       if(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id)
9763          macSrvCellCfg->firstActvUlBwpId = *(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id);
9764    }
9765    return ret;
9766 }
9767 /*******************************************************************
9768  *
9769  * @brief Fills Reconfig Cell group Info received by CU
9770  *
9771  * @details
9772  *
9773  *    Function : extractUeReCfgCellInfo
9774  *
9775  *    Functionality: Fills Reconfig Cell group Info received by CU
9776  *
9777  * @params[in] CellGroupConfigRrc_t *cellGrp = CellGroupConfigRrc_t information which
9778  *                       is send by CU, which we have stored in F1UeContextSetupDb
9779  *             MacUeCfg *MacUeCfg = Used to Store the information,
9780  *                      which needs to send in other layer, as well as this can be
9781  *                      the variable which stores the information in DuCb,
9782  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
9783  *                      information to other layer else it will have copyOfmacUeCfg
9784  *                      which we have stored in F1UeContextSetupDb.
9785  *
9786  * @return ROK/RFAILED
9787  *
9788  * ****************************************************************/
9789 uint8_t extractUeReCfgCellInfo(CellGroupConfigRrc_t *cellGrp, MacUeCfg *macUeCfg, MacUeCfg *storedMacUeCfg)
9790 {
9791    uint8_t ret = ROK;
9792    MAC_CellGroupConfig_t     *macCellGroup = NULLP;
9793    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
9794    SpCellConfig_t            *spcellCfg = NULLP;
9795    ServingCellConfig_t       *servCellCfg = NULLP;
9796
9797    if(cellGrp)
9798    {
9799       /* Fill MacCell Group Reconfig  */
9800       if(cellGrp->mac_CellGroupConfig)
9801       {
9802          macUeCfg->macCellGrpCfgPres = true;
9803          macCellGroup = ((MAC_CellGroupConfig_t *)(cellGrp->mac_CellGroupConfig));
9804          if(macCellGroup->schedulingRequestConfig)
9805          {
9806             extractSchReqReConfig(macCellGroup->schedulingRequestConfig, &macUeCfg->macCellGrpCfg.schReqCfg);
9807          }
9808          if(macCellGroup->tag_Config)
9809          {
9810             extractTagReconfig(macCellGroup->tag_Config, &macUeCfg->macCellGrpCfg.tagCfg);
9811          }
9812          if(macCellGroup->bsr_Config)
9813          {
9814             macUeCfg->macCellGrpCfg.bsrTmrCfg.periodicTimer = macCellGroup->bsr_Config->periodicBSR_Timer;
9815             macUeCfg->macCellGrpCfg.bsrTmrCfg.retxTimer     = macCellGroup->bsr_Config->retxBSR_Timer;
9816             if(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer)
9817             {
9818                macUeCfg->macCellGrpCfg.bsrTmrCfg.srDelayTimer  =\
9819                *(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer);
9820             }
9821          }
9822          if(macCellGroup->phr_Config)
9823          {
9824             if(macCellGroup->phr_Config->present == MAC_CellGroupConfig__phr_Config_PR_setup)
9825             {
9826                macUeCfg->macCellGrpCfg.phrCfgSetupPres = true;
9827                if(macCellGroup->phr_Config->choice.setup)
9828                {
9829                   macUeCfg->macCellGrpCfg.phrCfg.periodicTimer     = \
9830                   macCellGroup->phr_Config->choice.setup->phr_PeriodicTimer;
9831                   macUeCfg->macCellGrpCfg.phrCfg.prohibitTimer     = \
9832                   macCellGroup->phr_Config->choice.setup->phr_ProhibitTimer;
9833                   macUeCfg->macCellGrpCfg.phrCfg.txPowerFactor     = \
9834                   macCellGroup->phr_Config->choice.setup->phr_Tx_PowerFactorChange;
9835                   macUeCfg->macCellGrpCfg.phrCfg.multiplePHR       = \
9836                   macCellGroup->phr_Config->choice.setup->multiplePHR;
9837                   macUeCfg->macCellGrpCfg.phrCfg.dummy             = \
9838                   macCellGroup->phr_Config->choice.setup->dummy;
9839                   macUeCfg->macCellGrpCfg.phrCfg.phrType2OtherCell = \
9840                   macCellGroup->phr_Config->choice.setup->phr_Type2OtherCell;
9841                   macUeCfg->macCellGrpCfg.phrCfg.phrOtherCG        = \
9842                   macCellGroup->phr_Config->choice.setup->phr_ModeOtherCG;
9843                }
9844             }
9845          }
9846       }
9847       /* Fill Physical Cell Group Reconfig */
9848       if(cellGrp->physicalCellGroupConfig)
9849       {
9850          macUeCfg->phyCellGrpCfgPres = true;
9851          phyCellGrpCfg = ((PhysicalCellGroupConfig_t *)(cellGrp->physicalCellGroupConfig));
9852          if(phyCellGrpCfg->p_NR_FR1)
9853          {
9854             if(*(phyCellGrpCfg->p_NR_FR1) != macUeCfg->phyCellGrpCfg.pNrFr1)
9855                macUeCfg->phyCellGrpCfg.pNrFr1 = *(phyCellGrpCfg->p_NR_FR1);
9856          }
9857          macUeCfg->phyCellGrpCfg.pdschHarqAckCodebook = phyCellGrpCfg->pdsch_HARQ_ACK_Codebook;
9858       }
9859       /* Fill SpCell Reconfig */
9860       if(cellGrp->spCellConfig)
9861       {
9862          macUeCfg->spCellCfgPres = true;
9863          spcellCfg = ((SpCellConfig_t *)(cellGrp->spCellConfig));
9864          if(spcellCfg->servCellIndex)
9865          {
9866             macUeCfg->spCellCfg.servCellIdx = *(spcellCfg->servCellIndex);
9867          }
9868          /* Fill Serving cell Reconfig info */
9869          if(cellGrp->spCellConfig->spCellConfigDedicated)
9870          {
9871             servCellCfg = ((ServingCellConfig_t *)(cellGrp->spCellConfig->spCellConfigDedicated));
9872             if(storedMacUeCfg)
9873             {
9874                if(!storedMacUeCfg->spCellCfgPres)
9875                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
9876                else
9877                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg,\
9878                         &storedMacUeCfg->spCellCfg.servCellCfg);
9879             }
9880             else
9881             {
9882                ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
9883             }
9884             if(ret == RFAILED)
9885             {
9886                DU_LOG("\nERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
9887             }
9888          }
9889       }
9890    }
9891    return ret;
9892 }
9893 /*******************************************************************
9894 *
9895 * @brief free the memory allocated by decoder
9896 *
9897 * @details
9898 *
9899 *    Function : freeAperDecodeNrcgi
9900 *
9901 *    Functionality: Free Nrcgi values
9902 *
9903 * @params[in] NRCGI_t *nrcgi
9904 * @return void
9905 *
9906 * ****************************************************************/
9907
9908
9909 void freeAperDecodeNrcgi(NRCGI_t *nrcgi)
9910 {
9911     if(nrcgi->pLMN_Identity.buf != NULLP)
9912     {
9913        free(nrcgi->pLMN_Identity.buf);
9914     }
9915     if(nrcgi->nRCellIdentity.buf != NULLP)
9916     {
9917        free(nrcgi->nRCellIdentity.buf);
9918     }
9919 }
9920 /*******************************************************************
9921 *
9922 * @brief free the memory allocated by decoder
9923 *
9924 * @details
9925 *
9926 *    Function : freeAperDecodeCuToDuInfo
9927 *
9928 *    Functionality:  Free Cu To Du Information
9929 *
9930 * @params[in] CUtoDURRCInformation_t *rrcMsg
9931 * @return void
9932 *
9933 * ****************************************************************/
9934
9935
9936 void freeAperDecodeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
9937 {
9938    uint8_t ieIdx =0;
9939    uint8_t arrIdx =0;
9940
9941    if(rrcMsg->uE_CapabilityRAT_ContainerList)
9942    {
9943       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
9944          free(rrcMsg->uE_CapabilityRAT_ContainerList->buf);
9945       free(rrcMsg->uE_CapabilityRAT_ContainerList);
9946    }
9947
9948    if(rrcMsg->iE_Extensions)
9949    {
9950       if(rrcMsg->iE_Extensions->list.array)
9951       {
9952          for(ieIdx= 0; ieIdx < rrcMsg->iE_Extensions->list.count; ieIdx++)
9953          {
9954             if(rrcMsg->iE_Extensions->list.array[ieIdx])
9955             {
9956                switch(rrcMsg->iE_Extensions->list.array[ieIdx]->id)
9957                {
9958                   case ProtocolIE_ID_id_CellGroupConfig:
9959                      if(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
9960                      {
9961                         free(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf);
9962                      }
9963                      break;
9964                   default:
9965                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
9966                            rrcMsg->iE_Extensions->list.array[ieIdx]->id);
9967                      break;
9968                }
9969             }
9970          }
9971          for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
9972          {
9973             free(rrcMsg->iE_Extensions->list.array[arrIdx]);
9974          }
9975          free(rrcMsg->iE_Extensions->list.array);
9976
9977       }
9978
9979       free(rrcMsg->iE_Extensions);
9980    }
9981 }
9982 /*******************************************************************
9983 *
9984 * @brief free the memory allocated by decoder
9985 *
9986 * @details
9987 *
9988 *    Function : freeAperDecodeSplCellList
9989 *
9990 *    Functionality: Free Spl Cell List
9991                     where memory allocated by aper_decoder
9992 *
9993 * @params[in]  SCell_ToBeSetup_List_t *spCellLst
9994 * @return void
9995 *
9996 * ****************************************************************/
9997
9998
9999 void freeAperDecodeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
10000 {
10001     uint8_t  cellIdx =0;
10002
10003     if(spCellLst->list.array != NULLP)
10004     {
10005        for(cellIdx=0; cellIdx<spCellLst->list.count; cellIdx++)
10006        {
10007           if(cellIdx==0&&spCellLst->list.array[cellIdx]!=NULLP)
10008           {
10009              freeAperDecodeNrcgi(&spCellLst->list.array[cellIdx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
10010           }
10011           if(spCellLst->list.array[cellIdx]!=NULLP)
10012           {
10013              free(spCellLst->list.array[cellIdx]);
10014           }
10015        }
10016        free(spCellLst->list.array);
10017     }
10018 }
10019 /*******************************************************************
10020 *
10021 * @brief free the memory allocated by decoder
10022 *
10023 * @details
10024 *
10025 *    Function : freeAperDecodeSRBSetup
10026 *
10027 *    Functionality: added free part for the memory allocated by aper_decoder
10028 *
10029 * @params[in] SRBs_ToBeSetup_List_t *srbSet
10030 * @return void
10031 *
10032 ****************************************************************/
10033
10034
10035 void freeAperDecodeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
10036 {
10037     uint8_t srbIdx =0;
10038     if(srbSet->list.array != NULLP)
10039     {
10040        for(srbIdx=0; srbIdx<srbSet->list.count; srbIdx++)
10041        {
10042           if(srbSet->list.array[srbIdx]!=NULLP)
10043           {
10044              free(srbSet->list.array[srbIdx]);
10045           }
10046        }
10047        free(srbSet->list.array);
10048     }
10049 }
10050
10051 /*******************************************************************
10052 *
10053 * @brief free the memory allocated by decoder
10054 *
10055 * @details
10056 *
10057 *    Function : freeAperDecodeULTnlInfo
10058 *
10059 *    Functionality: added free part for the memory allocated by aper_decoder
10060 *
10061 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
10062 * @return void
10063 *
10064 * ****************************************************************/
10065
10066
10067 void freeAperDecodeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
10068 {
10069    uint8_t ulIdx=0;
10070    if(ulInfo->list.array != NULLP)
10071    {
10072       for(ulIdx=0; ulIdx<ulInfo->list.count; ulIdx++)
10073       {
10074          if(ulIdx==0&&ulInfo->list.array[ulIdx]!=NULLP)
10075          {
10076             if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
10077             {
10078                if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10079                      transportLayerAddress.buf != NULLP)
10080                {
10081                   if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
10082                         !=NULLP)
10083                   {
10084                      free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf);
10085                   }
10086                   free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
10087                         transportLayerAddress.buf);
10088                }
10089                free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel);
10090             }
10091          }
10092          if(ulInfo->list.array[ulIdx]!=NULLP)
10093          {
10094             free(ulInfo->list.array[ulIdx]);
10095          }
10096       }
10097       free(ulInfo->list.array);
10098    }
10099 }
10100 /*******************************************************************
10101 *
10102 * @brief free the memory allocated by decoder
10103 *
10104 * @details
10105 *
10106 *    Function : freeAperDecodeDRBSetup
10107 *
10108 *    Functionality: free DRBSetup which is allocated by decoder
10109 *
10110 * @params[in]  DRBs_ToBeSetup_List_t *drbSet
10111 * @return void
10112 *
10113 * ****************************************************************/
10114
10115 void freeAperDecodeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
10116 {
10117    DRBs_ToBeSetup_Item_t *drbSetItem = NULLP;
10118    uint8_t  flowIdx =0;
10119    uint8_t  drbIdx =0;
10120
10121    if(drbSet->list.array != NULLP)
10122    {
10123       for(drbIdx=0; drbIdx<drbSet->list.count; drbIdx++)
10124       {
10125          if(drbIdx==0&&drbSet->list.array[drbIdx] != NULLP)
10126          {
10127             drbSetItem =&drbSet->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
10128             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
10129             {
10130                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
10131                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
10132                {
10133                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
10134                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
10135                   {
10136                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
10137                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
10138                      {
10139
10140                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
10141                         {
10142
10143                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
10144                            {
10145
10146                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->\
10147                                     buf!=NULLP)
10148                               {
10149
10150                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
10151                                        flows_Mapped_To_DRB_List.list.array != NULLP)
10152                                  {
10153
10154                                     for(flowIdx=0;flowIdx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
10155                                           DRB_Information.flows_Mapped_To_DRB_List.list.count; flowIdx++)
10156                                     {
10157
10158                                        if(flowIdx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
10159                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
10160                                        {
10161                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
10162                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
10163                                                 qoSFlowLevelQoSParameters.\
10164                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
10165                                           {
10166                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
10167                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
10168                                                    qoSFlowLevelQoSParameters.\
10169                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
10170                                              {
10171
10172                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
10173                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
10174                                                       qoSFlowLevelQoSParameters.\
10175                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
10176                                                 {
10177
10178
10179                                                    free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
10180                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
10181                                                          qoSFlowLevelQoSParameters.\
10182                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
10183                                                 }
10184
10185                                                 free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
10186                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
10187                                                       qoSFlowLevelQoSParameters.\
10188                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
10189                                              }
10190
10191                                              free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
10192
10193                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
10194                                                    qoSFlowLevelQoSParameters.\
10195                                                    qoS_Characteristics.choice.non_Dynamic_5QI);
10196                                           }
10197                                        }
10198                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
10199                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
10200                                        {
10201
10202                                           free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
10203                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]);
10204                                        }
10205                                     }
10206
10207                                     free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
10208                                           DRB_Information.flows_Mapped_To_DRB_List.list.array);
10209                                  }
10210
10211                                  free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
10212                                        DRB_Information.sNSSAI.sD->buf);
10213                               }
10214
10215                               free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD);
10216                            }
10217
10218                            free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf);
10219
10220                         }
10221
10222                         free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
10223
10224                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
10225                      }
10226
10227                      free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
10228                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
10229                   }
10230
10231                   free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
10232                         qoS_Characteristics.choice.non_Dynamic_5QI);
10233                }
10234                free(drbSetItem->qoSInformation.choice.choice_extension);
10235             }
10236             freeAperDecodeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
10237             if(drbSetItem->uLConfiguration)
10238             {
10239                free(drbSetItem->uLConfiguration);
10240             }
10241          }
10242          if(drbSet->list.array[drbIdx]!=NULLP)
10243          {
10244             free(drbSet->list.array[drbIdx]);
10245          }
10246       }
10247       free(drbSet->list.array);
10248    }
10249 }
10250
10251
10252 /*******************************************************************
10253  *
10254  * @brief builds Mac Cell Cfg
10255  *
10256  * @details
10257  *
10258  *    Function : procUeReCfgCellInfo
10259  *
10260  *    Functionality: builds Mac Cell Cfg
10261  *
10262  * @params[in] MacUeCfg *macUeCfgToSend = Used to Store the information which
10263  *                       needs to send in other layer, as well as this can be
10264  *                       the variable which stores the information in DuCb.
10265  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
10266  *                       information to other layer else it will have copyOfmacUeCfg
10267  *                       which we have stored in F1UeContextSetupDb
10268  *             void *cellInfo = CellGroupConfigRrc_t information which is send
10269  *                        by CU, which we have stored in F1UeContextSetupDb
10270  *
10271  * @return void
10272  *
10273  * ****************************************************************/
10274 uint8_t procUeReCfgCellInfo(MacUeCfg *macUeCfgToSend,MacUeCfg *storedMacUeCfg, void *cellInfo)
10275 {
10276    uint8_t ret = ROK;
10277    CellGroupConfigRrc_t *cellGrp = NULLP;
10278
10279    if(cellInfo)
10280    {
10281       cellGrp = (CellGroupConfigRrc_t *)cellInfo;
10282       ret = extractUeReCfgCellInfo(cellGrp, macUeCfgToSend, storedMacUeCfg);
10283       if(ret == RFAILED)
10284          DU_LOG("\nERROR  -->  F1AP : Failed at procUeReCfgCellInfo()");
10285    }
10286    if(ret == RFAILED)
10287    {
10288       freeUeReCfgCellGrpInfo(macUeCfgToSend);
10289    }
10290    return ret;
10291 }
10292
10293 /*******************************************************************
10294  *
10295  * @brief Filling modulation info in mac ue cfg
10296  *
10297  * @details
10298  *
10299  *    Function : duFillModulationDetails
10300  *
10301  *    Functionality: Filling modulation info in mac ue cfg
10302  *
10303  * @params[in] MAC UE Config to be updated
10304  *             Current UE configuration
10305  *             UE NR capability from CU
10306  * @return ROK     - success
10307  *         RFAILED - failure
10308  *
10309  * ****************************************************************/
10310 void duFillModulationDetails(MacUeCfg *ueCfg, MacUeCfg *oldUeCfg, void *ueCap)
10311 {
10312    UE_NR_Capability_t *ueNrCap=NULLP;
10313
10314    if(!ueCap)
10315    {
10316       memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
10317       memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
10318    }
10319    else
10320    {
10321       ueNrCap = (UE_NR_Capability_t *)ueCap;
10322
10323       /* Filling DL modulation info */
10324       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsDownlinkPerCC && \
10325          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0] && \
10326          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL)
10327       {
10328          switch(*(ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL))
10329          {
10330             case ModulationOrder_qpsk:
10331                {
10332                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
10333                   break;
10334                }
10335             case ModulationOrder_qam16:
10336                {
10337                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM16;
10338                   break;
10339                }
10340             case ModulationOrder_qam64:
10341                {
10342                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM64;
10343                   ueCfg->dlModInfo.mcsIndex = PDSCH_MCS_INDEX;
10344                   ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64;
10345                   break;
10346                }
10347             case ModulationOrder_qam256:
10348                {
10349                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM256;
10350                   break;
10351                }
10352             default:
10353                {
10354                   DU_LOG("\nERROR  -->  DU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
10355                   memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
10356                   break;
10357                }
10358          }
10359       }
10360       else
10361       {
10362          memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
10363       }
10364
10365       /* Filling UL modulation info */
10366       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsUplinkPerCC && \
10367          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0] && \
10368          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL)
10369       {
10370          switch(*(ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL))
10371          {
10372             case ModulationOrder_qpsk:
10373                {
10374                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
10375                   break;
10376                }
10377             case ModulationOrder_qam16:
10378                {
10379                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM16;
10380                   ueCfg->ulModInfo.mcsIndex = PUSCH_MCS_INDEX;
10381                   ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64;
10382                   break;
10383                }
10384             case ModulationOrder_qam64:
10385                {
10386                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM64;
10387                   break;
10388                }
10389             case ModulationOrder_qam256:
10390                {
10391                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM256;
10392                   break;
10393                }
10394             default:
10395                {
10396                   DU_LOG("\nERROR  -->  DU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
10397                   memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
10398                   break;
10399                }
10400          }
10401       }
10402       else
10403       {
10404          memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
10405       }
10406    }
10407 }
10408
10409 /*******************************************************************
10410  *
10411  * @brief Function to extract cellGrp Info present in cutoDu cont
10412  *
10413  * @details
10414  *
10415  *    Function : extractCellGrpInfo
10416  *
10417  *    Functionality: Function to extract cellGrp Info present
10418  *                   in cutoDu cont
10419  *
10420  * @params[in] ProtocolExtensionContainer_4624P16_t pointer
10421  *
10422  * @return CellGroupConfigRrc_t *
10423  *
10424  * ****************************************************************/
10425
10426 CellGroupConfigRrc_t *extractCellGrpInfo(ProtocolExtensionContainer_4624P16_t *protocolIeExtn,\
10427       DuUeCfg *ueCfgDb)
10428 {
10429    uint8_t idx2 =0;
10430    uint16_t id =0;
10431    uint16_t recvBufLen =0;
10432    CellGroupConfigRrc_t *cellGrpCfg = NULLP;
10433    CUtoDURRCInformation_ExtIEs_t *extIeInfo = NULLP;
10434    asn_dec_rval_t rval; /* Decoder return value */
10435    memset(&rval, 0, sizeof(asn_dec_rval_t));
10436
10437    if(protocolIeExtn)
10438    {
10439       for(idx2 = 0; idx2 < protocolIeExtn->list.count; idx2++)
10440       {
10441          extIeInfo = ((CUtoDURRCInformation_ExtIEs_t *)(protocolIeExtn->list.array[idx2]));
10442          id = extIeInfo->id;
10443          switch(id)
10444          {
10445             case ProtocolIE_ID_id_CellGroupConfig:
10446             {
10447                recvBufLen = extIeInfo->extensionValue.choice.CellGroupConfig.size;
10448                /* decoding the CellGroup Buf received */
10449                DU_ALLOC(cellGrpCfg, sizeof(CellGroupConfigRrc_t));
10450                if(cellGrpCfg)
10451                {
10452                   memset(cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
10453                   rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfg,
10454                      extIeInfo->extensionValue.choice.CellGroupConfig.buf, recvBufLen, 0, 0);
10455                   if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10456                   {
10457                      DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
10458                      return NULLP;
10459                   }
10460                   xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfg);
10461                   if(extractRlcCfgToAddMod(cellGrpCfg->rlc_BearerToAddModList, ueCfgDb))
10462                      return NULLP;
10463                }
10464                break;
10465             }
10466             default:
10467                DU_LOG("\nERROR  -->  F1AP : Invalid IE received CUtoDURRCInformation:%d at decodeCellGrpCfg()", id);
10468                break;
10469          }
10470       }
10471    }
10472    return cellGrpCfg;
10473 }
10474
10475 /*******************************************************************
10476  *
10477  * @brief Fills Srb List received by CU
10478  *
10479  * @details
10480  *
10481  *    Function : procSrbListToSetup
10482  *
10483  *    Functionality: Fills Srb List received  by CU
10484  *
10485  * @params[in] SRBs_ToBeSetup_Item_t *cuSrbItem
10486  *             LcCfg pointer
10487  *             RlcBearerCfg pointer
10488  * @return void
10489  *
10490  * ****************************************************************/
10491 uint8_t procSrbListToSetup(SRBs_ToBeSetup_Item_t * srbItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd)
10492 {
10493
10494    /* Filling RLC INFO */
10495    procRlcLcCfg(srbItem->sRBID, srbItem->sRBID, RB_TYPE_SRB, RLC_AM, CONFIG_ADD, NULL, rlcLcToAdd, NULL);
10496
10497    /* Filling MAC INFO */
10498    if(procMacLcCfg(srbItem->sRBID, RB_TYPE_SRB, CONFIG_ADD, NULL,NULL, NULL, NULL, macLcToAdd, NULL)  != ROK)
10499    {
10500       DU_LOG("\nERROR  -->  F1AP : Failed at MAC LC Cfg in procSrbListToSetup()");
10501       return RFAILED;
10502    }
10503
10504    return ROK;
10505 }
10506
10507
10508
10509 /*******************************************************************
10510  *
10511  * @brief extract Srb List received by CU
10512  *
10513  * @details
10514  *
10515  *    Function : extractSrbListToSetup
10516  *
10517  *    Functionality: extract Srb List received by CU
10518  *                   for both MAC and RLC
10519  *
10520  * @params[in] SRBs_ToBeSetup_Item_t pointer
10521  *             DuUeCfg pointer
10522  * @return ROK/RFAIED
10523  *
10524  * ****************************************************************/
10525
10526 uint8_t extractSrbListToSetup(SRBs_ToBeSetup_List_t *srbCfg, DuUeCfg *ueCfgDb)
10527 {
10528    uint8_t ret, srbIdx;
10529    SRBs_ToBeSetup_Item_t *srbItem = NULLP;
10530
10531    if(srbCfg)
10532    {
10533       for(srbIdx = 0; srbIdx < srbCfg->list.count; srbIdx++)
10534       {
10535          srbItem = &srbCfg->list.array[srbIdx]->value.choice.SRBs_ToBeSetup_Item;
10536          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
10537          {
10538             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in MAC");
10539             ret = RFAILED;
10540             break;
10541          }
10542          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
10543          {
10544             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in RLC");
10545             ret = RFAILED;
10546             break;
10547          }
10548          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
10549          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
10550          ret = procSrbListToSetup(srbItem, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
10551             &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs]);
10552          ueCfgDb->numRlcLcs++;
10553          ueCfgDb->numMacLcs++;
10554          DU_LOG("\nDEBUG --> DUAPP: extractSrbListToSetup: SRBID: %d [RLC,MAC,NumDrb]:[%x,%x,%x]",\
10555                             srbItem->sRBID, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
10556          if(ret == RFAILED)
10557          {
10558             DU_LOG("\nERROR  -->  F1AP:  Failed at extractSrbListToSetup()");
10559             break;
10560          }
10561       }
10562    }
10563    else
10564       ret = RFAILED;
10565
10566    return ret;
10567 }
10568
10569 /*******************************************************************
10570  *
10571  * @brief Fills Drb List received by CU
10572  *
10573  * @details
10574  *
10575  *    Function : procDrbListToSetupMod
10576  *
10577  *    Functionality: Fills Drb List received by CU
10578  *                   for both MAC and RLC
10579  *
10580  * @params[in] DRBs_ToBeSetup_Item_t , DRBs_ToBeSetupMod_Item_t,
10581  *             DRBs_ToBeModified_Item_t , lcId, LcCfg pointer,
10582  *             RlcBearerCfg , UpTnlCfg, RlcUeCfg
10583  * @return void
10584  *
10585  * ****************************************************************/
10586
10587 uint8_t procDrbListToSetupMod(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbItem,\
10588 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd, UpTnlCfg *upTnlInfo, RlcUeCfg *storedRlcUeCfg)
10589 {
10590    uint8_t cfgIdx = 0;
10591    RlcMode rlcModeInfo;
10592
10593    if(drbItem != NULLP)
10594    {
10595       /* Filling RLC INFO */
10596       procRlcLcCfg(drbItem->dRBID, lcId, RB_TYPE_DRB, drbItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd, &drbItem->\
10597       qoSInformation);
10598
10599       /* Filling MAC INFO */
10600       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, drbItem, NULL, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
10601       {
10602          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
10603          return RFAILED;
10604       }
10605    }
10606    else if(drbSetupModItem != NULLP)
10607    {
10608       procRlcLcCfg(drbSetupModItem->dRBID, lcId, RB_TYPE_DRB, drbSetupModItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd,
10609       &drbSetupModItem->qoSInformation);
10610
10611       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, NULL, drbSetupModItem, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
10612       {
10613          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
10614          return RFAILED;
10615       }
10616    }
10617    else if(drbModItem != NULLP)
10618    {
10619       /* Drb to Mod IEs doesnot have rlcMode to be modified
10620        * in ASN. Hence no change in RLC configurations */
10621       if(storedRlcUeCfg != NULLP)
10622       {
10623          for(cfgIdx = 0; cfgIdx < storedRlcUeCfg->numLcs; cfgIdx++)
10624          {
10625             if(storedRlcUeCfg->rlcLcCfg[cfgIdx].lcId == lcId)
10626             {
10627                rlcModeInfo = storedRlcUeCfg->rlcLcCfg[cfgIdx].rlcMode;
10628                break;
10629             }
10630          }
10631       }
10632
10633       procRlcLcCfg(drbModItem->dRBID, lcId, RB_TYPE_DRB, rlcModeInfo, CONFIG_MOD, NULL, rlcLcToAdd, drbModItem->qoSInformation);
10634       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_MOD, NULL, NULL, drbModItem, NULL, macLcToAdd, upTnlInfo) != ROK)
10635       {
10636          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
10637          return RFAILED;
10638       }
10639    }
10640    return ROK;
10641 }
10642
10643 /*******************************************************************
10644  *
10645  * @brief extract Drb List received by CU
10646  *
10647  * @details
10648  *
10649  *    Function : extractDrbListToSetupMod
10650  *
10651  *    Functionality: extract Drb List received by CU
10652  *                   for both MAC and RLC
10653  *
10654  * @params[in] DRBs_ToBeSetup_Item_t pointer
10655  *             DuUeCfg pointer
10656  * @return ROK/RFAIED
10657  *
10658  * ****************************************************************/
10659
10660 uint8_t extractDrbListToSetupMod(DRBs_ToBeSetup_List_t *drbCfg, DRBs_ToBeSetupMod_List_t *drbSetupModCfg,\
10661  DRBs_ToBeModified_List_t *drbModCfg, uint8_t drbCount, DuUeCfg *ueCfgDb, uint32_t *drbBitMap, RlcUeCfg *rlcUeCfg)
10662 {
10663    uint8_t ret, drbIdx = 0, lcId = 0;
10664    DRBs_ToBeSetup_Item_t *drbItem = NULLP;
10665    DRBs_ToBeSetupMod_ItemIEs_t *drbSetupModItem = NULLP;
10666    DRBs_ToBeModified_ItemIEs_t *drbModItem = NULLP;
10667
10668    ret = ROK;
10669    if(drbCount > 0)
10670    {
10671       for(drbIdx = 0; drbIdx < drbCount; drbIdx++)
10672       {
10673          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
10674          {
10675             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in MAC at extractDrbListToSetupMod()");
10676             ret = RFAILED;
10677             break;
10678          }
10679          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
10680          {
10681             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in RLC at extractDrbListToSetupMod()");
10682             ret = RFAILED;
10683             break;
10684          }
10685          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
10686          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
10687
10688          if(drbModCfg != NULLP)
10689          {
10690             drbModItem = (DRBs_ToBeModified_ItemIEs_t *) drbModCfg->list.array[drbIdx];
10691             lcId = fetchLcId(drbModItem->value.choice.DRBs_ToBeModified_Item.dRBID);
10692             if(lcId < MIN_DRB_LCID)
10693             {
10694                DU_LOG("\nERROR  --> F1AP : Failed fetching LCID %d in extractDrbListToSetupMod() for Modified List", lcId);
10695                break;
10696             }
10697             ret = procDrbListToSetupMod(lcId, NULL, NULL, &(drbModItem->value.choice.DRBs_ToBeModified_Item),\
10698             &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs],\
10699             &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
10700             if(ret == RFAILED)
10701             {
10702                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for Modified List");
10703                break;
10704             }
10705
10706          }
10707          else
10708          {
10709             lcId = getDrbLcId(drbBitMap);
10710             if(lcId == RFAILED)
10711             {
10712                DU_LOG("\nERROR  -->  F1AP :  InCorrect LCID extractDrbListToSetupMod()");
10713                ret = RFAILED;
10714                break;
10715             }
10716             if(drbCfg != NULL)
10717             {
10718                drbItem = &drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
10719                ret = procDrbListToSetupMod(lcId, drbItem, NULL, NULL, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
10720                      &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
10721                if(ret == RFAILED)
10722                {
10723                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetup List");
10724                   break;
10725                }
10726             }
10727             else if(drbSetupModCfg != NULL)
10728             {
10729                drbSetupModItem = (DRBs_ToBeSetupMod_ItemIEs_t *) drbSetupModCfg->list.array[drbIdx];
10730                ret = procDrbListToSetupMod(lcId, NULL, &(drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item), NULL,\
10731                      &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs],\
10732                      &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
10733                if(ret == RFAILED)
10734                {
10735                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetupMod List");
10736                   break;
10737                }
10738                ueCfgDb->numDrbSetupMod++;
10739             }
10740          }
10741          ueCfgDb->numRlcLcs++;
10742          ueCfgDb->numMacLcs++;
10743          ueCfgDb->numDrb++;
10744
10745          DU_LOG("\nDEBUG --> DUAPP: extractDrbListToSetupMod:lcId:%x ,BitMap:%x, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
10746                             lcId,*drbBitMap, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
10747          if(ret == RFAILED)
10748          {
10749             DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod()");
10750             break;
10751          }
10752       }
10753    }
10754    else
10755       ret = RFAILED;
10756
10757    return ret;
10758 }
10759
10760 /*******************************************************************
10761  *
10762  * @brief Function to extract Dl RRC Msg received from CU
10763  *
10764  * @details
10765  *
10766  *    Function : extractDlRrcMsg
10767  *
10768  *    Functionality: Function to extract Dl RRC Msg received from CU
10769  *
10770  * @params[in] F1AP message
10771  * @return ROK     - success
10772  *         RFAILED - failure
10773  *
10774  * ****************************************************************/
10775
10776 uint8_t extractDlRrcMsg(uint32_t gnbDuUeF1apId, uint32_t gnbCuUeF1apId, \
10777    F1DlRrcMsg *dlRrcMsg, RRCContainer_t *rrcContainer)
10778 {
10779    uint8_t ret = ROK;
10780    dlRrcMsg->rrcMsgSize = rrcContainer->size;
10781    if(dlRrcMsg->rrcMsgSize > 0)
10782    {
10783       DU_ALLOC_SHRABL_BUF(dlRrcMsg->rrcMsgPdu, dlRrcMsg->rrcMsgSize);
10784       if(!dlRrcMsg->rrcMsgPdu)
10785       {
10786          DU_LOG("\nERROR  --> DU APP : Memory allocation failed for RRC Msg in extractDlRrcMsg()");
10787          ret = RFAILED;
10788       }
10789       else
10790       {
10791          dlRrcMsg->gnbDuUeF1apId = gnbDuUeF1apId;
10792          dlRrcMsg->gnbCuUeF1apId = gnbCuUeF1apId;
10793          dlRrcMsg->srbId = SRB1_LCID;
10794          memcpy(dlRrcMsg->rrcMsgPdu, rrcContainer->buf, dlRrcMsg->rrcMsgSize);
10795       }
10796    }
10797    return ret;
10798 }
10799
10800 /*******************************************************************
10801  *
10802  * @brief Extract UE capability info
10803  *
10804  * @details
10805  *
10806  *    Function : extractUeCapability
10807  *
10808  *    Functionality: Extract UE capability info and stores in ue Cb
10809  *
10810  * @params[in] Octet string of UE capability RAT container list
10811  * @return ROK     - success
10812  *         RFAILED - failure
10813  *
10814  * ****************************************************************/
10815 UE_NR_Capability_t *extractUeCapability(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf, DuUeCb *ueCb)
10816 {
10817    uint8_t  idx;
10818    uint16_t recvBufLen;
10819    asn_dec_rval_t rval;
10820    UE_NR_Capability_t  *ueNrCap = NULLP;
10821    UE_CapabilityRAT_ContainerListRRC_t  *ueCapRatContList = NULLP;
10822
10823    /* Decoding UE Capability RAT Container List */
10824    recvBufLen = ueCapablityListBuf->size;
10825    DU_ALLOC(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10826    if(!ueCapRatContList)
10827    {
10828       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
10829       return NULLP;
10830    }
10831    memset(ueCapRatContList, 0, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10832    memset(&rval, 0, sizeof(asn_dec_rval_t));
10833    rval = aper_decode(0, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, (void **)&ueCapRatContList,
10834           ueCapablityListBuf->buf, recvBufLen, 0, 0);
10835    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10836    {
10837       DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
10838       return NULLP;
10839    }
10840    xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, ueCapRatContList);
10841
10842    /* Free encoded buffer after decoding */
10843
10844    for(idx = 0; idx < ueCapRatContList->list.count; idx++)
10845    {
10846       if(ueCapRatContList->list.array[idx]->rat_Type == RAT_Type_nr)
10847       {
10848          /* Decoding UE NR Capability */
10849           recvBufLen = ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.size;
10850           DU_ALLOC(ueNrCap, sizeof(UE_NR_Capability_t));
10851           if(!ueNrCap)
10852           {
10853              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
10854              DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10855              return NULLP;
10856           }
10857           memset(ueNrCap, 0, sizeof(UE_NR_Capability_t));
10858           memset(&rval, 0, sizeof(asn_dec_rval_t));
10859           rval = aper_decode(0, &asn_DEF_UE_NR_Capability, (void **)&ueNrCap,
10860                  ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf, recvBufLen, 0, 0);
10861           if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10862           {
10863              DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
10864              return NULLP;
10865           }
10866           xer_fprint(stdout, &asn_DEF_UE_NR_Capability, ueNrCap);
10867
10868           /* Free encoded buffer after decoding */
10869           free(ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf);
10870       }
10871       free(ueCapRatContList->list.array[idx]);
10872    }
10873
10874    /* Free Memory*/
10875    free(ueCapRatContList->list.array);
10876    DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10877    return ueNrCap;
10878 }
10879
10880 /*******************************************************************
10881 *
10882 * @brief free UE context setup request from CU
10883 *
10884 * @details
10885 *
10886 *    Function : freeAperDecodeF1UeContextSetupReq
10887 *
10888 *    Functionality: freeing part for the memory allocated by aper_decoder
10889 *
10890 * @params[in] F1AP message
10891 * @return ROK     - success
10892 *         RFAILED - failure
10893 *
10894 * ****************************************************************/
10895 void freeAperDecodeF1UeContextSetupReq(UEContextSetupRequest_t   *ueSetReq)
10896 {
10897    uint8_t ieIdx = 0;
10898
10899    if(ueSetReq->protocolIEs.list.array != NULLP)
10900    {
10901       for(ieIdx = 0; ieIdx < ueSetReq->protocolIEs.list.count; ieIdx++)
10902       {
10903          if(ueSetReq->protocolIEs.list.array[ieIdx])
10904          {
10905             switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
10906             {
10907                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10908                   break;
10909                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10910                   break;
10911                case ProtocolIE_ID_id_SpCell_ID:
10912                   freeAperDecodeNrcgi(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
10913                   break;
10914                case ProtocolIE_ID_id_ServCellIndex:
10915                   break;
10916                case ProtocolIE_ID_id_SpCellULConfigured:
10917                   break;
10918                case ProtocolIE_ID_id_CUtoDURRCInformation:
10919
10920                   freeAperDecodeCuToDuInfo(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation);
10921                   break;
10922                case ProtocolIE_ID_id_SCell_ToBeSetup_List:
10923
10924                   freeAperDecodeSplCellList(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SCell_ToBeSetup_List);
10925                   break;
10926                case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
10927
10928                   freeAperDecodeSRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List);
10929                   break;
10930                case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
10931
10932                   freeAperDecodeDRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List);
10933                   break;
10934                case ProtocolIE_ID_id_RRCContainer:
10935                   {
10936
10937                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf != NULLP)
10938                      {
10939
10940                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
10941                      }
10942                      break;
10943                   }
10944                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10945                   break;
10946                case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
10947                   {
10948                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf)
10949                      {
10950                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf);
10951                      }
10952                      break;
10953                   }
10954                default:
10955                   DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld " ,ueSetReq->protocolIEs.list.array[ieIdx]->id);
10956             }
10957             free(ueSetReq->protocolIEs.list.array[ieIdx]);
10958          }
10959       }
10960       free(ueSetReq->protocolIEs.list.array);
10961    }
10962 }
10963 /*******************************************************************
10964  *
10965  * @brief Process UE context setup request from CU
10966  *
10967  * @details
10968  *
10969  *    Function : procF1UeContextSetupReq
10970  *
10971  *    Functionality: Process UE context setup request from CU
10972  *
10973  * @params[in] F1AP message
10974  * @return ROK     - success
10975  *         RFAILED - failure
10976  *
10977  * ****************************************************************/
10978 uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
10979 {
10980    uint8_t  ret=0, ieIdx=0, ueIdx=0, cellIdx=0;
10981    bool ueCbFound = false;
10982    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0, bitRateSize=0;
10983    DuUeCb   *duUeCb = NULL;
10984    UEContextSetupRequest_t   *ueSetReq = NULL;
10985    DRBs_ToBeSetup_List_t *drbCfg = NULL;
10986
10987    ret = ROK;
10988
10989    ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
10990    for(ieIdx=0; (ieIdx < ueSetReq->protocolIEs.list.count && ret == ROK); ieIdx++)
10991    {
10992       switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
10993       {
10994          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10995             {
10996                gnbCuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
10997                break;
10998             }
10999          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11000             {
11001                gnbDuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
11002                break;
11003             }
11004          case ProtocolIE_ID_id_ServCellIndex:
11005             {
11006                cellIdx = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.ServCellIndex;
11007                for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
11008                {
11009                   if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
11010                         (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
11011                   {
11012                      ueCbFound = true;
11013                      duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
11014                      DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
11015                      if(duUeCb->f1UeDb)
11016                      {
11017                         memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
11018                         duUeCb->f1UeDb->actionType = UE_CTXT_SETUP;
11019                         duUeCb->f1UeDb->cellIdx = cellIdx;
11020                      }
11021                      else
11022                      {
11023                         DU_LOG("\nERROR  -->  F1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
11024                         ret = RFAILED;
11025                      }
11026                      break;
11027                   }
11028                   else
11029                      ueCbFound = false;
11030
11031                }
11032                if(!ueCbFound)
11033                {
11034                   DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
11035                   ret = RFAILED;
11036                }
11037                break;
11038             }
11039          case ProtocolIE_ID_id_SpCellULConfigured:
11040             /* Indicates whether the gNB-CU requests the gNB-DU to configure the uplink as no UL,
11041                UL, SUL or UL+SUL for the indicated cell for the UE */
11042             break;
11043          case ProtocolIE_ID_id_CUtoDURRCInformation:
11044             {
11045                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.uE_CapabilityRAT_ContainerList)
11046                {
11047                   duUeCb->f1UeDb->duUeCfg.ueNrCapability = \
11048                   extractUeCapability(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.\
11049                   uE_CapabilityRAT_ContainerList, duUeCb);
11050                }
11051                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.iE_Extensions)
11052                {
11053                   duUeCb->f1UeDb->duUeCfg.cellGrpCfg = extractCellGrpInfo(ueSetReq->protocolIEs.list.array[ieIdx]->\
11054                         value.choice.CUtoDURRCInformation.iE_Extensions, &duUeCb->f1UeDb->duUeCfg);
11055                   if(!duUeCb->f1UeDb->duUeCfg.cellGrpCfg)
11056                   {
11057                      DU_LOG("\nERROR  -->  F1AP: Failed to extract cell Grp Info");
11058                      //TODO: Update the failure cause in ue context Setup Response
11059                      ret = RFAILED;
11060                   }
11061                }
11062                break;
11063             }
11064          case ProtocolIE_ID_id_SCell_ToBeSetup_List:
11065             {
11066                DU_LOG("\nINFO   -->  DU_APP: Received SCell_ToBeSetup_List but  Not processing the list");
11067                break;
11068             }
11069          case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
11070             {
11071                if(extractSrbListToSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List,\
11072                &duUeCb->f1UeDb->duUeCfg))
11073                {
11074                   DU_LOG("\nERROR  -->  DU APP : Failed at extractSrbListToSetup()");
11075                   //TODO: Update the failure cause in ue context Setup Response
11076                   ret = RFAILED;
11077                }
11078                break;
11079             }
11080          case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
11081             {
11082                   drbCfg = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List;
11083
11084                   if(extractDrbListToSetupMod(drbCfg, NULL, NULL, drbCfg->list.count, &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, NULLP))
11085                   {
11086                      DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod()");
11087                      //TODO: Update the failure cause in ue context Setup Response
11088                      ret = RFAILED;
11089                   }
11090                break;
11091             }
11092          case ProtocolIE_ID_id_RRCContainer:
11093             {
11094                /* Filling Dl RRC Msg Info */
11095                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
11096                if(!duUeCb->f1UeDb->dlRrcMsg)
11097                {
11098                   DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
11099                   ret = RFAILED;
11100                }
11101                else
11102                {
11103                   duUeCb->f1UeDb->dlRrcMsgPres = true;
11104                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
11105                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
11106                         &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer);
11107                }
11108                break;
11109             }
11110          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
11111             {
11112                if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
11113                {
11114                   duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
11115                }
11116                else
11117                {
11118                   DU_LOG("\nERROR  -->  Ignoring delivery report, since rrcContainer is not present");
11119                }
11120                break;
11121             }
11122          case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
11123             {
11124                /* MaximumBitRate Uplink */
11125                bitRateSize = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.size;
11126                if(bitRateSize > 0)
11127                {
11128                   DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.ambrCfg, bitRateSize);
11129                   if(!duUeCb->f1UeDb->duUeCfg.ambrCfg)
11130                   {
11131                      DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
11132                      ret = RFAILED;
11133                   }
11134                   else
11135                   {
11136                      memset(duUeCb->f1UeDb->duUeCfg.ambrCfg, 0, sizeof(AmbrCfg));
11137                      memcpy(&duUeCb->f1UeDb->duUeCfg.ambrCfg->ulBr,
11138                            ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf, bitRateSize);
11139                   }
11140                }
11141                else
11142                   ret = RFAILED;
11143                break;
11144             }
11145          default:
11146             {
11147                break;
11148             }
11149       }
11150    }
11151    if(ret == RFAILED)
11152    {
11153       /*TODO : Negative case*/
11154       // BuildAndSendUeContextSetupRsp(cellId,ueId);
11155       DU_LOG("\nERROR  -->  F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
11156    }
11157    else
11158       ret = duProcUeContextSetupRequest(duUeCb);
11159
11160    freeAperDecodeF1UeContextSetupReq(ueSetReq);
11161    return ret;
11162
11163 }
11164 /*******************************************************************
11165  * @brief Free the memory allocated for Dl Tunnel Info
11166  *
11167  * @details
11168  *
11169  *    Function : freeDlTnlInfo
11170  *
11171  *    Functionality:
11172  *       Free the memory allocated for Dl Tunnel Info
11173  *
11174  * @params[in] DLUPTNLInformation_ToBeSetup_List_t *
11175  * @return void
11176  *
11177  * ****************************************************************/
11178
11179 void freeDlTnlInfo(DLUPTNLInformation_ToBeSetup_List_t *tnlInfo)
11180 {
11181    uint8_t arrIdx = 0;
11182
11183    if(tnlInfo)
11184    {
11185       for(arrIdx=0; arrIdx < tnlInfo->list.count; arrIdx++)
11186       {
11187          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf,\
11188                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
11189          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf,\
11190                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
11191          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
11192          DU_FREE(tnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
11193       }
11194       DU_FREE(tnlInfo->list.array, tnlInfo->list.size);
11195    }
11196 }
11197
11198 /*******************************************************************
11199  * @brief Free the memory allocated for DRB setup List
11200  *
11201  * @details
11202  *
11203  *    Function : freeDrbSetupList
11204  *
11205  *    Functionality:
11206  *       Free the memory allocated for DRB setup list
11207  *
11208  * @params[in] DRBs_Setup_List_t *
11209  * @return void
11210  *
11211  * ****************************************************************/
11212 void freeDrbSetupList(DRBs_Setup_List_t *drbSetupList)
11213 {
11214    uint8_t arrIdx = 0;
11215    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
11216
11217    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
11218    {
11219       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
11220       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
11221       DU_FREE(drbSetupList->list.array[arrIdx],  sizeof(DRBs_Setup_Item_t));
11222    }
11223    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
11224 }
11225
11226 /*******************************************************************
11227  * @brief Free the memory allocated for UE Setup response
11228  *
11229  * @details
11230  *
11231  *    Function : FreeUeContextSetupRsp
11232  *
11233  *    Functionality:
11234  *       Free the memory allocated for UE Setup response
11235  *
11236  * @params[in] F1AP PDU for UE setup response
11237  * @return ROK     - success
11238  *         RFAILED - failure
11239  *
11240  * ****************************************************************/
11241 void FreeUeContextSetupRsp(F1AP_PDU_t *f1apMsg)
11242 {
11243    uint8_t idx;
11244    UEContextSetupResponse_t *ueSetRsp = NULLP;
11245
11246    if(f1apMsg)
11247    {
11248       if(f1apMsg->choice.successfulOutcome)
11249       {
11250          ueSetRsp = &f1apMsg->choice.successfulOutcome->value.choice.\
11251                     UEContextSetupResponse;
11252          if(ueSetRsp->protocolIEs.list.array)
11253          {
11254             for(idx = 0; idx < ueSetRsp->protocolIEs.list.count; idx++)
11255             {
11256                if(ueSetRsp->protocolIEs.list.array[idx])
11257                {
11258                   switch(ueSetRsp->protocolIEs.list.array[idx]->id)
11259                   {
11260                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11261                         break;
11262                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11263                         break;
11264                      case ProtocolIE_ID_id_DUtoCURRCInformation:
11265                         {
11266                            CellGroupConfig_t *cellGrpCfg = NULLP;
11267                            cellGrpCfg  = &ueSetRsp->protocolIEs.list.array[idx]->value.choice.\
11268                                          DUtoCURRCInformation.cellGroupConfig;
11269                            if(cellGrpCfg->buf != NULLP)
11270                            {
11271                               DU_FREE(cellGrpCfg->buf, cellGrpCfg->size);
11272                               cellGrpCfg = NULLP;
11273                            }
11274                            break;
11275                         }
11276                     case ProtocolIE_ID_id_DRBs_Setup_List:
11277                         {
11278                            freeDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
11279                            break;
11280                         }
11281                      default:
11282                         DU_LOG("\nERROR  -->  DUAPP: Invalid Id %ld at FreeUeContextSetupRsp()",\
11283                         ueSetRsp->protocolIEs.list.array[idx]->id);
11284                         break;
11285                   }
11286                   DU_FREE(ueSetRsp->protocolIEs.list.array[idx],\
11287                         sizeof(UEContextSetupResponseIEs_t));
11288                }
11289             }
11290             DU_FREE(ueSetRsp->protocolIEs.list.array, \
11291                   ueSetRsp->protocolIEs.list.size);
11292          }
11293          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11294       }
11295       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11296    }
11297 }
11298
11299 /*******************************************************************
11300  *
11301  * @brief Builds Ue context Setup Rsp DU To CU Info
11302  *
11303  * @details
11304  *
11305  *    Function : EncodeUeCntxtDuToCuInfo
11306  *
11307  *    Functionality: Builds Ue context Setup Rsp DU To CU Info
11308  *
11309  * @params[in] CellGroupConfig_t *, CellGroupConfigRrc_t *
11310  *
11311  * @return ROK     - success
11312  *         RFAILED - failure
11313  *
11314  ******************************************************************/
11315
11316 uint8_t EncodeUeCntxtDuToCuInfo(CellGroupConfig_t *duToCuCellGrp, CellGroupConfigRrc_t *duCellGrpCfg)
11317 {
11318    asn_enc_rval_t        encRetVal;
11319
11320    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, duCellGrpCfg);
11321    memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
11322    encBufSize = 0;
11323    encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, duCellGrpCfg, PrepFinalEncBuf, encBuf);
11324    /* Encode results */
11325    if(encRetVal.encoded == ENCODE_FAIL)
11326    {
11327       DU_LOG( "\nERROR  -->  F1AP : Could not encode UeCntxtDuToCuInfo (at %s)\n",\
11328             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11329       return RFAILED;
11330    }
11331    else
11332    {
11333       DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
11334       for(int i=0; i< encBufSize; i++)
11335       {
11336          printf("%x",encBuf[i]);
11337       }
11338    }
11339    duToCuCellGrp->size = encBufSize;
11340    DU_ALLOC(duToCuCellGrp->buf, duToCuCellGrp->size);
11341    if(!duToCuCellGrp->buf)
11342    {
11343       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in UeCntxtDuToCuInfo");
11344    }
11345    memcpy(duToCuCellGrp->buf, encBuf, duToCuCellGrp->size);
11346    return ROK;
11347 }
11348
11349 /*******************************************************************
11350  *
11351  * @brief Fills Dl Gtp tunnel Info
11352  *
11353  * @details
11354  *
11355  *    Function : fillGtpTunnelforDl
11356  *
11357  *    Functionality: Fills Dl Gtp tunnel Info
11358  *
11359  * @params[in]
11360  *
11361  * @return ROK     - success
11362  *         RFAILED - failure
11363  *
11364  * ****************************************************************/
11365
11366 uint8_t fillGtpTunnelforDl(GTPTunnel_t *gtpDl, GtpTnlCfg *gtpUeCfg)
11367 {
11368    uint8_t bufSize = 0;
11369
11370    gtpDl->transportLayerAddress.size    = 4*sizeof(uint8_t);
11371    DU_ALLOC(gtpDl->transportLayerAddress.buf, gtpDl->transportLayerAddress.size);
11372    if(gtpDl->transportLayerAddress.buf == NULLP)
11373    {
11374       return RFAILED;
11375    }
11376    memcpy(gtpDl->transportLayerAddress.buf, &gtpUeCfg->dlTnlAddress, gtpDl->transportLayerAddress.size);
11377
11378    /*GTP TEID*/
11379    gtpDl->gTP_TEID.size = 4 * sizeof(uint8_t);
11380    DU_ALLOC(gtpDl->gTP_TEID.buf, gtpDl->gTP_TEID.size);
11381    if(gtpDl->gTP_TEID.buf == NULLP)
11382    {
11383       return RFAILED;
11384    }
11385    bufSize = 3; /*forming an Octect String*/
11386    fillTeIdString(bufSize, gtpUeCfg->teId, gtpDl->gTP_TEID.buf);
11387
11388    return ROK;
11389 }
11390
11391 /*******************************************************************
11392  *
11393  * @brief Fills DL Tunnel Setup List
11394  *
11395  * @details
11396  *
11397  *    Function : fillDlTnlSetupList
11398  *
11399  *    Functionality: Fills the DL Tunnel Setup List
11400  *
11401  * @params[in]
11402  *
11403  * @return ROK     - success
11404  *         RFAILED - failure
11405  *
11406  * ****************************************************************/
11407
11408 uint8_t fillDlTnlSetupList(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo, UpTnlCfg *tnlCfg)
11409 {
11410    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
11411
11412    eleCount = 1;
11413    dlTnlInfo->list.count = eleCount;
11414    dlTnlInfo->list.size = (eleCount * sizeof(DLUPTNLInformation_ToBeSetup_Item_t *));
11415
11416    /* Initialize the DL Tnl Setup List Members */
11417    DU_ALLOC(dlTnlInfo->list.array, dlTnlInfo->list.size);
11418    if(dlTnlInfo->list.array == NULLP)
11419    {
11420       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL Tnl Setup List in fillDlTnlSetupList()");
11421       ret = RFAILED;
11422    }
11423    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
11424    {
11425       DU_ALLOC(dlTnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
11426       if(dlTnlInfo->list.array[arrIdx] == NULLP)
11427       {
11428          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDlTnlSetupList()", arrIdx);
11429          return RFAILED;
11430       }
11431       dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
11432       DU_ALLOC(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
11433       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel == NULLP)
11434       {
11435          DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL tunnel info in fillDlTnlSetupList()");
11436          return RFAILED;
11437       }
11438       ret = fillGtpTunnelforDl(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel,\
11439                tnlCfg->tnlCfg1);
11440       if(ret != ROK)
11441          break;
11442    }
11443    return ret;
11444 }
11445
11446 /*******************************************************************
11447  *
11448  * @brief Fills the Drb Setup List for Ue Context Setup Response
11449  *
11450  * @details
11451  *
11452  *    Function : fillDrbSetupList
11453  *
11454  *    Functionality: Fills the Drb Setup List for Ue Context Setup Response
11455  *
11456  * @params[in]
11457  *
11458  * @return ROK     - success
11459  *         RFAILED - failure
11460  *
11461  * ****************************************************************/
11462 uint8_t fillDrbSetupList(DRBs_Setup_List_t *drbSetupList, DuUeCfg *ueCfg)
11463 {
11464    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
11465    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
11466
11467    eleCount = ueCfg->numDrb;
11468    drbSetupList->list.count = eleCount;
11469    drbSetupList->list.size = \
11470         (eleCount * sizeof(DRBs_Setup_Item_t *));
11471
11472    /* Initialize the Drb Setup List Members */
11473    DU_ALLOC(drbSetupList->list.array, drbSetupList->list.size);
11474    if(drbSetupList->list.array == NULLP)
11475    {
11476       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DRB Setup List in fillDrbSetupList()");
11477       ret = RFAILED;
11478    }
11479
11480    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
11481    {
11482       DU_ALLOC(drbSetupList->list.array[arrIdx], sizeof(DRBs_Setup_Item_t));
11483       if(drbSetupList->list.array[arrIdx] == NULLP)
11484       {
11485          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDrbSetupList()", arrIdx);
11486          return RFAILED;
11487       }
11488       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
11489       drbItemIe->id = ProtocolIE_ID_id_DRBs_Setup_Item;
11490       drbItemIe->criticality = Criticality_reject;
11491       drbItemIe->value.present = DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item;
11492       drbItemIe->value.choice.DRBs_Setup_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
11493       ret = fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List,\
11494           &ueCfg->upTnlInfo[arrIdx]);
11495       if(ret != ROK)
11496          break;
11497    }
11498    return ret;
11499 }
11500
11501 /*******************************************************************
11502  *
11503  * @brief Builds and sends the UE Setup Response
11504  *
11505  * @details
11506  *
11507  *    Function : BuildAndSendUeContextSetupRsp
11508  *
11509  *    Functionality: Constructs the UE Setup Response and sends
11510  *                   it to the DU through SCTP.
11511  *
11512  * @params[in] uint8_t cellId,uint8_t ueId
11513  *
11514  * @return ROK     - success
11515  *         RFAILED - failure
11516  *
11517  * ****************************************************************/
11518 uint8_t BuildAndSendUeContextSetupRsp(uint8_t cellId,uint8_t ueId)
11519 {
11520    uint8_t   idx, ret, cellIdx, elementCnt;
11521    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
11522    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
11523    asn_enc_rval_t  encRetVal;        /* Encoder return value */
11524    F1AP_PDU_t               *f1apMsg = NULLP;
11525    UEContextSetupResponse_t *ueSetRsp = NULLP;
11526    CellGroupConfigRrc_t     *cellGrpCfg = NULLP;
11527    DuUeCb                   *ueCb = NULLP;
11528
11529    DU_LOG("\n INFO   -->  F1AP : Building UE Context Setup Response for cellId %d, ueId %d\n", cellId, ueId);
11530
11531    while(true)
11532    {
11533       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11534       if(f1apMsg == NULLP)
11535       {
11536          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11537          ret = RFAILED;
11538          break;
11539       }
11540
11541       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
11542       DU_ALLOC(f1apMsg->choice.successfulOutcome,
11543             sizeof(SuccessfulOutcome_t));
11544       if(f1apMsg->choice.successfulOutcome == NULLP)
11545       {
11546          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
11547          ret = RFAILED;
11548          break;
11549       }
11550
11551       f1apMsg->choice.successfulOutcome->procedureCode = \
11552                                                          ProcedureCode_id_UEContextSetup;
11553       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
11554       f1apMsg->choice.successfulOutcome->value.present = \
11555                                                          SuccessfulOutcome__value_PR_UEContextSetupResponse;
11556
11557       ueSetRsp =
11558          &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
11559       elementCnt = 4;
11560       ueSetRsp->protocolIEs.list.count = elementCnt;
11561       ueSetRsp->protocolIEs.list.size = \
11562                                         elementCnt * sizeof(UEContextSetupResponse_t *);
11563
11564       /* Initialize the UESetup members */
11565       DU_ALLOC(ueSetRsp->protocolIEs.list.array, \
11566             ueSetRsp->protocolIEs.list.size);
11567       if(ueSetRsp->protocolIEs.list.array == NULLP)
11568       {
11569          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
11570          ret = RFAILED;
11571          break;
11572       }
11573
11574       for(idx=0; idx<elementCnt; idx++)
11575       {
11576          DU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
11577                sizeof(UEContextSetupResponseIEs_t));
11578          if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
11579          {
11580             DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
11581             ret = RFAILED;
11582             break;
11583          }
11584       }
11585       /* Fetching Ue Cb Info*/
11586       GET_CELL_IDX(cellId, cellIdx);
11587       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbDuUeF1apId;
11588       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbCuUeF1apId;
11589       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueId-1];
11590
11591       idx = 0;
11592       /*GNB CU UE F1AP ID*/
11593       ueSetRsp->protocolIEs.list.array[idx]->id = \
11594                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11595       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11596       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
11597                                                              UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
11598       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
11599
11600       /*GNB DU UE F1AP ID*/
11601       idx++;
11602       ueSetRsp->protocolIEs.list.array[idx]->id = \
11603                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11604       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11605       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
11606                                                              UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
11607       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
11608
11609
11610       /*DUtoCURRC Information */
11611       idx++;
11612       ueSetRsp->protocolIEs.list.array[idx]->id  = \
11613                                                    ProtocolIE_ID_id_DUtoCURRCInformation;
11614       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11615       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
11616                                                             UEContextSetupResponseIEs__value_PR_DUtoCURRCInformation;
11617       if(ueCb->f1UeDb)
11618       {
11619          if(ueCb->f1UeDb->duUeCfg.cellGrpCfg)
11620          {
11621             cellGrpCfg = (CellGroupConfigRrc_t*)ueCb->f1UeDb->duUeCfg.cellGrpCfg;
11622             ret = EncodeUeCntxtDuToCuInfo(&ueSetRsp->protocolIEs.list.array[idx]->value.\
11623                      choice.DUtoCURRCInformation.cellGroupConfig, cellGrpCfg);
11624             if(ret == RFAILED)
11625             {
11626                DU_LOG("\nERROR  -->  F1AP : Failed to EncodeUeCntxtDuToCuInfo in BuildAndSendUeContextSetupRsp()");
11627                freeF1UeDb(ueCb->f1UeDb);
11628                ueCb->f1UeDb = NULLP;
11629                break;
11630             }
11631          }
11632       }
11633       else
11634       {
11635          DU_LOG("\nERROR  -->  F1AP : Failed to form DUtoCU RRCInfo at BuildAndSendUeContextSetupRsp()");
11636          ret = RFAILED;
11637          break;
11638       }
11639
11640       /* Drb Setup List */
11641       idx++;
11642       ueSetRsp->protocolIEs.list.array[idx]->id  = \
11643                                  ProtocolIE_ID_id_DRBs_Setup_List;
11644       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11645       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
11646                                  UEContextSetupResponseIEs__value_PR_DRBs_Setup_List;
11647       ret = fillDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List,\
11648                &ueCb->f1UeDb->duUeCfg);
11649       if(ret == RFAILED)
11650       {
11651          DU_LOG("\nERROR  -->  F1AP : Failed to fillDrbSetupList in BuildAndSendUeContextSetupRsp()");
11652          freeF1UeDb(ueCb->f1UeDb);
11653          ueCb->f1UeDb = NULLP;
11654          break;
11655       }
11656
11657        /* Free UeContext Db created during Ue context Req */
11658        freeF1UeDb(ueCb->f1UeDb);
11659        ueCb->f1UeDb = NULLP;
11660
11661       /* TODO: To send Drb list */
11662       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11663
11664       /* Encode the UE context setup response type as APER */
11665       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
11666       encBufSize = 0;
11667       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11668             encBuf);
11669       /* Encode results */
11670       if(encRetVal.encoded == ENCODE_FAIL)
11671       {
11672          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Response structure (at %s)\n",\
11673                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11674          ret = RFAILED;
11675          break;
11676       }
11677       else
11678       {
11679          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Setup Response\n");
11680          for(int i=0; i< encBufSize; i++)
11681          {
11682             printf("%x",encBuf[i]);
11683          }
11684       }
11685
11686       /* Sending  msg  */
11687       if(sendF1APMsg()  != ROK)
11688       {
11689          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Response failed");
11690          ret = RFAILED;
11691          break;
11692       }
11693       break;
11694    }
11695    FreeUeContextSetupRsp(f1apMsg);
11696    return ret;
11697 }/* End of BuildAndSendUeContextSetupRsp */
11698 /*******************************************************************
11699 *
11700 * @brief  Build And Send Ue Context Rsp
11701 *
11702 * @details
11703 *
11704 *    Function : BuildAndSendUeCtxtRsp
11705 *
11706 *    Functionality : Build And Send Ue Context Rsp
11707
11708 * @params[in]
11709 * @return sucess = ROK
11710 *         failure = RFAILED
11711 *
11712 * ****************************************************************/
11713 uint8_t BuildAndSendUeCtxtRsp(uint8_t cellId, uint8_t ueId)
11714 {
11715    uint8_t cellIdx = 0, actionType = 0;
11716
11717    GET_CELL_IDX(cellId, cellIdx);
11718    actionType = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].f1UeDb->actionType;
11719
11720    switch(actionType)
11721    {
11722       case UE_CTXT_SETUP:
11723          {
11724             BuildAndSendUeContextSetupRsp(cellId,ueId);
11725             break;
11726          }
11727       case UE_CTXT_MOD:
11728          {
11729             BuildAndSendUeContextModRsp(cellId, ueId);
11730             break;
11731          }
11732       default:
11733          DU_LOG("ERROR  -->  F1AP: Invalid Action Type %d at BuildAndSendUeCtxtRsp()", actionType);
11734          break;
11735
11736    }
11737    return ROK;
11738 }
11739
11740 /*******************************************************************
11741  *
11742  * @brief deallocating the memory of  F1reset msg
11743  *
11744  * @details
11745  *
11746  *    Function : FreeF1ResetReq
11747  *
11748  *    Functionality :
11749  *         - freeing memory of F1reset request msg
11750  *
11751  * @params[in]
11752  * @return void
11753  *
11754  *
11755  * ****************************************************************/
11756 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
11757 {
11758    uint8_t idx =0 ;
11759    Reset_t *f1ResetMsg;
11760
11761    if(f1apMsg)
11762    {
11763       if(f1apMsg->choice.initiatingMessage)
11764       {
11765          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11766
11767          if(f1ResetMsg->protocolIEs.list.array)
11768          {
11769             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
11770             {
11771                if(f1ResetMsg->protocolIEs.list.array[idx])
11772                {
11773                   DU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
11774                }
11775             }
11776             DU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
11777          }
11778          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11779       }
11780       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11781    }
11782 }
11783 /*******************************************************************
11784  *
11785  * @brief Build and Send F1reset request
11786  *
11787  * @details
11788  *
11789  *    Function : BuildAndSendF1ResetReq
11790  *
11791  *    Functionality:
11792  *         - Build and Send F1reset request msg
11793  *
11794  * @params[in]
11795  * @return ROK     - success
11796  *         RFAILED - failure
11797  *
11798  * ****************************************************************/
11799 uint8_t BuildAndSendF1ResetReq()
11800 {
11801    uint8_t          elementCnt=0;
11802    uint8_t          idx=0;
11803    uint8_t          ret= RFAILED;
11804    Reset_t          *f1ResetMsg = NULLP;
11805    F1AP_PDU_t       *f1apMsg = NULLP;
11806    asn_enc_rval_t   encRetVal;
11807    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset request \n");
11808    do
11809    {
11810       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11811       if(f1apMsg == NULLP)
11812       {
11813          break;
11814       }
11815       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
11816       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11817       if(f1apMsg->choice.initiatingMessage == NULLP)
11818       {
11819          break;
11820       }
11821       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
11822       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
11823       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
11824
11825       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11826
11827       elementCnt = 3;
11828       f1ResetMsg->protocolIEs.list.count = elementCnt;
11829       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
11830
11831       /* Initialize the F1Setup members */
11832       DU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
11833       if(f1ResetMsg->protocolIEs.list.array == NULLP)
11834       {
11835          break;
11836       }
11837       for(idx=0; idx<elementCnt; idx++)
11838       {
11839          DU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
11840          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
11841          {
11842             break;
11843          }
11844       }
11845
11846       /*TransactionID*/
11847       idx=0;
11848       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
11849       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11850       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
11851       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
11852
11853       /*Cause*/
11854       idx++;
11855       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
11856       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
11857       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
11858       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
11859       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
11860
11861       /*Reset Type*/
11862       idx++;
11863       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
11864       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11865       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
11866       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
11867       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
11868
11869       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11870
11871       /* Encode the F1SetupRequest type as APER */
11872       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11873       encBufSize = 0;
11874       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11875             encBuf);
11876
11877       /* Encode results */
11878       if(encRetVal.encoded == ENCODE_FAIL)
11879       {
11880          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
11881                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11882          break;
11883       }
11884       else
11885       {
11886          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1Reset\n");
11887          for(idx=0; idx< encBufSize; idx++)
11888          {
11889             printf("%x",encBuf[idx]);
11890          }
11891       }
11892
11893       if(sendF1APMsg() != ROK)
11894       {
11895          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
11896          break;
11897       }
11898
11899       ret = ROK;
11900       break;
11901    }while(true);
11902
11903    FreeF1ResetReq(f1apMsg);
11904    return ret;
11905 }
11906 /*******************************************************************
11907  *
11908  * @brief Build And Send F1ResetAck
11909  *
11910  * @details
11911  *
11912  *    Function : BuildAndSendF1ResetAck
11913  *
11914  *    Functionality:
11915  *         - Build And Send  F1ResetRSP
11916  *
11917  * @return ROK     - success
11918  *         RFAILED - failure
11919  *
11920  * ****************************************************************/
11921 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
11922 {
11923    uint8_t idx;
11924    ResetAcknowledge_t *f1ResetAck;
11925
11926    if(f1apMsg)
11927    {
11928       if(f1apMsg->choice.successfulOutcome)
11929       {
11930          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
11931
11932          if(f1ResetAck->protocolIEs.list.array)
11933          {
11934             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
11935             {
11936                if(f1ResetAck->protocolIEs.list.array[idx])
11937                {
11938                   DU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
11939                }
11940             }
11941             DU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
11942          }
11943          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11944       }
11945       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11946    }
11947 }
11948
11949 /*******************************************************************
11950  *
11951  * @brief Build And Send F1ResetAck
11952  *
11953  * @details
11954  *
11955  *    Function : BuildAndSendF1ResetAck
11956  *
11957  *    Functionality:
11958  *         - Build And Send  F1ResetRSP
11959  *
11960  *  @params[in]
11961  * @return ROK     - success
11962  *         RFAILED - failure
11963  *
11964  * ****************************************************************/
11965 uint8_t BuildAndSendF1ResetAck()
11966 {
11967    uint8_t                idx = 0;
11968    uint8_t                elementCnt = 0;
11969    uint8_t                ret = RFAILED;
11970    F1AP_PDU_t             *f1apMsg = NULL;
11971    ResetAcknowledge_t     *f1ResetAck = NULLP;
11972    asn_enc_rval_t         encRetVal;
11973    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset Acknowledgment \n");
11974
11975    do{
11976       /* Allocate the memory for F1ResetRequest_t */
11977       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11978       if(f1apMsg == NULLP)
11979       {
11980          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11981          break;
11982       }
11983
11984       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
11985
11986       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11987       if(f1apMsg->choice.successfulOutcome == NULLP)
11988       {
11989          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11990          break;
11991       }
11992       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
11993       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
11994       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
11995
11996       elementCnt = 1;
11997
11998       f1ResetAck->protocolIEs.list.count = elementCnt;
11999       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
12000
12001       DU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
12002       if(f1ResetAck->protocolIEs.list.array == NULLP)
12003       {
12004          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
12005          break;
12006       }
12007
12008       for(idx=0; idx<elementCnt; idx++)
12009       {
12010          DU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
12011          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
12012          {
12013             break;
12014          }
12015       }
12016       /*TransactionID*/
12017       idx = 0;
12018       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
12019       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
12020       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
12021       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
12022
12023       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12024
12025       /* Encode the F1SetupRequest type as UPER */
12026       memset(encBuf, 0, ENC_BUF_MAX_LEN);
12027       encBufSize = 0;
12028       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
12029
12030       /* Check encode results */
12031       if(encRetVal.encoded == ENCODE_FAIL)
12032       {
12033          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
12034                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12035          break;
12036       }
12037       else
12038       {
12039          DU_LOG("\nDUBUG   -->  F1AP : Created APER encoded buffer for F1ResetAck\n");
12040          for(int i=0; i< encBufSize; i++)
12041          {
12042             printf("%x",encBuf[i]);
12043          }
12044       }
12045       /* Sending msg */
12046       if(sendF1APMsg() != ROK)
12047       {
12048          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Acknowledgement failed");
12049          break;
12050       }
12051
12052       ret = ROK;
12053       break;
12054    }while(true);
12055
12056    FreeF1ResetAck(f1apMsg);
12057    return ret;
12058 }
12059 /******************************************************************
12060 *
12061 * @brief free F1 reset msg allocated by aper_decoder
12062 *
12063 * @details
12064 *
12065 *    Function : freeAperDecodeF1ResetMsg
12066 *
12067 *    Functionality: free F1 reset msg allocated by aper_decoder
12068 *
12069 * @params[in] Reset_t *f1ResetMsg
12070 * @return void
12071 *
12072 * ****************************************************************/
12073
12074 void freeAperDecodeF1ResetMsg(Reset_t *f1ResetMsg)
12075 {
12076    uint8_t ieIdx =0;
12077    if(f1ResetMsg->protocolIEs.list.array)
12078    {
12079       for(ieIdx=0 ;ieIdx < f1ResetMsg->protocolIEs.list.count ; ieIdx++)
12080       {
12081          if(f1ResetMsg->protocolIEs.list.array[ieIdx])
12082          {
12083             free(f1ResetMsg->protocolIEs.list.array[ieIdx]);
12084          }
12085       }
12086       free(f1ResetMsg->protocolIEs.list.array);
12087    }
12088 }
12089
12090 /******************************************************************
12091  *
12092  * @brief Processes DL RRC Message Transfer  sent by CU
12093  *
12094  * @details
12095  *
12096  *    Function : procF1ResetReq
12097  *
12098  *    Functionality: Processes DL RRC Message Transfer sent by CU
12099  *
12100  * @params[in] F1AP_PDU_t ASN decoded F1AP message
12101  * @return ROK     - success
12102  *         RFAILED - failure
12103  *
12104  * ****************************************************************/
12105 uint8_t procF1ResetReq(F1AP_PDU_t *f1apMsg)
12106 {
12107    /* we are currently not supporting Ue release. right now we are supporting only init case of fireset */
12108    uint8_t       ieIdx = 0;
12109    uint8_t        ret = ROK;
12110    Reset_t       *f1ResetMsg = NULLP;
12111
12112    DU_LOG("\nINFO   -->  Processing F1 reset request");
12113    f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
12114
12115    for(ieIdx=0; ieIdx<f1ResetMsg->protocolIEs.list.count; ieIdx++)
12116    {
12117       switch(f1ResetMsg->protocolIEs.list.array[ieIdx]->id)
12118       {
12119          case ProtocolIE_ID_id_TransactionID:
12120             break;
12121
12122          case ProtocolIE_ID_id_Cause:
12123             break;
12124
12125          case ProtocolIE_ID_id_ResetType:
12126             {
12127                break;
12128             }
12129
12130          default:
12131             break;
12132       }
12133    }
12134    ret = BuildAndSendF1ResetAck();
12135    DU_LOG("\nINFO   -->  UE release is not supported for now");
12136
12137    freeAperDecodeF1ResetMsg(f1ResetMsg);
12138
12139    return ret;
12140 }
12141
12142 /*******************************************************************
12143  *
12144  * @brief free the RRC delivery report
12145  *
12146  * @details
12147  *
12148  *    Function : freeRrcDeliveryReport
12149  *
12150  *    Functionality: free the RRC delivery report
12151  *
12152  * @params[in]
12153  * @return ROK     - success
12154  *         RFAILED - failure
12155  *
12156  * ****************************************************************/
12157 void freeRrcDeliveryReport(F1AP_PDU_t  *f1apMsg )
12158 {
12159    uint8_t idx=0;
12160    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
12161
12162    if(f1apMsg)
12163    {
12164       if(f1apMsg->choice.initiatingMessage)
12165       {
12166          rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
12167          if(rrcDeliveryReport->protocolIEs.list.array)
12168          {
12169             for(idx =0 ;idx <rrcDeliveryReport->protocolIEs.list.count ;
12170                   idx++)
12171             {
12172                if(rrcDeliveryReport->protocolIEs.list.array[idx])
12173                {
12174                   DU_FREE(rrcDeliveryReport->protocolIEs.list.array[idx],
12175                         sizeof(RRCDeliveryReportIEs_t));
12176                }
12177             }
12178             DU_FREE(rrcDeliveryReport->protocolIEs.list.array,
12179                   rrcDeliveryReport->protocolIEs.list.size);
12180          }
12181          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
12182       }
12183       DU_FREE(f1apMsg,
12184             sizeof(F1AP_PDU_t));
12185    }
12186 }
12187
12188 /*******************************************************************
12189 *
12190 * @brief Builds and sends the RRC delivery report
12191 *
12192 * @details
12193 *
12194 *    Function : BuildAndSendRrcDeliveryReport
12195 *
12196 *    Functionality: Builds and sends the RRC delivery report
12197 *
12198 * @params[in]
12199 *
12200 * @return ROK     - success
12201 *         RFAILED - failure
12202 *
12203 * ****************************************************************/
12204 uint8_t BuildAndSendRrcDeliveryReport(uint32_t gnbCuUeF1apId, \
12205    uint32_t gnbDuUeF1apId, RrcDeliveryReport *rrcDelivery)
12206 {
12207    uint8_t             ret = RFAILED;
12208    uint8_t             idx    = 0;
12209    uint8_t             idx1   = 0;
12210    uint8_t             elementCnt = 0;
12211    F1AP_PDU_t          *f1apMsg = NULLP;
12212    asn_enc_rval_t      encRetVal;
12213    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
12214
12215    do{
12216
12217       DU_LOG("\nINFO   -->  F1AP : Building RRC delivery Message Transfer Message\n");
12218       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12219       if(f1apMsg == NULLP)
12220       {
12221          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
12222          break;
12223       }
12224       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
12225       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
12226       if(f1apMsg->choice.initiatingMessage == NULLP)
12227       {
12228          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU  failed");
12229          break;
12230       }
12231       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_RRCDeliveryReport;
12232       f1apMsg->choice.initiatingMessage->criticality   = Criticality_ignore;
12233       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RRCDeliveryReport;
12234
12235       rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
12236       elementCnt = 4;
12237       rrcDeliveryReport->protocolIEs.list.count = elementCnt;
12238       rrcDeliveryReport->protocolIEs.list.size = elementCnt * sizeof(RRCDeliveryReportIEs_t *);
12239
12240       /* Initialize the F1Setup members */
12241       DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array, rrcDeliveryReport->protocolIEs.list.size);
12242       if(rrcDeliveryReport->protocolIEs.list.array == NULLP)
12243       {
12244          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRC Delivery  failed");
12245          break;
12246       }
12247       for(idx =0 ;idx <elementCnt; idx++)
12248       {
12249          DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array[idx], sizeof(RRCDeliveryReportIEs_t));
12250          if(rrcDeliveryReport->protocolIEs.list.array[idx] == NULLP)
12251          {
12252             break;
12253          }
12254       }
12255
12256       idx1 = 0;
12257
12258       /*GNB CU UE F1AP ID*/
12259       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
12260       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
12261       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_CU_UE_F1AP_ID;
12262       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
12263
12264       /*GNB DU UE F1AP ID*/
12265       idx1++;
12266       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
12267       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
12268       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_DU_UE_F1AP_ID;
12269       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
12270
12271       /*RRC delivery status*/
12272       idx1++;
12273       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_RRCDeliveryStatus;
12274       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
12275       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_RRCDeliveryStatus;
12276       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.delivery_status =\
12277       rrcDelivery->rrcDeliveryStatus.deliveryStatus;
12278       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.triggering_message =\
12279       rrcDelivery->rrcDeliveryStatus.triggeringMessage;
12280
12281       /* SRB ID */
12282       idx1++;
12283       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
12284       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
12285       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_SRBID;
12286       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.SRBID =  rrcDelivery->srbId;
12287
12288       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12289
12290       /* Encode the RRC DELIVERY REPORT type as APER */
12291       memset(encBuf, 0, ENC_BUF_MAX_LEN);
12292       encBufSize = 0;
12293       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
12294             encBuf);
12295
12296       /* Encode results */
12297       if(encRetVal.encoded == ENCODE_FAIL)
12298       {
12299          DU_LOG("\nERROR  -->  F1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
12300                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12301          break;
12302       }
12303       else
12304       {
12305          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for RRC Delivery Msg \n");
12306          for(idx=0; idx< encBufSize; idx++)
12307          {
12308             printf("%x",encBuf[idx]);
12309          }
12310       }
12311
12312       /* Sending msg */
12313       if(sendF1APMsg() != ROK)
12314       {
12315          DU_LOG("\nERROR  -->  F1AP : Sending RRC delivery  msg request failed");
12316          break;
12317       }
12318       ret = ROK;
12319       break;
12320
12321    }while(true);
12322
12323    freeRrcDeliveryReport(f1apMsg);
12324    return ret;
12325 }
12326
12327 /*******************************************************************
12328  *
12329  * @brief Processes cells to be activated
12330  *
12331  * @details
12332  *
12333  *    Function : extractCellsToBeActivated
12334  *
12335  *    Functionality:
12336  *      - Processes cells to be activated list received in F1SetupRsp
12337  *
12338  * @params[in] void
12339  * @return ROK     - success
12340  *         RFAILED - failure
12341  *
12342  * ****************************************************************/
12343
12344 uint8_t extractCellsToBeActivated(Cells_to_be_Activated_List_t cellsToActivate)
12345 {
12346    uint8_t  ret = ROK;
12347    uint16_t idx, nci, pci = 0;
12348    Cells_to_be_Activated_List_Item_t cell;
12349
12350    for(idx=0; idx<cellsToActivate.list.count; idx++)
12351    {
12352       nci = 0;
12353       cell = cellsToActivate.list.array[idx]->value.choice.Cells_to_be_Activated_List_Item;
12354       bitStringToInt(&cell.nRCGI.nRCellIdentity, &nci);
12355
12356       if(cell.nRPCI)
12357       {
12358          pci = *cell.nRPCI;
12359       }
12360       ret = duProcCellsToBeActivated(cell.nRCGI.pLMN_Identity.buf, nci, pci);
12361    }
12362    return ret;
12363 }
12364 /******************************************************************
12365 *
12366 * @brief Processes F1 Setup Response allocated by aper_decoder
12367 *
12368 * @details
12369 *
12370 *    Function : freeF1SetupRsp
12371 *
12372 *    Functionality: free F1 Setup Response allocated by aper_decoder
12373 *
12374 * @params[in] F1SetupResponse_t *f1SetRspMsg
12375 * @return void
12376 *
12377 * ****************************************************************/
12378
12379 void freeAperDecodeF1SetupRsp(F1SetupResponse_t *f1SetRspMsg)
12380 {
12381    uint8_t ieIdx =0;
12382    uint8_t arrIdx =0;
12383    Cells_to_be_Activated_List_t *cellToActivate =NULLP;
12384    RRC_Version_t      *rrcVer =NULLP;
12385
12386    if(f1SetRspMsg->protocolIEs.list.array)
12387    {
12388       for(ieIdx=0; ieIdx<f1SetRspMsg->protocolIEs.list.count; ieIdx++)
12389       {
12390          if(f1SetRspMsg->protocolIEs.list.array[ieIdx])
12391          {
12392             switch(f1SetRspMsg->protocolIEs.list.array[ieIdx]->id)
12393             {
12394                case ProtocolIE_ID_id_Cells_to_be_Activated_List:
12395                   {
12396                      cellToActivate =
12397                         &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.Cells_to_be_Activated_List;
12398                      if(cellToActivate->list.array)
12399                      {
12400                         for(arrIdx=0; arrIdx<cellToActivate->list.count ; arrIdx++)
12401                         {
12402                            if(cellToActivate->list.array[arrIdx])
12403                            {
12404
12405                               if(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.\
12406                               pLMN_Identity.buf)
12407                               {
12408                                  if(cellToActivate->list.array[0]->value.choice.\
12409                                        Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf)
12410                                  {
12411                                     free(cellToActivate->list.array[0]->value.choice.\
12412                                           Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf);
12413                                  }
12414
12415                                  free(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
12416                                        nRCGI.pLMN_Identity.buf);
12417                               }
12418                               free(cellToActivate->list.array[arrIdx]);
12419                            }
12420                         }
12421                         free(cellToActivate->list.array);
12422                      }
12423                      break;
12424                   }
12425                case ProtocolIE_ID_id_TransactionID:
12426                   {
12427                      break;
12428                   }
12429                case ProtocolIE_ID_id_gNB_CU_Name:
12430                   {
12431                      free(f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_Name.buf);
12432                      break;
12433                   }
12434                case ProtocolIE_ID_id_GNB_CU_RRC_Version:
12435                   {
12436                      rrcVer = &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
12437                      if(rrcVer->latest_RRC_Version.buf)
12438                      {
12439                         if(rrcVer->iE_Extensions)
12440                         {
12441                            if(rrcVer->iE_Extensions->list.array)
12442                            {
12443                               if(rrcVer->iE_Extensions->list.array[0])
12444                               {
12445                                  if(rrcVer->iE_Extensions->list.\
12446                                        array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf)
12447                                  {
12448                                     free(rrcVer->iE_Extensions->list.\
12449                                           array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf);
12450                                  }
12451                                  free(rrcVer->iE_Extensions->list.array[0]);
12452                               }
12453                               free(rrcVer->iE_Extensions->list.array);
12454                            }
12455                            free(rrcVer->iE_Extensions);
12456                         }
12457                         free(rrcVer->latest_RRC_Version.buf);
12458                      }
12459                      break;
12460
12461                   }
12462                default:
12463                   {
12464                      DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
12465                            f1SetRspMsg->protocolIEs.list.array[ieIdx]->id);
12466                   }
12467             }
12468             free(f1SetRspMsg->protocolIEs.list.array[ieIdx]);
12469          }
12470       }
12471       free(f1SetRspMsg->protocolIEs.list.array);
12472    }
12473 }
12474 /******************************************************************
12475  *
12476  * @brief Processes F1 Setup Response sent by CU
12477  *
12478  * @details
12479  *
12480  *    Function : procF1SetupRsp
12481  *
12482  *    Functionality: Processes F1 Setup Response sent by CU
12483  *
12484  * @params[in] F1AP_PDU_t ASN decoded F1AP message
12485  * @return ROK     - success
12486  *         RFAILED - failure
12487  *
12488  * ****************************************************************/
12489 uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg, MsgLen recvBufLen, char *recvBuf)
12490 {
12491    uint8_t ret = ROK;
12492    uint16_t idx =0;
12493    F1SetupResponse_t *f1SetRspMsg = NULLP;
12494    GNB_CU_Name_t     *cuName = NULLP;
12495    F1SetupRsp  f1SetRspDb;
12496    RRC_Version_t      *rrcVer =NULLP;
12497
12498    memset(&f1SetRspDb, 0, sizeof(F1SetupRsp));
12499
12500    DU_LOG("\nINFO   -->  F1AP : F1 Setup Response received");
12501    f1SetRspMsg = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
12502
12503    for(idx=0; idx<f1SetRspMsg->protocolIEs.list.count; idx++)
12504    {
12505       switch(f1SetRspMsg->protocolIEs.list.array[idx]->id)
12506       {
12507          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
12508             {
12509                extractCellsToBeActivated(f1SetRspMsg->protocolIEs.list.array[idx]->\
12510                      value.choice.Cells_to_be_Activated_List);
12511                break;
12512             }
12513          case ProtocolIE_ID_id_TransactionID:
12514             {
12515                f1SetRspDb.transId = f1SetRspMsg->protocolIEs.list.array[idx]->\
12516                                     value.choice.TransactionID;
12517                break;
12518             }
12519          case ProtocolIE_ID_id_gNB_CU_Name:
12520             {
12521                cuName = &f1SetRspMsg->protocolIEs.list.array[idx]->\
12522                         value.choice.GNB_CU_Name;
12523                strcpy(f1SetRspDb.cuName, (const char*)cuName->buf);
12524                break;
12525             }
12526          case ProtocolIE_ID_id_GNB_CU_RRC_Version:
12527             {
12528                rrcVer = &f1SetRspMsg->protocolIEs.list.array[idx]->value.choice.RRC_Version;
12529                strcpy(f1SetRspDb.rrcVersion.rrcVer,
12530                      (const char*)rrcVer->latest_RRC_Version.buf);
12531                break;
12532             }
12533          default:
12534             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
12535                   f1SetRspMsg->protocolIEs.list.array[idx]->id);
12536       }
12537       duProcF1SetupRsp();
12538    }
12539
12540    freeAperDecodeF1SetupRsp(f1SetRspMsg);
12541
12542    duCb.f1SetupReqAndRspMsg.f1MsgRspBufSize = recvBufLen;
12543    DU_ALLOC(duCb.f1SetupReqAndRspMsg.f1MsgRspBuf, duCb.f1SetupReqAndRspMsg.f1MsgRspBufSize);
12544    if(duCb.f1SetupReqAndRspMsg.f1MsgReqBuf == NULLP)
12545    {
12546       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed to store the buf of F1setup response");
12547       return RFAILED;
12548    }
12549    memcpy(duCb.f1SetupReqAndRspMsg.f1MsgRspBuf, recvBuf, recvBufLen);
12550
12551    if(BuildAndSendE2SetupReq() != ROK)
12552    {
12553       DU_LOG("\nERROR  -->  F1AP : Failed to build and send E2 setup request ");
12554       return RFAILED;
12555    }
12556    return ret;
12557 }
12558 /*******************************************************************
12559 *
12560 * @brief free GNB DU config update ack
12561 *
12562 * @details
12563 *
12564 *    Function : freeAperDecodeGnbDuAck
12565 *
12566 *    Functionality: Processes GNB DU config update ack And
12567 *                     added free part for the memory allocated by aper_decoder
12568 *
12569 * @params[in] F1AP_PDU_t ASN decoded F1AP message
12570 * @return ROK     - success
12571 *         RFAILED - failure
12572 *
12573 * ****************************************************************/
12574
12575 void freeAperDecodeGnbDuAck(GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck)
12576 {
12577    uint8_t ieIdx = 0;
12578
12579    if(gnbDuAck->protocolIEs.list.array)
12580    {
12581       for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
12582       {
12583          if(gnbDuAck->protocolIEs.list.array[ieIdx])
12584          {
12585             free(gnbDuAck->protocolIEs.list.array[ieIdx]);
12586          }
12587       }
12588       free(gnbDuAck->protocolIEs.list.array);
12589    }
12590 }
12591
12592 /*******************************************************************
12593 *
12594 * @brief Building  result of gnb-du config update ack output
12595 *
12596 * @details
12597 *
12598 *    Function : duProcGnbDuCfgUpdAckMsg
12599 *
12600 *    Functionality:
12601 *        Building output of gnb-du config update ack
12602 *
12603 * @params[in] transId
12604 * @return void
12605 *
12606 * ****************************************************************/
12607
12608 uint8_t duProcGnbDuCfgUpdAckMsg(uint8_t transId)
12609 {
12610    uint8_t  ieIdx=0, arrIdx=0,ret=ROK;
12611    uint8_t  ueId =0 , ueIdx =0, totalActiveUe = 0;
12612    uint16_t cellId =0, cellIdx =0, crnti=0;
12613    CmLList *f1apPduNode = NULLP;
12614    ReservedF1apPduInfo *f1apPduInfo =NULLP;
12615    F1AP_PDU_t *f1apMsgPdu = NULLP;
12616    GNBDUConfigurationUpdate_t *gnbDuConfigUpdate = NULLP;
12617    BIT_STRING_t *cellIdentity=NULLP;
12618    struct Served_Cells_To_Delete_ItemIEs *deleteItemIe=NULLP;
12619    Served_Cells_To_Delete_List_t *cellsToDelete=NULLP;
12620    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
12621
12622    DU_LOG("\nINFO   -->  DU APP: GNB-DU config update Ack received ");
12623    f1apPduNode = searchFromReservedF1apPduList(transId);
12624    f1apPduInfo = (ReservedF1apPduInfo *)f1apPduNode->node;
12625    f1apMsgPdu = (F1AP_PDU_t *)f1apPduInfo->f1apMsg;
12626
12627    if(f1apMsgPdu)
12628    {
12629       if(f1apMsgPdu->choice.initiatingMessage)
12630       {
12631          gnbDuConfigUpdate = &f1apMsgPdu->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
12632          for(ieIdx=0; ieIdx < gnbDuConfigUpdate->protocolIEs.list.count; ieIdx++)
12633          {
12634             switch(gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->id)
12635             {
12636                case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
12637                   {
12638                      cellsToDelete = &gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
12639                                      Served_Cells_To_Delete_List;
12640                      if(cellsToDelete->list.array)
12641                      {
12642                         if(cellsToDelete->list.array[arrIdx])
12643                         {
12644                            deleteItemIe = (Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx];
12645                            deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
12646                            if(deleteItem->oldNRCGI.nRCellIdentity.buf)
12647                            {
12648                               cellIdentity = &deleteItem->oldNRCGI.nRCellIdentity;
12649                               bitStringToInt(cellIdentity, &cellId);
12650                            }
12651                         }
12652                      }
12653
12654                      GET_CELL_IDX(cellId, cellIdx);
12655                      if(duCb.actvCellLst[cellIdx] != NULLP)
12656                      {
12657                         if(duCb.actvCellLst[cellIdx]->numActvUes == 0)
12658                         {
12659                            duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
12660                            ret = duSendCellDeletReq(cellId);
12661                            if(ret == RFAILED)
12662                            {
12663                               DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to send cell delete\
12664                               request for cellId[%d]", cellId);
12665                            }
12666                         }
12667                         else
12668                         {
12669                            totalActiveUe = duCb.actvCellLst[cellIdx]->numActvUes;
12670                            while(totalActiveUe)
12671                            {
12672                               if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].ueState != UE_ACTIVE)
12673                               {
12674                                  ueIdx++;
12675                                  continue;
12676                               }
12677
12678                               crnti = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].crnti;
12679                               GET_UE_ID(crnti,ueId);
12680                               /* Sending Ue Context release request only for maximum supporting UEs */
12681                               ret = BuildAndSendUeContextReleaseReq(cellId, ueId);
12682                               if(ret == RFAILED)
12683                               {
12684                                  DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to build and send UE delete\
12685                                  request for cellId[%d]", cellId);
12686                               }
12687                               ueIdx++;
12688                               totalActiveUe--;
12689                            }
12690                         }
12691                      }
12692                      else
12693                      {
12694                         DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): CellId [%d] not found", cellId);
12695                         ret = RFAILED;
12696                      }
12697                      break;
12698                   }
12699
12700                default:
12701                   break;
12702             }
12703          }
12704       }
12705    }
12706
12707    FreeDUConfigUpdate(f1apMsgPdu);
12708    deleteFromReservedF1apPduList(f1apPduNode);
12709    return ret;
12710 }
12711
12712 /*******************************************************************
12713 *
12714 * @brief Processes GNB DU config update ack
12715 *
12716 * @details
12717 *
12718 *    Function : procF1GNBDUCfgUpdAck
12719 *
12720 *    Functionality: added free part for the memory allocated by aper_decoder
12721 *
12722 * @params[in] F1AP_PDU_t *f1apMsg
12723 * @return void
12724 *
12725 * ****************************************************************/
12726 uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
12727 {
12728    uint8_t ieIdx=0,transId=0;
12729    GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
12730
12731    DU_LOG("\nINFO   -->  F1AP : GNB-DU config update acknowledgment");
12732    gnbDuAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
12733
12734    for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
12735    {
12736       switch(gnbDuAck->protocolIEs.list.array[ieIdx]->id)
12737       {
12738          case ProtocolIE_ID_id_TransactionID:
12739             {
12740                transId = gnbDuAck->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
12741                break;
12742             }
12743          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
12744             {
12745                break;
12746             }
12747          default :
12748             {
12749                DU_LOG("\nERROR  -->  F1AP: procF1GNBDUCfgUpdAck(): Invalid IE Received: %ld", \
12750                      gnbDuAck->protocolIEs.list.array[ieIdx]->id);
12751                break;
12752             }
12753       }
12754    }
12755
12756    duProcGnbDuCfgUpdAckMsg(transId);
12757
12758 #if 0
12759    /* presently we are not supporting F1 Reset from DU to CU , we are only
12760     * supporting F1 Reset from CU to DU */
12761
12762    if(BuildAndSendF1ResetReq() != ROK)
12763    {
12764       return RFAILED;
12765    }
12766 #endif
12767
12768    freeAperDecodeGnbDuAck(gnbDuAck);
12769    return ROK;
12770 }
12771 /******************************************************************
12772 *
12773 * @brief free DL RRC Message Transfer allocated by aper_decoder
12774 *
12775 * @details
12776 *
12777 *    Function : freeAperDecodef1DlRrcMsg
12778 *
12779 *    Functionality: free DL RRC Message Transfer allocated by aper_decoder
12780 *
12781 * @params[in] DLRRCMessageTransfer_t *f1DlRrcMsg
12782 * @return ROK     - success
12783 *         RFAILED - failure
12784 *
12785 * ****************************************************************/
12786
12787 void freeAperDecodef1DlRrcMsg(DLRRCMessageTransfer_t *f1DlRrcMsg)
12788 {
12789    uint8_t ieIdx =0;
12790    RRCContainer_t *rrcContainer = NULLP;
12791
12792    if(f1DlRrcMsg->protocolIEs.list.array)
12793    {
12794       for(ieIdx=0; ieIdx<f1DlRrcMsg->protocolIEs.list.count; ieIdx++)
12795       {
12796          if(f1DlRrcMsg->protocolIEs.list.array[ieIdx])
12797          {
12798             switch(f1DlRrcMsg->protocolIEs.list.array[ieIdx]->id)
12799             {
12800                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12801                   break;
12802                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12803                   break;
12804                case ProtocolIE_ID_id_SRBID:
12805                   break;
12806                case ProtocolIE_ID_id_RRCContainer:
12807                   {
12808                      rrcContainer =&f1DlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
12809                      free(rrcContainer->buf);
12810                   }
12811                case ProtocolIE_ID_id_ExecuteDuplication:
12812                   break;
12813                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
12814                   break;
12815                   break;
12816             }
12817             free(f1DlRrcMsg->protocolIEs.list.array[ieIdx]);
12818          }
12819       }
12820       free(f1DlRrcMsg->protocolIEs.list.array);
12821    }
12822 }
12823 /******************************************************************
12824  *
12825  * @brief Processes DL RRC Message Transfer  sent by CU
12826  *
12827  * @details
12828  *
12829  *    Function : procF1DlRrcMsgTrans
12830  *
12831  *    Functionality: Processes DL RRC Message Transfer sent by CU
12832  *
12833  * @params[in] F1AP_PDU_t ASN decoded F1AP message
12834  * @return ROK     - success
12835  *         RFAILED - failure
12836  *
12837  * ****************************************************************/
12838 uint8_t procF1DlRrcMsgTrans(F1AP_PDU_t *f1apMsg)
12839 {
12840    uint8_t  idx, ret;
12841    DLRRCMessageTransfer_t *f1DlRrcMsg = NULLP;
12842    F1DlRrcMsg dlMsg;
12843    memset(&dlMsg, 0, sizeof(F1DlRrcMsg));
12844
12845    DU_LOG("\nINFO   -->  DU_APP : DL RRC message transfer Recevied");
12846    f1DlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
12847
12848    ret = ROK;
12849
12850    for(idx=0; idx<f1DlRrcMsg->protocolIEs.list.count; idx++)
12851    {
12852       switch(f1DlRrcMsg->protocolIEs.list.array[idx]->id)
12853       {
12854          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12855             {
12856                dlMsg.gnbCuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
12857                break;
12858             }
12859          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12860             {
12861                dlMsg.gnbDuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
12862                break;
12863             }
12864          case ProtocolIE_ID_id_SRBID:
12865             {
12866                dlMsg.srbId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
12867                break;
12868             }
12869          case ProtocolIE_ID_id_ExecuteDuplication:
12870             dlMsg.execDup = true;
12871             break;
12872
12873          case ProtocolIE_ID_id_RRCContainer:
12874             {
12875                if(f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0)
12876                {
12877                   dlMsg.rrcMsgSize = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
12878                   DU_ALLOC_SHRABL_BUF(dlMsg.rrcMsgPdu, dlMsg.rrcMsgSize);
12879                   if(dlMsg.rrcMsgPdu)
12880                   {
12881                      memcpy(dlMsg.rrcMsgPdu, f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
12882                         dlMsg.rrcMsgSize);
12883                   }
12884                   else
12885                   {
12886                      DU_LOG("\nERROR  -->  DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
12887                      return RFAILED;
12888                   }
12889                }
12890                else
12891                {
12892                   DU_LOG("\nERROR  -->  DU_APP : RRC Container Size is invalid:%ld",\
12893                   f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
12894                   return RFAILED;
12895                }
12896                break;
12897             }
12898          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
12899             {
12900                dlMsg.deliveryStatRpt = true;
12901                break;
12902             }
12903          default:
12904             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
12905                   f1DlRrcMsg->protocolIEs.list.array[idx]->id);
12906       }
12907    }
12908
12909    ret = duProcDlRrcMsg(&dlMsg);
12910
12911    freeAperDecodef1DlRrcMsg(f1DlRrcMsg);
12912    return ret;
12913 }
12914 /*******************************************************************
12915  *
12916 * @brief Builds the DRB to be Setup Mod list
12917 *
12918 * @details
12919 *
12920 *    Function :
12921 *
12922 *    Functionality: Constructs the DRB to be Setup Mod list
12923 *
12924 * @params[in] DRBs_SetupMod_List_t *drbSet
12925 *
12926 * @return ROK     - success
12927 *         RFAILED - failure
12928 *
12929 * ****************************************************************/
12930
12931 uint8_t BuildDrbSetupModList(DRBs_SetupMod_List_t *drbSet , DuUeCfg *ueCfg)
12932 {
12933    uint8_t arrIdx =0;
12934    uint8_t drbCnt =0;
12935    struct DRBs_SetupMod_ItemIEs *drbItemIe;
12936
12937    drbCnt = ueCfg->numDrbSetupMod;
12938    drbSet->list.count = drbCnt;
12939    drbSet->list.size = drbCnt * sizeof(DRBs_SetupMod_ItemIEs_t *);
12940    DU_ALLOC(drbSet->list.array, drbSet->list.size);
12941    if(drbSet->list.array == NULLP)
12942    {
12943       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
12944       return  RFAILED;
12945    }
12946    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
12947    {
12948       DU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
12949       if(drbSet->list.array[arrIdx] == NULLP)
12950       {
12951               DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
12952               return  RFAILED;
12953       }
12954
12955       drbItemIe = (struct DRBs_SetupMod_ItemIEs *)drbSet->list.array[arrIdx];
12956       drbItemIe->id = ProtocolIE_ID_id_DRBs_SetupMod_Item;
12957       drbItemIe->criticality = Criticality_reject;
12958       drbItemIe->value.present = DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item;
12959       drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
12960       if(fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List,\
12961       &ueCfg->upTnlInfo[arrIdx])!= ROK)
12962       {
12963          DU_LOG("\nERROR  -->  F1AP : Failed to fill DlTnl SetupList in BuildDrbToBeSetupModList");
12964          return RFAILED;
12965       }
12966
12967    }
12968
12969    return ROK;
12970 }
12971 /*******************************************************************
12972 * @brief Free the memory allocated for DRB setup List
12973 *
12974 * @details
12975 *
12976 *    Function : FreeDrbSetupModList
12977 *
12978 *    Functionality:
12979 *       Free the memory allocated for DRB setup list
12980 *
12981 * @params[in] DRBs_Setup_List_t *
12982 * @return void
12983 *
12984 * ****************************************************************/
12985 void FreeDrbSetupModList(DRBs_SetupMod_List_t *drbSetupList)
12986 {
12987    uint8_t arrIdx = 0;
12988    DRBs_SetupMod_ItemIEs_t *drbItemIe = NULLP;
12989
12990    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
12991    {
12992       drbItemIe = ((DRBs_SetupMod_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
12993       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
12994       DU_FREE(drbSetupList->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
12995    }
12996    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
12997 }
12998 /*******************************************************************
12999 * @brief Free the memory allocated for UE Context Mod Response
13000 *
13001 * @details
13002 *
13003 *    Function : FreeUeContextModResp
13004 *
13005 *    Functionality:
13006 *       Free the memory allocated for UE Context Mod Response
13007 *
13008 * @params[in] F1AP_PDU_t *f1apMsg
13009 * @return void
13010 *
13011 * ****************************************************************/
13012
13013 void FreeUeContextModResp(F1AP_PDU_t *f1apMsg)
13014 {
13015    uint8_t ieIdx;
13016    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
13017    if(f1apMsg)
13018    {
13019       if(f1apMsg->choice.successfulOutcome)
13020       {
13021          ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
13022          if(ueContextModifyRes->protocolIEs.list.array)
13023          {
13024             for(ieIdx=0 ; ieIdx<ueContextModifyRes->protocolIEs.list.count; ieIdx++)
13025             {
13026                if(ueContextModifyRes->protocolIEs.list.array[ieIdx])
13027                {
13028                   switch(ueContextModifyRes->protocolIEs.list.array[ieIdx]->id)
13029                   {
13030                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13031                         break;
13032                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13033                         break;
13034                      case ProtocolIE_ID_id_DRBs_SetupMod_List:
13035                         {
13036                             FreeDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
13037                             value.choice.DRBs_SetupMod_List));
13038                             break;
13039                         }
13040                   }
13041                   DU_FREE(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
13042                }
13043
13044             }
13045             DU_FREE(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
13046          }
13047          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
13048       }
13049       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
13050    }
13051 }
13052
13053 /*****************************************************************i
13054 *
13055 * @brief Creating the ue context modifcation response and sending
13056 *
13057 * @details
13058 *
13059 *    Function : BuildAndSendUeContextModRsp
13060 *
13061 *    Functionality:
13062 *         - Creating the ue context modifcation response
13063 *
13064 * @params[in] uint8_t cellId,uint8_t ueId
13065 * @return ROK     - success
13066 *         RFAILED - failure
13067 *
13068 * ****************************************************************/
13069 uint8_t BuildAndSendUeContextModRsp(uint8_t cellId,uint8_t ueId)
13070 {
13071    uint8_t   ieIdx = 0;
13072    uint8_t   cellIdx =0;
13073    uint8_t   elementCnt = 0;
13074    uint8_t   ret = RFAILED;
13075    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
13076    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
13077    F1AP_PDU_t *f1apMsg = NULLP;
13078    asn_enc_rval_t         encRetVal;
13079    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
13080    DuUeCb                   *ueCb = NULLP;
13081
13082    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification response\n");
13083
13084    while(1)
13085    {
13086       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
13087       if(f1apMsg == NULLP)
13088       {
13089          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
13090          break;
13091       }
13092
13093       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
13094
13095       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
13096       if(f1apMsg->choice.successfulOutcome == NULLP)
13097       {
13098          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
13099          break;
13100       }
13101       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextModification;
13102       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
13103       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_UEContextModificationResponse;
13104
13105       ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
13106
13107       elementCnt = 3;
13108       ueContextModifyRes->protocolIEs.list.count = elementCnt;
13109       ueContextModifyRes->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationResponse_t*);
13110
13111       /* Initialize the UE context modification members */
13112       DU_ALLOC(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
13113       if(ueContextModifyRes->protocolIEs.list.array == NULLP)
13114       {
13115          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
13116          break;
13117       }
13118
13119       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
13120       {
13121          DU_ALLOC(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
13122          if(ueContextModifyRes->protocolIEs.list.array[ieIdx] == NULLP)
13123          {
13124             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
13125             break;
13126          }
13127       }
13128
13129       /* Fetching Ue Cb Info*/
13130       GET_CELL_IDX(cellId, cellIdx);
13131       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbDuUeF1apId;
13132       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbCuUeF1apId;
13133       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueId-1];
13134
13135       ieIdx=0;
13136       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
13137       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
13138       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
13139       UEContextModificationResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
13140       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
13141
13142       ieIdx++;
13143       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
13144       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
13145       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present=\
13146       UEContextModificationResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
13147       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
13148
13149       ieIdx++;
13150       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_SetupMod_List;
13151       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
13152       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
13153       UEContextModificationResponseIEs__value_PR_DRBs_SetupMod_List;
13154       if(ueCb->f1UeDb)
13155       {
13156          ret = BuildDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
13157                   value.choice.DRBs_SetupMod_List) , &ueCb->f1UeDb->duUeCfg);
13158          if(ret != ROK)
13159          {
13160             DU_LOG( "\nERROR  -->  F1AP : Failed to build drb setupmod List ");
13161             break;
13162          }
13163          freeF1UeDb(ueCb->f1UeDb);
13164          ueCb->f1UeDb = NULLP;
13165       }
13166       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13167
13168       /* Encode the F1SetupRequest type as APER */
13169       memset(encBuf, 0, ENC_BUF_MAX_LEN);
13170       encBufSize = 0;
13171       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,encBuf);
13172
13173       /* Encode results */
13174       if(encRetVal.encoded == ENCODE_FAIL)
13175       {
13176          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
13177                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13178          ret = RFAILED;
13179          break;
13180       }
13181       else
13182       {
13183          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Modification Response\n");
13184          for(int i=0; i< encBufSize; i++)
13185          {
13186             printf("%x",encBuf[i]);
13187          }
13188       }
13189
13190       /* Sending  msg  */
13191       if(sendF1APMsg() != ROK)
13192       {
13193          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Res Failed");
13194          ret = RFAILED;
13195          break;
13196       }
13197       break;
13198    }
13199    FreeUeContextModResp(f1apMsg);
13200    return ret;
13201 }
13202 /*******************************************************************
13203  *
13204  * @brief Deallocating the memory allocated by the aper decoder
13205  *          for QOSInfo
13206  *
13207  * @details
13208  *
13209  *    Function : freeAperDecodeQosInfo
13210  *
13211  *    Functionality:  Deallocating the memory allocated for QOSInfo
13212  *
13213  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
13214  *
13215  * @return void
13216  *
13217  * ****************************************************************/
13218
13219 void freeAperDecodeQosInfo(QoSFlowLevelQoSParameters_t *drbQos)
13220 {
13221    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
13222    {
13223       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
13224       {
13225          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
13226          {
13227             free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
13228          }
13229          free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
13230       }
13231       free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI);
13232    }
13233 }
13234 /*******************************************************************
13235  *
13236  * @brief Deallocating the memory allocated by the aper decoder
13237  *          for UlTnlInfoforDrb
13238  *
13239  * @details
13240  *
13241  *    Function : freeAperDecodeUlTnlInfoforDrbSetupMod
13242  *
13243  *    Functionality:  Deallocating memory allocated for UlTnlInfoforDrb
13244  *
13245  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
13246  *
13247  * @return void
13248  *
13249  * ****************************************************************/
13250 void freeAperDecodeUlTnlInfoforDrbSetupMod(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
13251 {
13252    uint8_t arrIdx =0;
13253
13254    if(ulInfo->list.array)
13255    {
13256       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
13257       {
13258          if(ulInfo->list.array[arrIdx])
13259          {
13260             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
13261             {
13262                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
13263                {
13264                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
13265                   {
13266                      free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
13267                            gTP_TEID.buf);
13268                   }
13269                   free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
13270                         transportLayerAddress.buf);
13271                }
13272                free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel);
13273             }
13274             free(ulInfo->list.array[arrIdx]);
13275          }
13276       }
13277       free(ulInfo->list.array);
13278    }
13279 }
13280 /*******************************************************************
13281  *
13282  * @brief Deallocating the memory allocated by the aper decoder
13283  *          for DrbSetupModItem
13284  *
13285  * @details
13286  *
13287  *    Function : freeAperDecodeDrbSetupModItem
13288  *
13289  *    Functionality:  Deallocating memory allocated for DrbSetupModItem
13290  *
13291  * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
13292  *
13293  * @return void
13294  *
13295  * ****************************************************************/
13296
13297 void freeAperDecodeDrbSetupModItem(DRBs_ToBeSetupMod_Item_t *drbItem)
13298 {
13299    uint8_t arrIdx =0;
13300    SNSSAI_t *snssai =NULLP;
13301    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
13302
13303    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
13304    switch(drbItem->qoSInformation.present)
13305    {
13306       case QoSInformation_PR_NOTHING:
13307          break;
13308       case QoSInformation_PR_eUTRANQoS:
13309          {
13310             if(drbItem->qoSInformation.choice.eUTRANQoS)
13311             {
13312                free(drbItem->qoSInformation.choice.eUTRANQoS);
13313             }
13314             break;
13315          }
13316       case QoSInformation_PR_choice_extension:
13317          {
13318             if(drbItem->qoSInformation.choice.choice_extension)
13319             {
13320                freeAperDecodeQosInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.\
13321                      DRB_Information.dRB_QoS);
13322                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
13323                if(snssai->sST.buf)
13324                {
13325                   free(snssai->sST.buf);
13326                }
13327                if(snssai->sD)
13328                {
13329                   if(snssai->sD->buf)
13330                   {
13331                      free(snssai->sD->buf);
13332                   }
13333                   free(snssai->sD);
13334                }
13335
13336                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.\
13337                          DRB_Information.flows_Mapped_To_DRB_List;
13338                if(flowMap->list.array)
13339                {
13340                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
13341                   {
13342                      if(flowMap->list.array[arrIdx] )
13343                      {
13344                         freeAperDecodeQosInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
13345                         free(flowMap->list.array[arrIdx]);
13346                      }
13347                   }
13348                   free(flowMap->list.array);
13349                }
13350
13351                free(drbItem->qoSInformation.choice.choice_extension);
13352             }
13353             break;
13354          }
13355
13356    }
13357    freeAperDecodeUlTnlInfoforDrbSetupMod(&drbItem->uLUPTNLInformation_ToBeSetup_List);
13358    if(drbItem->uLConfiguration)
13359    {
13360       free(drbItem->uLConfiguration);
13361    }
13362 }
13363
13364 /*******************************************************************
13365  *
13366  * @brief Deallocating the memory allocated by the aper decoder
13367  *          for DrbToBeSetupModList
13368  *
13369  * @details
13370  *
13371  *    Function : freeAperDecodeDrbToBeSetupModList
13372  *
13373  *    Functionality:  Deallocating memory allocated for DrbToBeSetupModList
13374  *
13375  * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
13376  *
13377  * @return void
13378  *
13379  * ****************************************************************/
13380
13381 void freeAperDecodeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
13382 {
13383    uint8_t arrIdx =0;
13384    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
13385
13386    if(drbSet->list.array)
13387    {
13388       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
13389       {
13390          if(drbSet->list.array[arrIdx] != NULLP)
13391          {
13392             if(arrIdx == 0)
13393             {
13394                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
13395                freeAperDecodeDrbSetupModItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
13396             }
13397             free(drbSet->list.array[arrIdx]);
13398          }
13399       }
13400       free(drbSet->list.array);
13401    }
13402
13403 }
13404 /*******************************************************************
13405  *
13406  * @brief Deallocating the memory allocated by the aper decoder
13407  *          for UeContextModificationReqMsg
13408  *
13409  * @details
13410  *
13411  *    Function : freeAperDecodeUeContextModificationReqMsg
13412  *
13413  *    Functionality:  Deallocating memory allocated for
13414  *                  UeContextModificationReqMsg
13415  *
13416  * @params[in] UEContextModificationRequest_t *UeContextModifyReq
13417  *
13418  * @return void
13419  *
13420  * ****************************************************************/
13421 void freeAperDecodeUeContextModificationReqMsg(UEContextModificationRequest_t *UeContextModifyReq )
13422 {
13423    uint8_t arrIdx, ieId;
13424
13425    if(UeContextModifyReq->protocolIEs.list.array)
13426    {
13427       for( arrIdx = 0 ; arrIdx<UeContextModifyReq->protocolIEs.list.count ; arrIdx++)
13428       {
13429          if(UeContextModifyReq->protocolIEs.list.array[arrIdx])
13430          {
13431             ieId = UeContextModifyReq->protocolIEs.list.array[arrIdx]->id;
13432             switch(ieId)
13433             {
13434                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13435                   break;
13436                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13437                   break;
13438                case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
13439                   {
13440                      freeAperDecodeDrbToBeSetupModList(&UeContextModifyReq->protocolIEs.list.array[arrIdx]->\
13441                            value.choice.DRBs_ToBeSetupMod_List);
13442                      break;
13443                   }
13444             }
13445             free(UeContextModifyReq->protocolIEs.list.array[arrIdx]);
13446          }
13447       }
13448       free(UeContextModifyReq->protocolIEs.list.array);
13449    }
13450 }
13451 /*******************************************************************
13452  *
13453  * @brief processing the F1 UeContextModificationReq
13454  *
13455  * @details
13456  *
13457  *    Function : procF1UeContextModificationReq
13458  *
13459  *    Functionality:  processing the F1 UeContextModificationReq
13460  *
13461  * @params[in] F1AP_PDU_t *f1apMsg
13462  *
13463  * @return
13464  * ****************************************************************/
13465 uint8_t procF1UeContextModificationReq(F1AP_PDU_t *f1apMsg)
13466 {
13467    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
13468    uint8_t  ret = ROK, ieIdx = 0, cellIdx=0, ueIdx=0;
13469    DuUeCb   *duUeCb = NULLP;
13470    DRBs_ToBeSetupMod_List_t *drbSetupModCfg;
13471    DRBs_ToBeModified_List_t *drbModifiedCfg;
13472    uint32_t gnbCuUeF1apId, gnbDuUeF1apId;
13473
13474    ueContextModifyReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
13475    for(ieIdx=0; (ieIdx < ueContextModifyReq->protocolIEs.list.count && ret == ROK); ieIdx++)
13476    {
13477       switch(ueContextModifyReq->protocolIEs.list.array[ieIdx]->id)
13478       {
13479          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13480             {
13481                gnbCuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
13482                break;
13483             }
13484          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13485             {
13486                gnbDuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
13487                break;
13488             }
13489          case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
13490          case ProtocolIE_ID_id_DRBs_ToBeModified_List:
13491             {
13492                for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
13493                {
13494                   for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
13495                   {
13496                      if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
13497                            (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
13498                      {
13499
13500                         duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
13501                         if(duUeCb->f1UeDb == NULLP)
13502                         {
13503                            DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
13504                         }
13505                         if(duUeCb->f1UeDb)
13506                         {
13507                            duUeCb->f1UeDb->actionType = UE_CTXT_MOD;
13508                            if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present ==\
13509                                  UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List)
13510                            {
13511                               drbSetupModCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
13512                               choice.DRBs_ToBeSetupMod_List;
13513
13514                               if(extractDrbListToSetupMod(NULL, drbSetupModCfg, NULL, drbSetupModCfg->list.count,\
13515                               &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, NULL))
13516                               {
13517                                  DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbSetupModList");
13518                                  ret = RFAILED;
13519                               }
13520                            }
13521
13522                            if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present == \
13523                                   UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List)
13524
13525                            {
13526                               drbModifiedCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
13527                               choice.DRBs_ToBeModified_List;
13528                               if(extractDrbListToSetupMod(NULL, NULL, drbModifiedCfg, drbModifiedCfg->list.count,\
13529                                  &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, &duUeCb->rlcUeCfg))
13530                               {
13531                                  DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbModifiedList");
13532                                  ret = RFAILED;
13533                               }
13534                            }
13535                         }
13536                         break;
13537                      }
13538                   }
13539                   if(ueIdx >= duCb.actvCellLst[cellIdx]->numActvUes)
13540                   {
13541                      DU_LOG("\nERROR  -->  DU APP : wrong values of gnbCuUeF1apId and gnbDuUeF1apId ");
13542                      ret = RFAILED;
13543                   }
13544                }
13545                break;
13546             }
13547       }
13548    }
13549    if(ret != RFAILED)
13550    {
13551       ret = duProcUeContextModReq(duUeCb);
13552    }
13553    freeAperDecodeUeContextModificationReqMsg(ueContextModifyReq);
13554    return ret;
13555 }
13556 /*****************************************************************i
13557 *
13558 * @brief Free memory allocated for UE Context Release Request
13559 *
13560 * @details
13561 *
13562 *    Function : FreeUeContextReleaseReq
13563 *
13564 *    Functionality:
13565 *         - Free memory allocated for UE Context Release Request
13566 *
13567 * @params[in] F1AP_PDU_t *f1apMsg
13568 * @return void
13569 *
13570 * *************************************************************/
13571 void FreeUeContextReleaseReq(F1AP_PDU_t *f1apMsg)
13572 {
13573    uint8_t ieIdx;
13574    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
13575
13576    if(f1apMsg)
13577    {
13578       if(f1apMsg->choice.initiatingMessage)
13579       {
13580          ueReleaseReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
13581          if(ueReleaseReq->protocolIEs.list.array)
13582          {
13583             for(ieIdx=0 ; ieIdx<ueReleaseReq->protocolIEs.list.count; ieIdx++)
13584             {
13585                DU_FREE(ueReleaseReq->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseRequest_t));
13586             }
13587             DU_FREE(ueReleaseReq->protocolIEs.list.array, ueReleaseReq->protocolIEs.list.size);
13588          }
13589          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
13590       }
13591       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
13592    }
13593
13594 }
13595 /*****************************************************************i
13596 *
13597 * @brief Build and Send UE Context Release Request
13598 *
13599 * @details
13600 *
13601 *    Function : BuildAndSendUeContextReleaseReq
13602 *
13603 *    Functionality:
13604 *         - Build and Send UE Context Release Request
13605 *
13606 * @params[in]
13607 * @return ROK     - success
13608 *         RFAILED - failure
13609 *
13610 * *************************************************************/
13611 uint8_t BuildAndSendUeContextReleaseReq(uint16_t cellId, uint8_t ueId)
13612 {
13613    bool memAllocFail = false;
13614    uint8_t ieIdx =0;
13615    uint8_t ret = RFAILED;
13616    uint16_t cellIdx =0;
13617    uint16_t crnti = 0;
13618    uint8_t  elementCnt = 0;
13619    uint32_t  gnbCuUeF1apId =0;   /* gNB-CU UE F1AP Id */
13620    uint32_t  gnbDuUeF1apId =0;   /* gNB-DU UE F1AP Id */
13621    asn_enc_rval_t encRetVal;
13622    F1AP_PDU_t *f1apMsg = NULLP;
13623    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
13624
13625    DU_LOG("\nINFO  --> Building the UE Context Release Request");
13626    do
13627    {
13628       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
13629       if(f1apMsg == NULLP)
13630       {
13631          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for f1apMsg");
13632          break;
13633       }
13634
13635       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
13636       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
13637       if(f1apMsg->choice.initiatingMessage == NULLP)
13638       {
13639          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for\
13640          initiatingMessage");
13641          break;
13642       }
13643       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextReleaseRequest;
13644       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
13645       f1apMsg->choice.initiatingMessage->value.present = \
13646       InitiatingMessage__value_PR_UEContextReleaseRequest;
13647
13648       ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
13649
13650       elementCnt = 2;
13651
13652       ueReleaseReq->protocolIEs.list.count = elementCnt;
13653       ueReleaseReq->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseRequest_t *);
13654
13655       /* Initialize the F1Setup members */
13656       DU_ALLOC(ueReleaseReq->protocolIEs.list.array,ueReleaseReq->protocolIEs.list.size);
13657       if(ueReleaseReq->protocolIEs.list.array == NULLP)
13658       {
13659          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE array");
13660          break;
13661       }
13662       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
13663       {
13664          DU_ALLOC(ueReleaseReq->protocolIEs.list.array[ieIdx],\
13665                sizeof(UEContextReleaseRequest_t));
13666          if(ueReleaseReq->protocolIEs.list.array[ieIdx] == NULLP)
13667          {
13668             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE elements");
13669             memAllocFail = true;
13670             break;
13671          }
13672       }
13673       if(memAllocFail == true)
13674          break;
13675
13676       /* Fetching Ue Cb Info*/
13677       GET_CELL_IDX(cellId, cellIdx);
13678       if(duCb.actvCellLst[cellIdx] == NULLP)
13679       {
13680          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): CellId[%d] does not exist", cellId);
13681          break;
13682       }
13683       else
13684       {
13685          GET_CRNTI(crnti, ueId);
13686          if(duCb.actvCellLst[cellIdx]->ueCb[ueId-1].crnti != crnti)
13687          {
13688             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): crnti[%d] does not exist", crnti);
13689             break;
13690          }
13691          gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbDuUeF1apId;
13692          gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueId-1].gnbCuUeF1apId;
13693       }
13694
13695       ieIdx=0;
13696       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
13697       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13698       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present = \
13699       UEContextReleaseRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
13700       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
13701
13702       ieIdx++;
13703       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
13704       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13705       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present =\
13706       UEContextReleaseRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
13707       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
13708
13709       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13710
13711       /* Encode the F1SetupRequest type as APER */
13712       memset(encBuf, 0, ENC_BUF_MAX_LEN);
13713       encBufSize = 0;
13714       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
13715       /* Encode results */
13716       if(encRetVal.encoded == ENCODE_FAIL)
13717       {
13718          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseRequest structure (at %s)\n",\
13719                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13720          break;
13721       }
13722       else
13723       {
13724          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseRequest\n");
13725          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
13726          {
13727             printf("%x",encBuf[ieIdx]);
13728          }
13729       }
13730
13731       /* Sending msg */
13732       if(sendF1APMsg() != ROK)
13733       {
13734          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Request failed");
13735          break;
13736       }
13737       ret = ROK;
13738       break;
13739    }while(true);
13740
13741    FreeUeContextReleaseReq(f1apMsg);
13742    return ret;
13743 }
13744 /*****************************************************************i
13745  *
13746  * @brief Free memory allocated for UE Context Release Complete
13747  *
13748  * @details
13749  *
13750  *    Function : FreeUeContextReleaseComplete
13751  *
13752  *    Functionality:
13753  *         - Free memory allocated for UE Context Release Complete
13754  *
13755  * @params[in] F1AP_PDU_t *f1apMsg
13756  * @return void
13757  *
13758  * *************************************************************/
13759 void FreeUeContextReleaseComplete(F1AP_PDU_t *f1apMsg)
13760 {
13761    uint8_t ieIdx;
13762    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
13763
13764    if(f1apMsg)
13765    {
13766       if(f1apMsg->choice.successfulOutcome)
13767       {
13768          ueReleaseComplete =&f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
13769          if(ueReleaseComplete->protocolIEs.list.array)
13770          {
13771             for(ieIdx=0 ; ieIdx<ueReleaseComplete->protocolIEs.list.count; ieIdx++)
13772             {
13773                DU_FREE(ueReleaseComplete->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseComplete_t));
13774             }
13775             DU_FREE(ueReleaseComplete->protocolIEs.list.array, ueReleaseComplete->protocolIEs.list.size);
13776          }
13777          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
13778       }
13779       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
13780    }
13781
13782 }
13783 /*****************************************************************i
13784  *
13785  * @brief Build and Send UE Context Release Complete
13786  *
13787  * @details
13788  *
13789  *    Function : BuildAndSendUeContextReleaseComplete
13790  *
13791  *    Functionality:
13792  *         - Build and Send UE Context Release Complete
13793  *
13794  * @params[in]  cellId,  gnbCuUeF1apId, gnbDuUeF1apId
13795  * @return ROK     - success
13796  *         RFAILED - failure
13797  *
13798  * *************************************************************/
13799 uint8_t BuildAndSendUeContextReleaseComplete(uint16_t cellId, uint32_t gnbCuUeF1apId, uint32_t gnbDuUeF1apId)
13800 {
13801    bool memAllocFail = false;
13802    uint8_t ieIdx =0, ret = RFAILED, elementCnt = 0;
13803    asn_enc_rval_t encRetVal;
13804    F1AP_PDU_t *f1apMsg = NULLP;
13805    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
13806
13807    DU_LOG("\nINFO  --> Building the UE Context Release Complete");
13808    do
13809    {
13810       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
13811       if(f1apMsg == NULLP)
13812       {
13813          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for f1apMsg");
13814          break;
13815       }
13816
13817       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
13818       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
13819       if(f1apMsg->choice.successfulOutcome == NULLP)
13820       {
13821          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for\
13822                successfulOutcome");
13823          break;
13824       }
13825       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextRelease;
13826       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
13827       f1apMsg->choice.successfulOutcome->value.present = \
13828       SuccessfulOutcome__value_PR_UEContextReleaseComplete;
13829
13830       ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
13831
13832       elementCnt = 2;
13833       ueReleaseComplete->protocolIEs.list.count = elementCnt;
13834       ueReleaseComplete->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseComplete_t *);
13835
13836       /* Initialize the UE Release Complete members */
13837       DU_ALLOC(ueReleaseComplete->protocolIEs.list.array,ueReleaseComplete->protocolIEs.list.size);
13838       if(ueReleaseComplete->protocolIEs.list.array == NULLP)
13839       {
13840          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE array");
13841          break;
13842       }
13843       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
13844       {
13845          DU_ALLOC(ueReleaseComplete->protocolIEs.list.array[ieIdx],\
13846                sizeof(UEContextReleaseComplete_t));
13847          if(ueReleaseComplete->protocolIEs.list.array[ieIdx] == NULLP)
13848          {
13849             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE\
13850             elements");
13851             memAllocFail = true;
13852             break;
13853          }
13854       }
13855       if(memAllocFail == true)
13856          break;
13857
13858
13859       ieIdx=0;
13860       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
13861       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13862       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present = \
13863       UEContextReleaseCompleteIEs__value_PR_GNB_CU_UE_F1AP_ID;
13864       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
13865
13866       ieIdx++;
13867       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
13868       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13869       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present =\
13870       UEContextReleaseCompleteIEs__value_PR_GNB_DU_UE_F1AP_ID;
13871       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
13872
13873       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13874
13875       /* Encode the F1SetupComplete type as APER */
13876       memset(encBuf, 0, ENC_BUF_MAX_LEN);
13877       encBufSize = 0;
13878       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
13879       /* Encode results */
13880       if(encRetVal.encoded == ENCODE_FAIL)
13881       {
13882          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseComplete structure (at %s)\n",\
13883                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13884          break;
13885       }
13886       else
13887       {
13888          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseComplete\n");
13889          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
13890          {
13891             printf("%x",encBuf[ieIdx]);
13892          }
13893       }
13894
13895       /* Sending msg */
13896       if(sendF1APMsg() != ROK)
13897       {
13898          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Complete failed");
13899          break;
13900       }
13901       ret = ROK;
13902       break;
13903    }while(true);
13904
13905    if(ret == ROK && (duCb.actvCellLst[cellId-1]->numActvUes == 0))
13906    {
13907       duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
13908       ret = duSendCellDeletReq(cellId);
13909       if(ret != ROK)
13910       {
13911          DU_LOG("\nERROR  -->  F1AP: BuildAndSendUeContextReleaseComplete(): Failed to process cell\
13912                Delete req for CellId");
13913       }
13914    }
13915    FreeUeContextReleaseComplete(f1apMsg);
13916    return ret;
13917
13918 }
13919
13920 /*******************************************************************
13921 *
13922 * @brief added free part for the memory allocated by aper_decoder
13923 *
13924 * @details
13925 *
13926 *    Function : freeAperDecodeUeContextReleaseCommand
13927 *
13928 *    Functionality: added free part for the memory allocated by aper_decoder
13929 *
13930 * @params[in] F1AP_PDU_t *f1apMsg
13931 * @return void
13932 *
13933 * ****************************************************************/
13934 void freeAperDecodeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
13935 {
13936    uint8_t ieIdx=0;
13937    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
13938
13939    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
13940
13941    if(ueContextReleaseCommand->protocolIEs.list.array)
13942    {
13943       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
13944       {
13945          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
13946          {
13947             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
13948             {
13949                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13950                   break;
13951                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13952                   break;
13953                case ProtocolIE_ID_id_Cause:
13954                   break;
13955                case ProtocolIE_ID_id_RRCContainer:
13956                {
13957                   if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
13958                   {
13959                      free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
13960                   }
13961                   break;
13962                }
13963                default :
13964                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
13965                        ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
13966                   break;
13967             }
13968          }
13969          free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]);
13970       }
13971       free(ueContextReleaseCommand->protocolIEs.list.array);
13972    }
13973 }
13974 /*******************************************************************
13975 *
13976 * @brief processing of UE Context Release Command
13977 *
13978 * @details
13979 *
13980 *    Function : procF1UeContextReleaseCommand
13981 *
13982 *    Functionality: processing of UE Context Release Command
13983 *
13984 * @params[in] F1AP_PDU_t *f1apMsg
13985 * @return void
13986 *
13987 * ****************************************************************/
13988 uint8_t procF1UeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
13989 {
13990    uint8_t  ieIdx=0, ret=ROK, ueIdx=0;
13991    uint16_t cellIdx =0;
13992    bool ueIdxFound;
13993    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0;
13994    DuUeCb   *duUeCb = NULLP;
13995    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
13996
13997    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
13998
13999    if(ueContextReleaseCommand->protocolIEs.list.array)
14000    {
14001       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
14002       {
14003          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
14004          {
14005             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
14006             {
14007                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
14008                   {
14009                      gnbCuUeF1apId= ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
14010                                     value.choice.GNB_CU_UE_F1AP_ID;
14011                      break;
14012                   }
14013
14014                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
14015                   {
14016                      gnbDuUeF1apId = ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
14017                                      value.choice.GNB_DU_UE_F1AP_ID;
14018                      break;
14019                   }
14020
14021                case ProtocolIE_ID_id_Cause:
14022                   {
14023                      break;
14024                   }
14025
14026                case ProtocolIE_ID_id_RRCContainer:
14027                   {
14028                      for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
14029                      {
14030                         for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
14031                         {
14032                            if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
14033                                  (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
14034                            {
14035                               duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
14036                               DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
14037                               if(duUeCb->f1UeDb)
14038                               {
14039                                  memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
14040                                  duUeCb->f1UeDb->actionType = UE_CTXT_RELEASE;
14041                                  duUeCb->f1UeDb->cellIdx = cellIdx;
14042                                  /* Filling Dl RRC Msg Info */
14043                                  DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
14044                                  if(!duUeCb->f1UeDb->dlRrcMsg)
14045                                  {
14046                                     DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
14047                                     Memory allocation failed ");
14048                                     ret = RFAILED;
14049                                  }
14050                                  else
14051                                  {
14052                                     duUeCb->f1UeDb->dlRrcMsgPres = true;
14053                                     memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
14054                                     ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
14055                                           &ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
14056                                           value.choice.RRCContainer);
14057                                  }
14058
14059                               }
14060                               else
14061                               {
14062                                  DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
14063                                  Memory allocation failed ");
14064                                  ret = RFAILED;
14065
14066                               }
14067
14068                               ueIdxFound = true;
14069                               break;
14070                            }
14071                         }
14072                         if(ueIdxFound == true)
14073                         {
14074                            break;
14075                         }
14076                      }
14077                      if(!ueIdxFound)
14078                      {
14079                         DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextReleaseCommand()");
14080                         ret = RFAILED;
14081                      }
14082
14083
14084                      break;
14085                   }
14086                default :
14087                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
14088                         ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
14089                   break;
14090             }
14091          }
14092       }
14093    }
14094    if(ret != RFAILED)
14095    {
14096       duProcUeContextReleaseCommand(duUeCb);
14097    }
14098    freeAperDecodeUeContextReleaseCommand(f1apMsg);
14099    return ret;
14100 }
14101 /**************************************************************
14102  *
14103  * @brief Handles received F1AP message and sends back response
14104  *
14105  * @details
14106  *
14107  *    Function : F1APMsgHdlr
14108  *
14109  *    Functionality:
14110  *         - Decodes received F1AP control message
14111  *         - Prepares response message, encodes and sends to SCTP
14112  *
14113  * @params[in]
14114  * @return ROK     - success
14115  *         RFAILED - failure
14116  *
14117  * ****************************************************************/
14118 void F1APMsgHdlr(Buffer *mBuf)
14119 {
14120    int i =0;
14121    char *recvBuf =NULLP;
14122    MsgLen copyCnt =0;
14123    MsgLen recvBufLen =0;
14124    F1AP_PDU_t *f1apMsg =NULLP;
14125    asn_dec_rval_t rval; /* Decoder return value */
14126    F1AP_PDU_t f1apasnmsg ;
14127    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
14128    ODU_PRINT_MSG(mBuf, 0,0);
14129
14130    /* Copy mBuf into char array to decode it */
14131    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
14132    DU_ALLOC(recvBuf, (Size)recvBufLen);
14133
14134    if(recvBuf == NULLP)
14135    {
14136       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
14137       return;
14138    }
14139    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
14140    {
14141       DU_LOG("\nERROR   -->  F1AP : Failed while copying %d", copyCnt);
14142       return;
14143    }
14144
14145    printf("\nDEBUG   -->  F1AP : Received flat buffer to be decoded : ");
14146    for(i=0; i< recvBufLen; i++)
14147    {
14148       printf("%x",recvBuf[i]);
14149    }
14150
14151    /* Decoding flat buffer into F1AP messsage */
14152    f1apMsg = &f1apasnmsg;
14153    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
14154
14155    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
14156
14157    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
14158    {
14159       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
14160       return;
14161    }
14162    printf("\n");
14163    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
14164
14165    switch(f1apMsg->present)
14166    {
14167       case F1AP_PDU_PR_successfulOutcome:
14168          {
14169             switch(f1apMsg->choice.successfulOutcome->value.present)
14170             {
14171                case SuccessfulOutcome__value_PR_ResetAcknowledge:
14172                   {
14173                      DU_LOG("\nINFO   -->  F1AP : F1ResetAcknowledge is received successfully ");
14174                      break;
14175                   }
14176                case SuccessfulOutcome__value_PR_F1SetupResponse:
14177                   {
14178 #ifndef ODU_TEST_STUB
14179                      procF1SetupRsp(f1apMsg, recvBufLen, recvBuf);
14180 #endif
14181                      break;
14182                   }
14183
14184                case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
14185                   {
14186                      procF1GNBDUCfgUpdAck(f1apMsg);
14187                      break;
14188                   }
14189
14190                default:
14191                   {
14192                      DU_LOG("\nERROR  -->  F1AP : Invalid type of SuccessfulOutcome__value_PR_ResetAcknowledge [%d]",\
14193                            f1apMsg->choice.successfulOutcome->value.present);
14194                      return;
14195                   }
14196             }/* End of switch(successfulOutcome) */
14197             free(f1apMsg->choice.successfulOutcome);
14198             break;
14199          }
14200       case F1AP_PDU_PR_initiatingMessage:
14201          {
14202             switch(f1apMsg->choice.initiatingMessage->value.present)
14203             {
14204                case InitiatingMessage__value_PR_Reset:
14205                   {
14206                      procF1ResetReq(f1apMsg);
14207                      break;
14208                   }
14209                case InitiatingMessage__value_PR_DLRRCMessageTransfer:
14210                   {
14211                      procF1DlRrcMsgTrans(f1apMsg);
14212                      break;
14213                   }
14214                case InitiatingMessage__value_PR_UEContextSetupRequest:
14215                   {
14216                      procF1UeContextSetupReq(f1apMsg);
14217                      break;
14218                   }
14219                case InitiatingMessage__value_PR_UEContextModificationRequest:
14220                   {
14221                      procF1UeContextModificationReq(f1apMsg);
14222                      break;
14223                   }
14224                case InitiatingMessage__value_PR_UEContextReleaseCommand:
14225                   {
14226                       procF1UeContextReleaseCommand(f1apMsg);
14227                       break;
14228                   }
14229                default:
14230                   {
14231                      DU_LOG("\nERROR  -->  F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
14232                            f1apMsg->choice.initiatingMessage->value.present);
14233                      return;
14234                   }
14235             }/* End of switch(initiatingMessage) */
14236             free(f1apMsg->choice.initiatingMessage);
14237             break;
14238          }
14239
14240       default:
14241          {
14242             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
14243             return;
14244          }
14245          free(f1apMsg);
14246
14247    }/* End of switch(f1apMsg->present) */
14248
14249    DU_FREE(recvBuf, (Size)recvBufLen);
14250 } /* End of F1APMsgHdlr */
14251
14252 /**********************************************************************
14253   End of file
14254  **********************************************************************/