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
 105 #ifdef O1_ENABLE
 106 #include "ConfigInterface.h"
 107 extern StartupConfig g_cfg;
 108 #endif
 109
 110 DuCfgParams duCfgParam;
 111
 112 /******************************************************************
 113  *
 114  * @brief Function to fetch lcId based on DRB Id
 115  *
 116  * @details
 117  *
 118  *    Function : fetchLcId
 119  *
 120  *    @params[in] drbId
 121  *
 122  *    Functionality: Function to fetch lcId based on DRB Id
 123  *
 124  * Returns: lcId - SUCCESS
 125  *          RFAILED - FAILURE
 126  *****************************************************************/
 127
 128 uint8_t fetchLcId(uint8_t drbId)
 129 {
 130    uint8_t cellIdx = 0, ueIdx = 0, lcIdx = 0, numLcs = 0, lcId = 0;
 131
 132    for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
 133    {
 134       for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
 135       {
 136          if(duCb.actvCellLst[cellIdx] != NULLP)
 137          {
 138             numLcs = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.numLcs;
 139             for(lcIdx = 0; lcIdx < numLcs; lcIdx++)
 140             {
 141                if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.rlcLcCfg[lcIdx].rbId == drbId && \
 142                   duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.rlcLcCfg[lcIdx].rbType == RB_TYPE_DRB)
 143                {
 144                   lcId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].rlcUeCfg.rlcLcCfg[lcIdx].lcId;
 145                   return lcId;
 146                }
 147             }
 148          }
 149       }
 150    }
 151    DU_LOG("\nERROR   -->  DU_APP: fetchLcId() failed for drbId %d", drbId);
 152    return RFAILED;
 153 }
 154
 155 /************************************************************************
 156  *
 157  * @brief Converts enum values into actual value of Poll retransmit timer
 158  *
 159  * @details
 160  *
 161  *    Function : getPollPdu
 162  *
 163  *    Functionality: Converts enum values into actual value of poll
 164  *    retransmit timer
 165  *
 166  * @params[in] Enum value of pollPdu
 167  * @return Actual value of pollPdu
 168  *
 169  * **********************************************************************/
 170
 171 uint16_t getPollRetxTmr(uint8_t pollRetxTmrCfg)
 172 {
 173    uint16_t pollRetxTmr;
 174
 175    /* All values of poll retx timer are at interval of 5ms.
 176     * This is valid upto 250ms
 177     * Hence converting the enum value to actual value by multiplying it to 5
 178     */
 179    if(pollRetxTmrCfg <= T_PollRetransmit_ms250)
 180       pollRetxTmr = (pollRetxTmrCfg + 1) * 5;
 181    else
 182    {
 183       switch(pollRetxTmrCfg)
 184       {
 185          case T_PollRetransmit_ms300:
 186             pollRetxTmr = 300;
 187             break;
 188          case T_PollRetransmit_ms350:
 189             pollRetxTmr = 350;
 190             break;
 191          case T_PollRetransmit_ms400:
 192             pollRetxTmr = 400;
 193             break;
 194          case T_PollRetransmit_ms450:
 195             pollRetxTmr = 450;
 196             break;
 197          case T_PollRetransmit_ms500:
 198             pollRetxTmr = 500;
 199             break;
 200          case T_PollRetransmit_ms800:
 201             pollRetxTmr = 800;
 202             break;
 203          default:
 204             DU_LOG("\nERROR  -->  F1AP: Invalid value of Poll Retransmit timer");
 205             pollRetxTmr = 0;
 206       }
 207    }
 208    return pollRetxTmr;
 209 }
 210
 211 /*******************************************************************
 212  *
 213  * @brief Converts enum values into actual value of PollPdu
 214  *
 215  * @details
 216  *
 217  *    Function : getPollPdu
 218  *
 219  *    Functionality: Converts enum values into actual value of PollPdu
 220  *
 221  * @params[in] Enum value of pollPdu
 222  * @return Actual value of pollPdu
 223  *
 224  * ****************************************************************/
 225 int32_t getPollPdu(uint8_t pollPduCfg)
 226 {
 227    int32_t pollPdu;
 228    switch(pollPduCfg)
 229    {
 230       case PollPDU_p4:
 231          pollPdu = 4;
 232          break;
 233       case PollPDU_p8:
 234          pollPdu = 8;
 235          break;
 236       case PollPDU_p16:
 237          pollPdu = 16;
 238          break;
 239       case PollPDU_p32:
 240          pollPdu = 32;
 241          break;
 242       case PollPDU_p64:
 243          pollPdu = 64;
 244          break;
 245       case PollPDU_p128:
 246          pollPdu = 128;
 247          break;
 248       case PollPDU_p256:
 249          pollPdu = 256;
 250          break;
 251       case PollPDU_p512:
 252          pollPdu = 512;
 253          break;
 254       case PollPDU_p1024:
 255          pollPdu = 1024;
 256          break;
 257       case PollPDU_p2048:
 258          pollPdu = 2048;
 259          break;
 260       case PollPDU_p4096:
 261          pollPdu = 4096;
 262          break;
 263       case PollPDU_p6144:
 264          pollPdu = 6144;
 265          break;
 266       case PollPDU_p8192:
 267          pollPdu = 8192;
 268          break;
 269       case PollPDU_p12288:
 270          pollPdu = 12288;
 271          break;
 272       case PollPDU_p16384:
 273          pollPdu = 16384;
 274          break;
 275       case PollPDU_p20480:
 276          pollPdu = 20480;
 277          break;
 278       case PollPDU_p24576:
 279          pollPdu = 24576;
 280          break;
 281       case PollPDU_p28672:
 282          pollPdu = 28672;
 283          break;
 284       case PollPDU_p32768:
 285          pollPdu = 32768;
 286          break;
 287       case PollPDU_p40960:
 288          pollPdu = 40960;
 289          break;
 290       case PollPDU_p49152:
 291          pollPdu = 49152;
 292          break;
 293       case PollPDU_p57344:
 294          pollPdu = 57344;
 295          break;
 296       case PollPDU_p65536:
 297          pollPdu = 65536;
 298          break;
 299       case PollPDU_infinity:
 300          pollPdu = -1;
 301          break;
 302       default:
 303          DU_LOG("\nERROR  -->  F1AP: Invalid value of poll pdu");
 304          pollPdu = 0;
 305          break;
 306    }
 307    return pollPdu;
 308 }
 309
 310 /*******************************************************************
 311  *
 312  * @brief Converts enum values into actual value of poll bytes
 313  *
 314  * @details
 315  *
 316  *    Function : getPollByte
 317  *
 318  *    Functionality: Converts enum values into actual value of pollBytes
 319  *
 320  * @params[in] Enum value
 321  * @return Actual value
 322  *
 323  * ****************************************************************/
 324 int32_t getPollByte(uint16_t pollBytesCfg)
 325 {
 326    int32_t pollBytes;
 327    switch(pollBytesCfg)
 328    {
 329       case PollByte_kB1:
 330          pollBytes = 1000;
 331          break;
 332       case PollByte_kB2:
 333          pollBytes = 2000;
 334          break;
 335       case PollByte_kB5:
 336          pollBytes = 5000;
 337          break;
 338       case PollByte_kB8:
 339          pollBytes = 8000;
 340          break;
 341       case PollByte_kB10:
 342          pollBytes = 10000;
 343          break;
 344       case PollByte_kB15:
 345          pollBytes = 15000;
 346          break;
 347       case PollByte_kB25:
 348          pollBytes = 25000;
 349          break;
 350       case PollByte_kB50:
 351          pollBytes = 50000;
 352          break;
 353       case PollByte_kB75:
 354          pollBytes = 75000;
 355          break;
 356       case PollByte_kB100:
 357          pollBytes = 100000;
 358          break;
 359       case PollByte_kB125:
 360          pollBytes = 125000;
 361          break;
 362       case PollByte_kB250:
 363          pollBytes = 250000;
 364          break;
 365       case PollByte_kB375:
 366          pollBytes = 375000;
 367          break;
 368       case PollByte_kB500:
 369          pollBytes = 500000;
 370          break;
 371       case PollByte_kB750:
 372          pollBytes = 750000;
 373          break;
 374       case PollByte_kB1000:
 375          pollBytes = 1000000;
 376          break;
 377       case PollByte_kB1250:
 378          pollBytes = 1250000;
 379          break;
 380       case PollByte_kB1500:
 381          pollBytes = 1500000;
 382          break;
 383       case PollByte_kB2000:
 384          pollBytes = 2000000;
 385          break;
 386       case PollByte_kB3000:
 387          pollBytes = 3000000;
 388          break;
 389       case PollByte_kB4000:
 390          pollBytes = 4000000;
 391          break;
 392       case PollByte_kB4500:
 393          pollBytes = 4500000;
 394          break;
 395       case PollByte_kB5000:
 396          pollBytes = 5000000;
 397          break;
 398       case PollByte_kB5500:
 399          pollBytes = 5500000;
 400          break;
 401       case PollByte_kB6000:
 402          pollBytes = 6000000;
 403          break;
 404       case PollByte_kB6500:
 405          pollBytes = 6500000;
 406          break;
 407       case PollByte_kB7000:
 408          pollBytes = 7000000;
 409          break;
 410       case PollByte_kB7500:
 411          pollBytes = 7500000;
 412          break;
 413       case PollByte_mB8:
 414          pollBytes = 8000000;
 415          break;
 416       case PollByte_mB9:
 417          pollBytes = 9000000;
 418          break;
 419       case PollByte_mB10:
 420          pollBytes = 10000000;
 421          break;
 422       case PollByte_mB11:
 423          pollBytes = 11000000;
 424          break;
 425       case PollByte_mB12:
 426          pollBytes = 12000000;
 427          break;
 428       case PollByte_mB13:
 429          pollBytes = 13000000;
 430          break;
 431       case PollByte_mB14:
 432          pollBytes = 14000000;
 433          break;
 434       case PollByte_mB15:
 435          pollBytes = 15000000;
 436          break;
 437       case PollByte_mB16:
 438          pollBytes = 16000000;
 439          break;
 440       case PollByte_mB17:
 441          pollBytes = 17000000;
 442          break;
 443       case PollByte_mB18:
 444          pollBytes = 18000000;
 445          break;
 446       case PollByte_mB20:
 447          pollBytes = 20000000;
 448          break;
 449       case PollByte_mB25:
 450          pollBytes = 25000000;
 451          break;
 452       case PollByte_mB30:
 453          pollBytes = 30000000;
 454          break;
 455       case PollByte_mB40:
 456          pollBytes = 40000000;
 457          break;
 458       case PollByte_infinity:
 459          pollBytes = -1;
 460          break;
 461       default:
 462          DU_LOG("\nERROR  -->  F1AP: Invalid value of poll bytes");
 463          pollBytes = 0;
 464    }
 465    return pollBytes;
 466 }
 467
 468 /*******************************************************************
 469  *
 470  * @brief Converts enum values into actual value of maxRetx
 471  *
 472  * @details
 473  *
 474  *    Function : getMaxRetx
 475  *
 476  *    Functionality: Converts enum values into actual value of maxRetx
 477  *
 478  * @params[in] Enum value
 479  * @return Actual value
 480  *
 481  * ****************************************************************/
 482 uint8_t getMaxRetx(uint8_t maxRetxCfg)
 483 {
 484    uint8_t maxRetx;
 485    switch(maxRetxCfg)
 486    {
 487       case UL_AM_RLC__maxRetxThreshold_t1:
 488          maxRetx = 1;
 489          break;
 490       case UL_AM_RLC__maxRetxThreshold_t2:
 491          maxRetx = 2;
 492          break;
 493       case UL_AM_RLC__maxRetxThreshold_t3:
 494          maxRetx = 3;
 495          break;
 496       case UL_AM_RLC__maxRetxThreshold_t4:
 497          maxRetx = 4;
 498          break;
 499       case UL_AM_RLC__maxRetxThreshold_t6:
 500          maxRetx = 6;
 501          break;
 502       case UL_AM_RLC__maxRetxThreshold_t8:
 503          maxRetx = 8;
 504          break;
 505       case UL_AM_RLC__maxRetxThreshold_t16:
 506          maxRetx = 16;
 507          break;
 508       case UL_AM_RLC__maxRetxThreshold_t32:
 509          maxRetx = 32;
 510          break;
 511       default:
 512          DU_LOG("\nERROR  -->  F1AP: Invalid configuration for Max retransmission threshold");
 513          maxRetx = 0;
 514    }
 515    return maxRetx;
 516 }
 517
 518 /*******************************************************************
 519  * @brief Converts enum values into actual value of reassembly timer
 520  *
 521  * @details
 522  *
 523  *    Function : getReAsmblTmr
 524  *
 525  *    Functionality: Converts enum values into actual value of reassembly
 526  *    timer
 527  *
 528  * @params[in] Enum value of reassembly timer
 529  * @return Actual value of reassembly timer
 530  *
 531  * **********************************************************************/
 532
 533 int8_t getReAsmblTmr(uint8_t reAsmblTmrCfg)
 534 {
 535    int8_t reAsmblTmr = 0;
 536
 537    if(reAsmblTmrCfg == T_Reassembly_ms0)
 538    {
 539       reAsmblTmr = 0;
 540    }
 541    else if(reAsmblTmrCfg >= T_Reassembly_ms5 || reAsmblTmrCfg <= T_Reassembly_ms100)
 542    {
 543      /* All values of re assembly timer are at interval of 5ms.
 544       * This is valid upto 100ms
 545       * Hence converting the enum value to actual value by multiplying it to 5
 546       */
 547       reAsmblTmr = reAsmblTmrCfg * 5;
 548    }
 549    else if(reAsmblTmrCfg >= T_Reassembly_ms110 || reAsmblTmrCfg <= T_Reassembly_ms200)
 550    {
 551      /* All values of re assembly timer are at interval of 10ms.
 552       * This is valid upto 200ms
 553       * since enum value starts from 20 for 100ms, subtracting 10 and
 554       * converting the enum value to actual value by multiplying it to 10
 555       */
 556       reAsmblTmr = ((reAsmblTmrCfg-10) * 10);
 557    }
 558    else
 559    {
 560       DU_LOG("\nERROR  -->  F1AP : Invalid value of Re Assembly timer %d", reAsmblTmrCfg);
 561       reAsmblTmr = -1;
 562    }
 563    return reAsmblTmr;
 564 }
 565
 566 /************************************************************************
 567  *
 568  * @brief Converts enum values into actual value of status prohibit timer
 569  *
 570  * @details
 571  *
 572  *    Function : getStatProhTmr
 573  *
 574  *    Functionality: Converts enum values into actual value of status prohibit
 575  *    timer
 576  *
 577  * @params[in] Enum value of status prohibit timer
 578  * @return Actual value of status prohibit timer
 579  *
 580  * **********************************************************************/
 581
 582 int16_t getStatProhTmr(uint8_t statProhTmrCfg)
 583 {
 584    int16_t statProhTmr =0;
 585
 586    if(statProhTmrCfg == T_StatusProhibit_ms0)
 587    {
 588       statProhTmr = 0;
 589    }
 590    else if(statProhTmrCfg >= T_StatusProhibit_ms5 || statProhTmrCfg <= T_StatusProhibit_ms250)
 591    {
 592       /* All values of re assembly timer are at interval of 5ms.
 593        * This is valid upto 250ms
 594        * Hence converting the enum value to actual value by multiplying it to 5
 595        */
 596       statProhTmr = statProhTmrCfg * 5;
 597    }
 598    else
 599    {
 600       switch(statProhTmrCfg)
 601       {
 602          case T_StatusProhibit_ms300:
 603             statProhTmr = 300;
 604             break;
 605          case T_StatusProhibit_ms350:
 606             statProhTmr = 350;
 607             break;
 608          case T_StatusProhibit_ms400:
 609             statProhTmr = 400;
 610             break;
 611          case T_StatusProhibit_ms450:
 612             statProhTmr = 450;
 613             break;
 614          case T_StatusProhibit_ms500:
 615             statProhTmr = 500;
 616             break;
 617          case T_StatusProhibit_ms800:
 618             statProhTmr = 800;
 619             break;
 620          case T_StatusProhibit_ms1000:
 621             statProhTmr = 1000;
 622             break;
 623          case T_StatusProhibit_ms1200:
 624             statProhTmr = 1200;
 625             break;
 626          case T_StatusProhibit_ms1600:
 627             statProhTmr = 1600;
 628             break;
 629          case T_StatusProhibit_ms2000:
 630             statProhTmr = 2000;
 631             break;
 632          case T_StatusProhibit_ms2400:
 633             statProhTmr = 2400;
 634             break;
 635          default:
 636             DU_LOG("\nInvalid value of Status Prohibit timer %d", statProhTmrCfg);
 637             statProhTmr = -1;
 638             break;
 639       }
 640    }
 641    return statProhTmr;
 642 }
 643
 644 /*******************************************************************
 645 *
 646 * @brief Adding F1AP pdu to reserved pdu list
 647 *
 648 * @details
 649 *
 650 *    Function : addToReservedF1apPduList
 651 *
 652 *    Functionality: Adding F1AP pdu to reserved pdu list.
 653 *     These pdu are awaiting aknowledgment from CU
 654 *
 655 * @params[in] uint8_t transId, F1AP_PDU_t *f1apMsg
 656 *
 657 * @return ROK - success
 658 *         RFAILED - failure
 659 *
 660 * ****************************************************************/
 661
 662 void addToReservedF1apPduList(uint8_t transId, F1AP_PDU_t *f1apPdu)
 663 {
 664    CmLList         *node = NULLP;
 665    ReservedF1apPduInfo *pduInfo = NULLP;
 666    DU_ALLOC(pduInfo, sizeof(ReservedF1apPduInfo));
 667    if(pduInfo)
 668    {
 669       DU_ALLOC(node, sizeof(CmLList));
 670       if(node)
 671       {
 672          pduInfo->transId = transId;
 673          pduInfo->f1apMsg = (void*) f1apPdu;
 674
 675          node->node = (PTR)pduInfo;
 676          cmLListAdd2Tail(&duCb.reservedF1apPduList, node);
 677       }
 678    }
 679 }
 680
 681 /*******************************************************************
 682 *
 683 * @brief searching for F1AP pdu from ReservedF1apPduList
 684 *
 685 * @details
 686 *
 687 *    Function : searchFromReservedF1apPduList
 688 *
 689 *    Functionality: searching for F1AP pdu information
 690 *
 691 * @params[in] uint8_t transId
 692 *
 693 * @return pointer to F1AP_PDU_t
 694 *
 695 * ****************************************************************/
 696
 697 CmLList *searchFromReservedF1apPduList(uint8_t transId)
 698 {
 699    CmLList         *node;
 700    ReservedF1apPduInfo *f1apPdu;
 701    if(duCb.reservedF1apPduList.count)
 702    {
 703       CM_LLIST_FIRST_NODE(&duCb.reservedF1apPduList, node);
 704       while(node)
 705       {
 706          f1apPdu = (ReservedF1apPduInfo*)node->node;
 707          if(f1apPdu->transId == transId)
 708          {
 709             return node;
 710          }
 711          node = node->next;
 712       }
 713    }
 714    return NULL;
 715 }
 716
 717 /*******************************************************************
 718 *
 719 * @brief deleting F1AP pdu information from ReservedF1apPduList
 720 *
 721 * @details
 722 *
 723 *    Function : deleteFromReservedF1apPduList
 724 *
 725 *    Functionality: deleting pdu information from ReservedF1apPduList
 726 *
 727 * @params[in] CmLList *node
 728 *
 729 * @return void
 730 *
 731 * ****************************************************************/
 732
 733 void deleteFromReservedF1apPduList(CmLList *node)
 734 {
 735    ReservedF1apPduInfo *f1apPdu;
 736
 737    if(node != NULL)
 738    {
 739       f1apPdu = (ReservedF1apPduInfo *)node->node;
 740       cmLListDelFrm(&duCb.reservedF1apPduList, node);
 741       DU_FREE(f1apPdu, sizeof(ReservedF1apPduInfo));
 742       DU_FREE(node, sizeof(CmLList));
 743       node = NULL;
 744    }
 745 }
 746
 747 /*******************************************************************
 748  *
 749  * @brief Builds Uplink Info for NR
 750  *
 751  * @details
 752  *
 753  *    Function : BuildULNRInfo
 754  *
 755  *    Functionality: Building NR Uplink Info
 756  *
 757  * @params[in] NRFreqInfo_t *ulnrfreq
 758  * @return ROK     - success
 759  *         RFAILED - failure
 760  *
 761  * ****************************************************************/
 762 uint8_t BuildULNRInfo(NRFreqInfo_t *ulnrfreq)
 763 {
 764    uint8_t idx=0;
 765    ulnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 766                        fdd.ulNrFreqInfo.nrArfcn;
 767    ulnrfreq->freqBandListNr.list.count = 1;
 768    ulnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 769    DU_ALLOC(ulnrfreq->freqBandListNr.list.array,ulnrfreq->freqBandListNr.list.size);
 770    if(ulnrfreq->freqBandListNr.list.array == NULLP)
 771    {
 772       return RFAILED;
 773    }
 774    for(idx=0;idx<ulnrfreq->freqBandListNr.list.count;idx++)
 775    {
 776       DU_ALLOC(ulnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 777       if(ulnrfreq->freqBandListNr.list.array[idx] == NULLP)
 778       {
 779          return RFAILED;
 780       }
 781    }
 782    ulnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 783                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
 784                                                                  freqBand[0].nrFreqBand;
 785    ulnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 786    return ROK;
 787 }
 788 /*******************************************************************
 789  *
 790  * @brief Builds Downlink NR Info
 791  *
 792  * @details
 793  *
 794  *    Function : BuildDLNRInfo
 795  *
 796  *    Functionality: Building Downlink NR Info
 797  *
 798  * @params[in] NRFreqInfo_t *dlnrfreq
 799  * @return ROK     - success
 800  *         RFAILED - failure
 801  *
 802  * ****************************************************************/
 803 uint8_t BuildDLNRInfo(NRFreqInfo_t *dlnrfreq)
 804 {
 805    uint8_t idx=0;
 806    dlnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 807                        fdd.dlNrFreqInfo.nrArfcn;
 808    dlnrfreq->freqBandListNr.list.count = 1;
 809    dlnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 810    DU_ALLOC(dlnrfreq->freqBandListNr.list.array,dlnrfreq->freqBandListNr.list.size);
 811    if(dlnrfreq->freqBandListNr.list.array == NULLP)
 812    {
 813       return RFAILED;
 814    }
 815    for(idx=0;idx< dlnrfreq->freqBandListNr.list.count;idx++)
 816    {
 817       DU_ALLOC(dlnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 818       if(dlnrfreq->freqBandListNr.list.array[idx] == NULLP)
 819       {
 820          return RFAILED;
 821       }
 822    }
 823    dlnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 824                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
 825                                                                  freqBand[0].nrFreqBand;
 826    dlnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 827
 828    return ROK;
 829 }
 830
 831 /*******************************************************************
 832  *
 833  * @brief Builds NRCell ID
 834  *
 835  * @details
 836  *
 837  *    Function : BuildNrCellId
 838  *
 839  *    Functionality: Building the NR Cell ID
 840  *
 841  * @params[in] BIT_STRING_t *nrcell
 842  * @return ROK     - success
 843  *         RFAILED - failure
 844  *
 845  * ****************************************************************/
 846
 847 S16 BuildNrCellId(BIT_STRING_t *nrcell)
 848 {
 849    memset(nrcell->buf, 0, nrcell->size);
 850    nrcell->buf[4]   = 16;
 851    nrcell->bits_unused = 4;
 852    return ROK;
 853 }
 854
 855 /*******************************************************************
 856  *
 857  * @brief Builds Nrcgi
 858  *
 859  * @details
 860  *
 861  *    Function : BuildNrcgi
 862  *
 863  *    Functionality: Building the PLMN ID and NR Cell id
 864  *
 865  * @params[in] NRCGI_t *nrcgi
 866  * @return ROK     - success
 867  *         RFAILED - failure
 868  *
 869  * ****************************************************************/
 870 uint8_t BuildNrcgi(NRCGI_t *nrcgi)
 871 {
 872    uint8_t ret;
 873    uint8_t byteSize = 5;
 874    /* Allocate Buffer Memory */
 875    nrcgi->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 876    DU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
 877    if(nrcgi->pLMN_Identity.buf == NULLP)
 878    {
 879       return RFAILED;
 880    }
 881    ret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 882          nrcgi->pLMN_Identity.buf); // Building PLMN function
 883    if(ret != ROK)
 884    {
 885       return RFAILED;
 886    }
 887    /*nrCellIdentity*/
 888    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
 889    DU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
 890    if(nrcgi->nRCellIdentity.buf == NULLP)
 891    {
 892       return RFAILED;
 893    }
 894    BuildNrCellId(&nrcgi->nRCellIdentity);
 895
 896    return ROK;
 897 }
 898 /*******************************************************************
 899  *
 900  * @brief Builds FiveGStac
 901  *
 902  * @details
 903  *
 904  *    Function : BuildFiveGSTac
 905  *
 906  *    Functionality: Building the FiveGSTac
 907  *
 908  * @params[in] OCTET_STRING_t *fivegsTac
 909  * @return ROK     - success
 910  *         RFAILED - failure
 911  *
 912  * ****************************************************************/
 913 uint8_t BuildFiveGSTac(Served_Cell_Information_t *servcell)
 914 {
 915    DU_ALLOC(servcell->fiveGS_TAC,sizeof(FiveGS_TAC_t));
 916    if(servcell->fiveGS_TAC == NULLP)
 917    {
 918       return RFAILED;
 919    }
 920    servcell->fiveGS_TAC->size = 3 * sizeof(uint8_t);
 921    DU_ALLOC(servcell->fiveGS_TAC->buf,\
 922          sizeof(servcell->fiveGS_TAC->size));
 923    if(servcell->fiveGS_TAC->buf == NULLP)
 924    {
 925       return RFAILED;
 926    }
 927    servcell->fiveGS_TAC->buf[0] = 0;
 928    servcell->fiveGS_TAC->buf[1] = 0;
 929    servcell->fiveGS_TAC->buf[2] = duCfgParam.srvdCellLst[0].duCellInfo.tac;
 930    return ROK;
 931 }
 932 /*******************************************************************
 933  *
 934  * @brief Builds NR Mode
 935  *
 936  * @details
 937  *
 938  *    Function : BuildNrMode
 939  *
 940  *    Functionality: Building the NR Mode
 941  *
 942  * @params[in] NR_Mode_Info_t *fdd
 943  * @return ROK     - success
 944  *         RFAILED - failure
 945  *
 946  * ****************************************************************/
 947 uint8_t BuildNrMode(NR_Mode_Info_t *mode)
 948 {
 949    uint8_t BuildDLNRInforet=0;
 950    uint8_t BuildULNRInforet=0;
 951    /* FDD Mode */
 952    mode->present = NR_Mode_Info_PR_fDD;
 953    if(mode->present == NR_Mode_Info_PR_fDD)
 954    {
 955       DU_ALLOC(mode->choice.fDD,sizeof(FDD_Info_t));
 956       if(mode->choice.fDD == NULLP)
 957       {
 958          return RFAILED;
 959       }
 960       BuildULNRInforet = BuildULNRInfo(&mode->choice.fDD->uL_NRFreqInfo);
 961       if(BuildULNRInforet != ROK)
 962       {
 963          return RFAILED;
 964       }
 965       BuildDLNRInforet = BuildDLNRInfo(&mode->choice.fDD->dL_NRFreqInfo);
 966       if(BuildDLNRInforet != ROK)
 967       {
 968          return RFAILED;
 969       }
 970    }
 971    mode->choice.fDD->uL_Transmission_Bandwidth.nRSCS = \
 972                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 973                                                        f1Mode.mode.fdd.ulTxBw.nrScs;
 974    mode->choice.fDD->uL_Transmission_Bandwidth.nRNRB = \
 975                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 976                                                        f1Mode.mode.fdd.ulTxBw.nrb;
 977    mode->choice.fDD->dL_Transmission_Bandwidth.nRSCS = \
 978                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 979                                                        f1Mode.mode.fdd.dlTxBw.nrScs;
 980    mode->choice.fDD->dL_Transmission_Bandwidth.nRNRB = \
 981                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 982                                                        f1Mode.mode.fdd.dlTxBw.nrb;
 983    return ROK;
 984 }
 985 /*******************************************************************
 986  *
 987  * @brief Builds IE Extensions for Served PLMNs
 988  *
 989  * @details
 990  *
 991  *    Function : BuildExtensions
 992  *
 993  *    Functionality: Building the IE Extensions
 994  *
 995  * @params[in] struct ProtocolExtensionContainer_4624P3 *buildextend
 996  * @return ROK     - success
 997  *         RFAILED - failure
 998  *
 999  * ****************************************************************/
1000 uint8_t BuildExtensions(ProtocolExtensionContainer_4624P3_t **ieExtend)
1001 {
1002    uint8_t idx=0, plmnidx=0, sliceLstIdx=0;
1003    uint8_t elementCnt=0, extensionCnt=0;
1004
1005    extensionCnt=IE_EXTENSION_LIST_COUNT;
1006    DU_ALLOC(*ieExtend,sizeof(ProtocolExtensionContainer_4624P3_t));
1007    if((*ieExtend) == NULLP)
1008    {
1009       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1010       return RFAILED;
1011    }
1012    (*ieExtend)->list.count = extensionCnt;
1013    (*ieExtend)->list.size = \
1014                             extensionCnt * sizeof(ServedPLMNs_ItemExtIEs_t *);
1015    DU_ALLOC((*ieExtend)->list.array,(*ieExtend)->list.size);
1016    if((*ieExtend)->list.array == NULLP)
1017    {
1018       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1019       return RFAILED;
1020    }
1021    for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
1022    {
1023       DU_ALLOC((*ieExtend)->list.array[plmnidx],\
1024             sizeof(ServedPLMNs_ItemExtIEs_t));
1025       if((*ieExtend)->list.array[plmnidx] == NULLP)
1026       {
1027          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1028          return RFAILED;
1029       }
1030    }
1031
1032    elementCnt = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].taiSliceSuppLst.numSupportedSlices;
1033    idx = 0;
1034    (*ieExtend)->list.array[idx]->id = ProtocolIE_ID_id_TAISliceSupportList;
1035    (*ieExtend)->list.array[idx]->criticality = Criticality_ignore;
1036    (*ieExtend)->list.array[idx]->extensionValue.present = \
1037    ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
1038    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1039       list.count = elementCnt;
1040    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1041       list.size = (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1042       list.count * sizeof(SliceSupportItem_t *);
1043
1044    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1045          list.array, elementCnt * sizeof(SliceSupportItem_t *));
1046    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1047          list.array == NULLP)
1048    {
1049       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1050       return RFAILED;
1051    }
1052
1053    for(sliceLstIdx =0; sliceLstIdx<elementCnt; sliceLstIdx++)
1054    {
1055       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1056             list.array[sliceLstIdx],sizeof(SliceSupportItem_t));
1057       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1058             list.array[sliceLstIdx] == NULLP)
1059       {
1060          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1061          return RFAILED;
1062       }
1063       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1064          list.array[sliceLstIdx]->sNSSAI.sST.size = sizeof(uint8_t);
1065       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
1066             .list.array[sliceLstIdx]->sNSSAI.sST.buf,(*ieExtend)->list.array[idx]->\
1067             extensionValue.choice.SliceSupportList.\
1068             list.array[sliceLstIdx]->sNSSAI.sST.size);
1069       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
1070             .list.array[sliceLstIdx]->sNSSAI.sST.buf == NULLP)
1071       {
1072          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1073          return RFAILED;
1074       }
1075       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1076          list.array[sliceLstIdx]->sNSSAI.sST.buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.\
1077          cellInfo.srvdPlmn[0].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
1078
1079       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1080             list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1081       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1082             list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
1083       {
1084          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1085          return RFAILED;
1086       }
1087       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1088          list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
1089       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1090             list.array[sliceLstIdx]->sNSSAI.sD->buf, (*ieExtend)->list.array[idx]->extensionValue.choice.\
1091             SliceSupportList.list.array[sliceLstIdx]->sNSSAI.sD->size);
1092       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1093             list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
1094       {
1095          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1096          return RFAILED;
1097       }
1098       memcpy((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1099       list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[0].duCellInfo.\
1100       cellInfo.srvdPlmn[0].taiSliceSuppLst.snssai[sliceLstIdx]->sd, (*ieExtend)->list.array[idx]->\
1101       extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->sNSSAI.sD->size);
1102    }
1103    return ROK;
1104 }
1105 /*******************************************************************
1106  *
1107  * @brief Builds Served PLMN
1108  *
1109  * @details
1110  *
1111  *    Function : BuildServedPlmn
1112  *
1113  *    Functionality: Building the Served PLMN
1114  *
1115  * @params[in] GNB_DU_Served_Cells_Item_t *srvCellItem
1116  * @return ROK     - success
1117  *         RFAILED - failure
1118  *
1119  * ****************************************************************/
1120 uint8_t  BuildServedPlmn(ServedPLMNs_List_t *srvplmn)
1121 {
1122    uint8_t  plmnidx;
1123    uint8_t  servPlmnCnt=1;
1124    uint8_t buildPlmnIdret=0;
1125    uint8_t BuildExtensionsret=0;
1126    srvplmn->list.count = servPlmnCnt;
1127    srvplmn->list.size = \
1128                         servPlmnCnt*sizeof(ServedPLMNs_Item_t *);
1129    DU_ALLOC(srvplmn->list.array,srvplmn->list.size);
1130    if(srvplmn->list.array == NULLP)
1131    {
1132       return RFAILED;
1133    }
1134    for(plmnidx=0; plmnidx<servPlmnCnt; plmnidx++)
1135    {
1136       DU_ALLOC(srvplmn->list.array[plmnidx],\
1137             sizeof(ServedPLMNs_Item_t));
1138       if(srvplmn->list.array[plmnidx] == NULLP)
1139       {
1140          return RFAILED;
1141       }
1142    }
1143    srvplmn->list.array[0]->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
1144    DU_ALLOC(srvplmn->list.array[0]->pLMN_Identity.buf, srvplmn->list.array[0]->pLMN_Identity.size);
1145    buildPlmnIdret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
1146          srvplmn->list.array[0]->pLMN_Identity.buf);
1147    if(buildPlmnIdret!= ROK)
1148    {
1149       return RFAILED;
1150    }
1151    BuildExtensionsret = BuildExtensions(&srvplmn->list.array[0]->iE_Extensions);
1152    if(BuildExtensionsret!= ROK)
1153    {
1154       return RFAILED;
1155    }
1156    return ROK;
1157 }
1158 /*******************************************************************
1159  *
1160  * @brief Builds Served Cell List
1161  *
1162  * @details
1163  *
1164  *    Function : BuildServedCellList
1165  *
1166  *    Functionality: Building Served Cell List
1167  *
1168  * @params[in] PLMNID plmn
1169  * @return ROK     - success
1170  *         RFAILED - failure
1171  *
1172  * ****************************************************************/
1173
1174 uint8_t BuildServedCellList(GNB_DU_Served_Cells_List_t *duServedCell)
1175 {
1176    uint8_t  BuildNrcgiret=0;
1177    uint8_t  BuildFiveGSTacret=0;
1178    uint8_t  BuildServedPlmnret=0;
1179    uint8_t  BuildNrModeret=0;
1180    uint8_t  idx;
1181    uint8_t  plmnidx;
1182    uint8_t  plmnCnt=1;
1183    GNB_DU_Served_Cells_Item_t *srvCellItem;
1184    duServedCell->list.size = plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t *);
1185    duServedCell->list.count = plmnCnt;
1186
1187    DU_ALLOC(duServedCell->list.array, duServedCell->list.size);
1188    if(duServedCell->list.array == NULLP)
1189    {
1190       return RFAILED;
1191    }
1192    for(plmnidx=0; plmnidx<plmnCnt; plmnidx++)
1193    {
1194       DU_ALLOC(duServedCell->list.array[plmnidx],\
1195             sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1196       if(duServedCell->list.array[plmnidx] == NULLP)
1197       {
1198          return RFAILED;
1199       }
1200    }
1201    idx = 0;
1202    duServedCell->list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_Served_Cells_Item;
1203    duServedCell->list.array[idx]->criticality = Criticality_reject;
1204    duServedCell->list.array[idx]->value.present = \
1205                                                   GNB_DU_Served_Cells_ItemIEs__value_PR_GNB_DU_Served_Cells_Item;
1206    srvCellItem = \
1207                  &duServedCell->list.array[idx]->value.choice.GNB_DU_Served_Cells_Item;
1208    /*nRCGI*/
1209    BuildNrcgiret = BuildNrcgi(&srvCellItem->served_Cell_Information.nRCGI);
1210    if(BuildNrcgiret != ROK)
1211    {
1212       return RFAILED;
1213    }
1214    /*nRPCI*/
1215    srvCellItem->served_Cell_Information.nRPCI = \
1216                                                 duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
1217
1218    /*fiveGS_TAC*/
1219    BuildFiveGSTacret = BuildFiveGSTac(&srvCellItem->served_Cell_Information);
1220    if(BuildFiveGSTacret != ROK)
1221    {
1222       return RFAILED;
1223    }
1224    /*Served PLMNs*/
1225    BuildServedPlmnret = BuildServedPlmn(&srvCellItem->served_Cell_Information.servedPLMNs);
1226    if(BuildServedPlmnret !=ROK)
1227    {
1228       return RFAILED;
1229    }
1230    /*nR Mode Info with FDD*/
1231    BuildNrModeret = BuildNrMode(&srvCellItem->served_Cell_Information.nR_Mode_Info);
1232    if(BuildNrModeret != ROK)
1233    {
1234       return RFAILED;
1235    }
1236    /*Measurement timing Config*/
1237    srvCellItem->served_Cell_Information.measurementTimingConfiguration.\
1238       size = sizeof(uint8_t);
1239    DU_ALLOC(srvCellItem->served_Cell_Information.\
1240          measurementTimingConfiguration.buf,srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1241    if(srvCellItem->served_Cell_Information.\
1242          measurementTimingConfiguration.buf == NULLP)
1243    {
1244       return RFAILED;
1245    }
1246    srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf[0] = \
1247                                                                                 duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
1248
1249    /* GNB DU System Information */
1250    DU_ALLOC(srvCellItem->gNB_DU_System_Information,
1251          sizeof(GNB_DU_System_Information_t));
1252    if(!srvCellItem->gNB_DU_System_Information)
1253    {
1254       return RFAILED;
1255    }
1256    /* MIB */
1257    srvCellItem->gNB_DU_System_Information->mIB_message.size = duCfgParam.srvdCellLst[0].duSysInfo.mibLen;
1258    DU_ALLOC(srvCellItem->gNB_DU_System_Information->mIB_message.buf,
1259          srvCellItem->gNB_DU_System_Information->mIB_message.size);
1260    if(!srvCellItem->gNB_DU_System_Information->mIB_message.buf)
1261    {
1262       return RFAILED;
1263    }
1264    memcpy(srvCellItem->gNB_DU_System_Information->mIB_message.buf, duCfgParam.srvdCellLst[0].duSysInfo.mibMsg, \
1265                    srvCellItem->gNB_DU_System_Information->mIB_message.size);
1266
1267    /* SIB1 */
1268    srvCellItem->gNB_DU_System_Information->sIB1_message.size =\
1269                                                               duCfgParam.srvdCellLst[0].duSysInfo.sib1Len;
1270
1271    DU_ALLOC(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,
1272          srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1273    if(!srvCellItem->gNB_DU_System_Information->sIB1_message.buf)
1274    {
1275       return RFAILED;
1276    }
1277    for(int x=0; x<srvCellItem->gNB_DU_System_Information->sIB1_message.size; x++)
1278    {
1279       srvCellItem->gNB_DU_System_Information->sIB1_message.buf[x]=\
1280                                                                   duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg[x];
1281    }
1282    return ROK;
1283 }
1284 /*******************************************************************
1285  *
1286  * @brief Builds RRC Version
1287  *
1288  * @details
1289  *
1290  *    Function : BuildRrcVer
1291  *
1292  *    Functionality: Building RRC Version
1293  *
1294  * @params[in] int idx,int elementCnt,RRC_Version_t *rrcver
1295  * @return ROK     - success
1296  *         RFAILED - failure
1297  *
1298  * ****************************************************************/
1299 uint8_t BuildRrcVer(RRC_Version_t *rrcVer)
1300 {
1301    uint8_t rrcExt;
1302    uint8_t rrcLatest;
1303    rrcVer->latest_RRC_Version.size = sizeof(uint8_t);
1304    DU_ALLOC(rrcVer->latest_RRC_Version.buf,sizeof(uint8_t));
1305    if(rrcVer->latest_RRC_Version.buf == NULLP)
1306    {
1307       return RFAILED;
1308    }
1309    rrcVer->latest_RRC_Version.buf[0] = 0;
1310    rrcVer->latest_RRC_Version.bits_unused = 5;
1311    DU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1312    if(rrcVer->iE_Extensions == NULLP)
1313    {
1314       return RFAILED;
1315    }
1316    rrcVer->iE_Extensions->list.count = 1;
1317    rrcVer->iE_Extensions->list.size = sizeof(RRC_Version_ExtIEs_t *);
1318    DU_ALLOC(rrcVer->iE_Extensions->list.array,rrcVer->iE_Extensions->list.size);
1319    if(rrcVer->iE_Extensions->list.array == NULLP)
1320    {
1321       return RFAILED;
1322    }
1323    rrcExt = 0;
1324    DU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
1325          sizeof(RRC_Version_ExtIEs_t));
1326    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
1327    {
1328       return RFAILED;
1329    }
1330    rrcVer->iE_Extensions->list.array[rrcExt]->id = \
1331                                                    ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
1332    rrcVer->iE_Extensions->list.array[rrcExt]->criticality = Criticality_reject;
1333    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.present =\
1334                                                                       RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
1335    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1336       .Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
1337    DU_ALLOC(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1338          .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1339          array[rrcExt]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1340    if(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1341          .Latest_RRC_Version_Enhanced.buf == NULLP)
1342    {
1343       return RFAILED;
1344    }
1345    rrcLatest = 0;
1346    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1347       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 15;
1348    rrcLatest++;
1349    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1350       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 5;
1351    rrcLatest++;
1352    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1353       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 0;
1354    return ROK;
1355 }
1356 /*******************************************************************
1357  *
1358  * @brief Sends F1 msg over SCTP
1359  *
1360  * @details
1361  *
1362  *    Function : sendF1APMsg
1363  *
1364  *    Functionality: Sends F1 msg over SCTP
1365  *
1366  * @params[in] Region region
1367  *             Pool pool
1368  * @return ROK     - success
1369  *         RFAILED - failure
1370  *
1371  * ****************************************************************/
1372 uint8_t sendF1APMsg()
1373 {
1374    Buffer *mBuf = NULLP;
1375
1376    if(ODU_GET_MSG_BUF(DU_APP_MEM_REGION, DU_POOL, &mBuf) == ROK)
1377    {
1378       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
1379       {
1380             ODU_PRINT_MSG(mBuf, 0,0);
1381
1382             if(sctpSend(mBuf, F1_INTERFACE) != ROK)
1383             {
1384                DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
1385                ODU_PUT_MSG_BUF(mBuf);
1386                return RFAILED;
1387             }
1388       }
1389       else
1390       {
1391          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
1392          ODU_PUT_MSG_BUF(mBuf);
1393          return RFAILED;
1394       }
1395       ODU_PUT_MSG_BUF(mBuf);
1396    }
1397    else
1398    {
1399       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
1400       return RFAILED;
1401    }
1402    return ROK;
1403 } /* sendF1APMsg */
1404
1405 /*******************************************************************
1406  *
1407  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1408  *
1409  * @details
1410  *
1411  *    Function :  FreeRrcVer
1412  *
1413  *    Functionality: deallocating the memory of function BuildRrcVer
1414  *
1415  * @params[in] RRC_Version_t *rrcVer
1416  *
1417  * @return void
1418  *
1419  *****************************************************************/
1420 void FreeRrcVer(RRC_Version_t *rrcVer)
1421 {
1422    if(rrcVer->latest_RRC_Version.buf != NULLP)
1423    {
1424       if(rrcVer->iE_Extensions != NULLP)
1425       {
1426          if(rrcVer->iE_Extensions->list.array != NULLP)
1427          {
1428             if(rrcVer->iE_Extensions->list.array[0] != NULLP)
1429             {
1430                if(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf
1431                      != NULLP)
1432                {
1433                   DU_FREE(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice\
1434                         .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1435                         array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1436                }
1437                DU_FREE(rrcVer->iE_Extensions->list.array[0],sizeof(RRC_Version_ExtIEs_t));
1438             }
1439             DU_FREE(rrcVer->iE_Extensions->list.array,sizeof(RRC_Version_ExtIEs_t*));
1440          }
1441          DU_FREE(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1442       }
1443       DU_FREE(rrcVer->latest_RRC_Version.buf,rrcVer->latest_RRC_Version.size);
1444    }
1445 }
1446 /*******************************************************************
1447  *
1448  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1449  *
1450  * @details
1451  *
1452  *    Function :  FreeServedCellList
1453  *
1454  *    Functionality:  deallocating the memory of function BuildServedCellList
1455
1456  *
1457  * @params[in] GNB_DU_Served_Cells_List_t *duServedCell
1458  *
1459  * @return void
1460  *
1461  * ****************************************************************/
1462 void FreeServedCellList( GNB_DU_Served_Cells_List_t *duServedCell)
1463 {
1464    uint8_t   plmnCnt=MAX_PLMN;
1465    uint8_t  extensionCnt=IE_EXTENSION_LIST_COUNT;
1466    uint8_t  plmnIdx=0, sliceIdx=0;
1467    GNB_DU_Served_Cells_Item_t *srvCellItem;
1468    ServedPLMNs_Item_t  *servedPlmnItem;
1469    SliceSupportItem_t  *sliceSupportItem;
1470
1471    if(duServedCell->list.array!=NULLP)
1472    {
1473       if(duServedCell->list.array[0]!=NULLP)
1474       {
1475          srvCellItem= &duServedCell->list.array[0]->value.choice.GNB_DU_Served_Cells_Item;
1476
1477          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1478                srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size * sizeof(uint8_t));
1479          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1480                srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size * sizeof(uint8_t));
1481
1482          if(srvCellItem->served_Cell_Information.fiveGS_TAC!=NULLP)
1483          {
1484             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
1485                   sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
1486             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,sizeof(FiveGS_TAC_t));
1487          }
1488
1489          if(srvCellItem->served_Cell_Information.servedPLMNs.list.array!=NULLP)
1490          {
1491             if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx] != NULLP)
1492             {
1493                servedPlmnItem = srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx];
1494                DU_FREE(servedPlmnItem->pLMN_Identity.buf, servedPlmnItem->pLMN_Identity.size);
1495
1496                if(servedPlmnItem->iE_Extensions != NULLP)
1497                {
1498                   if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1499                   {
1500                      if(servedPlmnItem->iE_Extensions->list.array[0] != NULLP)
1501                      {
1502                         if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1503                         SliceSupportList.list.array != NULLP)
1504                         {
1505                            for(sliceIdx =0; sliceIdx<servedPlmnItem->iE_Extensions->list.array[0]->\
1506                            extensionValue.choice.SliceSupportList.list.count; sliceIdx++)
1507                            {
1508                               if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1509                               SliceSupportList.list.array[sliceIdx] != NULLP)
1510                               {
1511                                  sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[0]->\
1512                                  extensionValue.choice.SliceSupportList.list.array[sliceIdx];
1513
1514                                  DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sizeof(uint8_t));
1515
1516                                  if(sliceSupportItem->sNSSAI.sD != NULLP)
1517                                  {
1518                                     DU_FREE(sliceSupportItem->sNSSAI.sD->buf,\
1519                                     sliceSupportItem->sNSSAI.sD->size);
1520                                     DU_FREE(sliceSupportItem->sNSSAI.sD, sizeof(OCTET_STRING_t));
1521                                  }
1522
1523                                  DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.\
1524                                  choice.SliceSupportList.list.array[sliceIdx], sizeof(SliceSupportItem_t));
1525                               }
1526                            }
1527                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1528                            SliceSupportList.list.array, servedPlmnItem->iE_Extensions->list.array[0]->\
1529                            extensionValue.choice.SliceSupportList.list.size);
1530                         }
1531                         DU_FREE(servedPlmnItem->iE_Extensions->list.array[0],\
1532                         sizeof(ServedPLMNs_ItemExtIEs_t));
1533                      }
1534                      DU_FREE(servedPlmnItem->iE_Extensions->list.array,\
1535                      extensionCnt*sizeof(ServedPLMNs_ItemExtIEs_t*));
1536                   }
1537                   DU_FREE(servedPlmnItem->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P3_t));
1538                }
1539                DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx],\
1540                sizeof(ServedPLMNs_Item_t));
1541             }
1542             DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array,\
1543             sizeof(ServedPLMNs_Item_t *));
1544          }
1545
1546          if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD != NULLP)
1547          {
1548             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
1549                   freqBandListNr.list.array != NULLP)
1550             {
1551                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
1552                uL_NRFreqInfo.freqBandListNr.list.array[0],sizeof(FreqBandNrItem_t));
1553                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
1554                uL_NRFreqInfo.freqBandListNr.list.array,sizeof(FreqBandNrItem_t*));
1555             }
1556
1557             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1558                   freqBandListNr.list.array)
1559             {
1560                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1561                      freqBandListNr.list.array[0],sizeof(FreqBandNrItem_t));
1562                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1563                      freqBandListNr.list.array,sizeof(FreqBandNrItem_t *));
1564             }
1565             DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD, sizeof(FDD_Info_t));
1566          }
1567
1568          DU_FREE(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1569                srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1570
1571          if(srvCellItem->gNB_DU_System_Information != NULLP)
1572          {
1573             if(srvCellItem->gNB_DU_System_Information->mIB_message.buf != NULLP)
1574             {
1575                DU_FREE(srvCellItem->gNB_DU_System_Information->mIB_message.buf,\
1576                      srvCellItem->gNB_DU_System_Information->mIB_message.size);
1577             }
1578
1579             if(srvCellItem->gNB_DU_System_Information->sIB1_message.buf != NULLP)
1580             {
1581                DU_FREE(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,\
1582                      srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1583             }
1584
1585             DU_FREE(srvCellItem->gNB_DU_System_Information, sizeof(GNB_DU_System_Information_t));
1586          }
1587
1588          DU_FREE(duServedCell->list.array[0], sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1589       }
1590       DU_FREE(duServedCell->list.array, plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t*));
1591    }
1592 }
1593
1594 /*******************************************************************
1595  *
1596  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1597  *
1598  * @details
1599  *
1600  *    Function :  FreeF1SetupReq
1601  *
1602  *    Functionality:  deallocating the memory of function BuildAndSendF1SetupReq
1603  *
1604  * @params[in] F1AP_PDU_t *f1apMsg
1605  *
1606  * @return void
1607  *
1608  * ****************************************************************/
1609 void FreeF1SetupReq(F1AP_PDU_t *f1apMsg)
1610 {
1611    uint8_t ieIdx, ieIdx2;
1612    F1SetupRequest_t *f1SetupReq=NULLP;
1613
1614    if(f1apMsg != NULLP)
1615    {
1616       if(f1apMsg->choice.initiatingMessage != NULLP)
1617       {
1618          f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1619          if(f1SetupReq->protocolIEs.list.array != NULLP)
1620          {
1621             for(ieIdx = 0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
1622             {
1623                if(f1SetupReq->protocolIEs.list.array[ieIdx] != NULLP)
1624                {
1625                   switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
1626                   {
1627                      case ProtocolIE_ID_id_TransactionID:
1628                         break;
1629                      case ProtocolIE_ID_id_gNB_DU_ID:
1630                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1631                               f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1632                         break;
1633                      case ProtocolIE_ID_id_gNB_DU_Name:
1634                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,\
1635                               strlen((char *)duCfgParam.duName));
1636                         break;
1637                      case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
1638                         FreeServedCellList(&f1SetupReq->protocolIEs.list.\
1639                               array[ieIdx]->value.choice.GNB_DU_Served_Cells_List);
1640                         break;
1641                      case ProtocolIE_ID_id_GNB_DU_RRC_Version:
1642                         FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version);
1643                         break;
1644                      default:
1645                         DU_LOG("\nERROR  -->  Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id);
1646                         break;
1647                   }
1648                }
1649             }
1650             for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++)
1651             {
1652                DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx2],sizeof(F1SetupRequestIEs_t));
1653             }
1654             DU_FREE(f1SetupReq->protocolIEs.list.array,\
1655                   f1SetupReq->protocolIEs.list.size);
1656          }
1657          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1658       }
1659       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1660    }
1661 }
1662 /*******************************************************************
1663  *
1664  * @brief Builds and Send the F1SetupRequest
1665  *
1666  * @details
1667  *
1668  *    Function : BuildAndSendF1SetupReq
1669  *
1670  * Functionality:Fills the F1SetupRequest
1671  *
1672  * @return ROK     - success
1673  *         RFAILED - failure
1674  *
1675  ******************************************************************/
1676 uint8_t BuildAndSendF1SetupReq()
1677 {
1678    uint8_t   ret, ieIdx, elementCnt;
1679    F1AP_PDU_t                 *f1apMsg = NULLP;
1680    F1SetupRequest_t           *f1SetupReq=NULLP;
1681    GNB_DU_Served_Cells_List_t *duServedCell=NULLP;
1682    RRC_Version_t              *rrcVer=NULLP;
1683    asn_enc_rval_t             encRetVal;        /* Encoder return value */
1684    ret= RFAILED;
1685
1686    DU_LOG("\nINFO   -->  F1AP : Building F1 Setup Request\n");
1687    do
1688    {
1689       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1690       if(f1apMsg == NULLP)
1691       {
1692          break;
1693       }
1694       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1695       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1696       if(f1apMsg->choice.initiatingMessage == NULLP)
1697       {
1698          break;
1699       }
1700       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_F1Setup;
1701       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
1702       f1apMsg->choice.initiatingMessage->value.present = \
1703                                                          InitiatingMessage__value_PR_F1SetupRequest;
1704
1705       f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1706
1707       elementCnt = (duCfgParam.duName != NULL) ? 5 : 4;
1708
1709       f1SetupReq->protocolIEs.list.count = elementCnt;
1710       f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t );
1711
1712       /* Initialize the F1Setup members */
1713       DU_ALLOC(f1SetupReq->protocolIEs.list.array,f1SetupReq->protocolIEs.list.size);
1714       if(f1SetupReq->protocolIEs.list.array == NULLP)
1715       {
1716          break;
1717       }
1718       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
1719       {
1720          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx],\
1721                sizeof(F1SetupRequestIEs_t));
1722          if(f1SetupReq->protocolIEs.list.array[ieIdx] == NULLP)
1723          {
1724             break;
1725          }
1726       }
1727
1728       ieIdx = 0;
1729       /*TransactionID*/
1730       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransactionID;
1731       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1732       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present =\
1733                                                                F1SetupRequestIEs__value_PR_TransactionID;
1734       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = \
1735                                                                              TRANS_ID;
1736
1737       /*DU ID*/
1738       ieIdx++;
1739       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
1740       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1741       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1742                                                                 F1SetupRequestIEs__value_PR_GNB_DU_ID;
1743       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size =\
1744                                                                              sizeof(uint8_t);
1745
1746       DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1747             f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1748       if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == \
1749             NULLP)
1750       {
1751          break;
1752       }
1753
1754       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] =\
1755          duCfgParam.duId;
1756
1757       /*DU Name*/
1758       if(duCfgParam.duName != NULL)
1759       {
1760          ieIdx++;
1761          f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_Name;
1762          f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
1763          f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = F1SetupRequestIEs__value_PR_GNB_DU_Name;
1764          f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.size =\
1765             strlen((char *)duCfgParam.duName);
1766          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.\
1767                GNB_DU_Name.buf, strlen((char *)duCfgParam.duName));
1768          if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.\
1769                buf == NULLP)
1770          {
1771             break;
1772          }
1773          strcpy((char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.\
1774                choice.GNB_DU_Name.buf,
1775                (char*)&duCfgParam.duName);
1776
1777       }
1778
1779       /*Served Cell list */
1780       ieIdx++;
1781       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1782                                                      ProtocolIE_ID_id_gNB_DU_Served_Cells_List;
1783       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1784       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1785                                                                 F1SetupRequestIEs__value_PR_GNB_DU_Served_Cells_List;
1786       duServedCell = &f1SetupReq->protocolIEs.list.\
1787                      array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
1788       if(BuildServedCellList(duServedCell))
1789       {
1790          break;
1791       }
1792       /*RRC Version*/
1793       ieIdx++;
1794       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1795                                                      ProtocolIE_ID_id_GNB_DU_RRC_Version ;
1796       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1797       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1798                                                                 F1SetupRequestIEs__value_PR_RRC_Version;
1799       rrcVer = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
1800       if(BuildRrcVer(rrcVer))
1801       {
1802          break;
1803       }
1804       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1805
1806       /* Encode the F1SetupRequest type as APER */
1807       memset(encBuf, 0, ENC_BUF_MAX_LEN);
1808       encBufSize = 0;
1809       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1810             encBuf);
1811
1812       /* Encode results */
1813       if(encRetVal.encoded == ENCODE_FAIL)
1814       {
1815          DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupRequest structure (at %s)\n",\
1816                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1817          break;
1818       }
1819       else
1820       {
1821          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1SetupRequest\n");
1822          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
1823          {
1824             printf("%x",encBuf[ieIdx]);
1825          }
1826       }
1827
1828       /* Sending msg */
1829       if(sendF1APMsg() != ROK)
1830       {
1831          DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup request failed");
1832          break;
1833       }
1834
1835       ret=ROK;
1836       break;
1837    }while(true);
1838
1839    FreeF1SetupReq(f1apMsg);
1840
1841    return ret;
1842 }/* End of BuildAndSendF1SetupReq */
1843
1844 /*******************************************************************
1845  *
1846  * @brief Deallocating memory allocated for Served_Cells_To_Modify_Item_t
1847  *
1848  * @details
1849  *
1850  *    Function : freeCellsToModifyItem
1851  *
1852  *    Functionality: Deallocating memory of variables allocated in
1853  *                    BuildAndSendDUConfigUpdate function
1854  *
1855  * @params[in]  Served_Cells_To_Modify_Item_t *modifyItem
1856  *
1857  * @return ROK     - void
1858  *
1859  * ****************************************************************/
1860
1861 void freeCellsToModifyItem(Served_Cells_To_Modify_Item_t *modifyItem)
1862 {
1863    uint8_t arrIdx=0, servedPlmnIdx=0, sliceLstIdx=0;
1864    ServedPLMNs_Item_t *servedPlmnItem = NULLP;
1865    SliceSupportItem_t *sliceSupportItem = NULLP;
1866
1867    DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf, modifyItem->oldNRCGI.pLMN_Identity.size);
1868    DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf, modifyItem->oldNRCGI.nRCellIdentity.size);
1869
1870    DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1871            modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
1872    DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1873          modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
1874
1875    if(modifyItem->served_Cell_Information.servedPLMNs.list.array != NULLP)
1876    {
1877       if(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx] != NULLP)
1878       {
1879          servedPlmnItem = modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx];
1880
1881          DU_FREE(servedPlmnItem->pLMN_Identity.buf,servedPlmnItem->pLMN_Identity.size);
1882
1883          if(servedPlmnItem->iE_Extensions != NULLP)
1884          {
1885             if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1886             {
1887                if(servedPlmnItem->iE_Extensions->list.array[arrIdx] != NULLP)
1888                {
1889                   if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1890                         list.array != NULLP)
1891                   {
1892                      for(sliceLstIdx =0; sliceLstIdx<servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
1893                            extensionValue.choice.SliceSupportList.list.count; sliceLstIdx++)
1894                      {
1895                         if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1896                               list.array[sliceLstIdx] != NULLP)
1897                         {
1898
1899                            sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1900                                               SliceSupportList.list.array[sliceLstIdx];
1901
1902                            DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sliceSupportItem->sNSSAI.sST.size);
1903                            if(sliceSupportItem->sNSSAI.sD != NULLP)
1904                            {
1905                               DU_FREE(sliceSupportItem->sNSSAI.sD->buf, sliceSupportItem->sNSSAI.sD->size);
1906                               DU_FREE(sliceSupportItem->sNSSAI.sD,sizeof(OCTET_STRING_t));
1907                            }
1908                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1909                                  SliceSupportList.list.array[sliceLstIdx], sizeof(SliceSupportItem_t));
1910                         }
1911                      }
1912                      DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.\
1913                            choice.SliceSupportList.list.array,\
1914                            servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
1915                            extensionValue.choice.SliceSupportList.list.size);
1916                   }
1917                }
1918                for(servedPlmnIdx=0; servedPlmnIdx< servedPlmnItem->iE_Extensions->list.count ; servedPlmnIdx++)
1919                {
1920                   DU_FREE(servedPlmnItem->iE_Extensions->list.array[servedPlmnIdx], sizeof(ServedPLMNs_ItemExtIEs_t ));
1921                }
1922                DU_FREE(servedPlmnItem->iE_Extensions->list.array, servedPlmnItem->iE_Extensions->list.size);
1923             }
1924             DU_FREE(servedPlmnItem->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1925          }
1926       }
1927       for(servedPlmnIdx=0; servedPlmnIdx<modifyItem->served_Cell_Information.servedPLMNs.list.count; servedPlmnIdx++)
1928       {
1929          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[servedPlmnIdx], sizeof(ServedPLMNs_Item_t));
1930       }
1931       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1932          modifyItem->served_Cell_Information.servedPLMNs.list.size);
1933    }
1934
1935    if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD != NULLP)
1936    {
1937       if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1938       {
1939          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
1940                array[arrIdx], sizeof(FreqBandNrItem_t));
1941          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array, \
1942                modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1943       }
1944
1945       if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1946       {
1947          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.\
1948              array[arrIdx], sizeof(FreqBandNrItem_t));
1949          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,\
1950                modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1951       }
1952       DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD,sizeof(FDD_Info_t));
1953    }
1954
1955    DU_FREE(modifyItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1956       modifyItem->served_Cell_Information.measurementTimingConfiguration.size);
1957 }
1958
1959 /*******************************************************************
1960  *
1961  * @brief Deallocating memory of BuildAndSendDUConfigUpdate
1962  *
1963  * @details
1964  *
1965  *    Function : FreeDUConfigUpdate
1966  *
1967  *    Functionality: Deallocating memory of variables allocated in
1968  *                    BuildAndSendDUConfigUpdate function
1969  *
1970  * @params[in]  F1AP_PDU_t *f1apDuCfg
1971  *
1972  * @return ROK     - void
1973  *
1974  * ****************************************************************/
1975 void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg)
1976 {
1977    uint8_t  ieIdx=0, cellModifyIdx=0, cellDeleteIdx=0;
1978    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
1979    Served_Cells_To_Modify_List_t  *cellsToModify=NULLP;
1980    Served_Cells_To_Delete_List_t  *cellsToDelete=NULLP;
1981    Served_Cells_To_Delete_Item_t  *deleteItem = NULLP;
1982    Served_Cells_To_Delete_ItemIEs_t *deleteItemIe = NULLP;
1983
1984    if(f1apDuCfg != NULLP)
1985    {
1986       if(f1apDuCfg->choice.initiatingMessage != NULLP)
1987       {
1988          duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->\
1989                        value.choice.GNBDUConfigurationUpdate;
1990          if(duCfgUpdate->protocolIEs.list.array != NULLP)
1991          {
1992             for(ieIdx=0; ieIdx<duCfgUpdate->protocolIEs.list.count; ieIdx++)
1993             {
1994                if(duCfgUpdate->protocolIEs.list.array[ieIdx] != NULLP)
1995                {
1996                   switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
1997                   {
1998                      case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
1999                         {
2000                            cellsToModify = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
2001                                            value.choice.Served_Cells_To_Modify_List;
2002                            if(cellsToModify->list.array != NULLP)
2003                            {
2004                               for(cellModifyIdx=0; cellModifyIdx<cellsToModify->list.count ;cellModifyIdx++)
2005                               {
2006                                  if(cellsToModify->list.array[cellModifyIdx] != NULLP)
2007                                  {
2008                                     freeCellsToModifyItem(&cellsToModify->list.array[cellModifyIdx]->value.choice.\
2009                                           Served_Cells_To_Modify_Item);
2010                                     DU_FREE(cellsToModify->list.array[cellModifyIdx],\
2011                                           sizeof(Served_Cells_To_Modify_ItemIEs_t));
2012                                  }
2013                               }
2014                               DU_FREE(cellsToModify->list.array,cellsToModify->list.size);
2015                            }
2016                            break;
2017                         }
2018                      case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
2019                         {
2020                            cellsToDelete = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
2021                                            value.choice.Served_Cells_To_Delete_List;
2022                            if(cellsToDelete->list.array != NULLP)
2023                            {
2024                               for(cellDeleteIdx=0; cellDeleteIdx<cellsToDelete->list.count ;cellDeleteIdx++)
2025                               {
2026                                  if(cellsToDelete->list.array[cellDeleteIdx] != NULLP)
2027                                  {
2028                                     deleteItemIe = ((Served_Cells_To_Delete_ItemIEs_t*)\
2029                                           cellsToDelete->list.array[cellDeleteIdx]);
2030                                     deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
2031                                     DU_FREE(deleteItem->oldNRCGI.pLMN_Identity.buf,\
2032                                           deleteItem->oldNRCGI.pLMN_Identity.size);
2033                                     DU_FREE(deleteItem->oldNRCGI.nRCellIdentity.buf,\
2034                                           deleteItem->oldNRCGI.nRCellIdentity.size);
2035                                     DU_FREE(cellsToDelete->list.array[cellDeleteIdx],\
2036                                           sizeof(Served_Cells_To_Delete_ItemIEs_t));
2037                                  }
2038                               }
2039                               DU_FREE(cellsToDelete->list.array,cellsToDelete->list.size);
2040                            }
2041
2042                            break;
2043                         }
2044                      case ProtocolIE_ID_id_gNB_DU_ID:
2045                         {
2046                            DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2047                                  duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2048                            break;
2049                         }
2050                   }
2051                   DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx],\
2052                         sizeof(GNBDUConfigurationUpdateIEs_t));
2053                }
2054             }
2055             DU_FREE(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2056          }
2057          DU_FREE(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2058       }
2059       DU_FREE(f1apDuCfg, (Size)sizeof(F1AP_PDU_t));
2060    }
2061 }
2062
2063 /*******************************************************************
2064  *
2065  * @brief Fills Served Plmns required in ServCellInfo IE
2066  *
2067  * @details
2068  *
2069  *    Function : fillServedPlmns
2070  *
2071  *    Functionality: Fills Served Plmns required in ServCellInfo IE
2072  *
2073  * @params[in] Pointer to ServedPLMNs_List_t *
2074  *
2075  * @return ROK     - success
2076  *         RFAILED - failure
2077  *
2078  *****************************************************************/
2079
2080 uint8_t fillServedPlmns(ServedPLMNs_List_t *servedPlmn)
2081 {
2082    uint8_t ieIdx=0, arrayIdx=0, ieListCnt=0, elementCnt=0, sliceLstIdx=0;
2083
2084    servedPlmn->list.array[arrayIdx]->pLMN_Identity.size = 3*sizeof(uint8_t);
2085    DU_ALLOC(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf, servedPlmn->list.\
2086          array[arrayIdx]->pLMN_Identity.size);
2087    if(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf == NULLP)
2088    {
2089       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2090       return RFAILED;
2091    }
2092    buildPlmnId(duCfgParam.srvdCellLst[arrayIdx].duCellInfo.cellInfo.srvdPlmn[arrayIdx].plmn,\
2093          servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf);
2094    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
2095    if(servedPlmn->list.array[arrayIdx]->iE_Extensions == NULLP)
2096    {
2097       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2098       return RFAILED;
2099    }
2100
2101    ieListCnt=1;
2102    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.count = ieListCnt;
2103    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.size = ieListCnt *sizeof(ServedPLMNs_ItemExtIEs_t *);
2104    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array,servedPlmn->list.array[arrayIdx]->\
2105          iE_Extensions->list.size);
2106    if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array == NULLP)
2107    {
2108       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2109       return RFAILED;
2110    }
2111    for(ieIdx=arrayIdx;ieIdx<ieListCnt;ieIdx++)
2112    {
2113       DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx],\
2114             sizeof(ServedPLMNs_ItemExtIEs_t));
2115       if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx] == NULLP)
2116       {
2117          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2118          return RFAILED;
2119       }
2120    }
2121
2122    ieIdx = 0;
2123    elementCnt = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].taiSliceSuppLst.numSupportedSlices;
2124    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->id =ProtocolIE_ID_id_TAISliceSupportList;
2125    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->criticality = Criticality_ignore;
2126    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.present = \
2127    ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
2128    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2129       list.count = elementCnt;
2130    servedPlmn->list.array[arrayIdx]->\
2131       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2132       list.size = elementCnt * sizeof(SliceSupportItem_t *);
2133    DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2134          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2135          list.array,servedPlmn->list.array[arrayIdx]->\
2136          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.size);
2137    if(servedPlmn->list.array[arrayIdx]->\
2138          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2139          list.array == NULLP)
2140    {
2141       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2142       return RFAILED;
2143    }
2144
2145    for(sliceLstIdx =0; sliceLstIdx< elementCnt; sliceLstIdx++)
2146    {
2147       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2148       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2149       list.array[sliceLstIdx],sizeof( SliceSupportItem_t));
2150       if(servedPlmn->list.array[arrayIdx]->\
2151       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2152       list.array[sliceLstIdx] == NULLP)
2153       {
2154          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2155          return RFAILED;
2156       }
2157
2158       servedPlmn->list.array[arrayIdx]->\
2159       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2160       list.array[sliceLstIdx]->sNSSAI.sST.size = sizeof(uint8_t);
2161       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2162       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2163       list.array[sliceLstIdx]->sNSSAI.sST.buf,servedPlmn->list.array[arrayIdx]->\
2164       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->\
2165       sNSSAI.sST.size);
2166
2167       if(servedPlmn->list.array[arrayIdx]->\
2168       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2169       list.array[sliceLstIdx]->sNSSAI.sST.buf == NULLP)
2170       {
2171          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2172          return RFAILED;
2173       }
2174       servedPlmn->list.array[arrayIdx]->\
2175       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2176       list.array[sliceLstIdx]->sNSSAI.sST.buf[arrayIdx] =  duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
2177       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
2178
2179       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2180       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2181       list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
2182       if(servedPlmn->list.array[arrayIdx]->\
2183       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2184       list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
2185       {
2186          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2187          return RFAILED;
2188       }
2189       servedPlmn->list.array[arrayIdx]->\
2190       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2191       list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
2192       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2193       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2194       list.array[sliceLstIdx]->sNSSAI.sD->buf,servedPlmn->list.array[arrayIdx]->\
2195       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2196       list.array[sliceLstIdx]->sNSSAI.sD->size);
2197       if(servedPlmn->list.array[arrayIdx]->\
2198       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2199       list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
2200       {
2201          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2202          return RFAILED;
2203       }
2204       memcpy(servedPlmn->list.array[arrayIdx]->\
2205       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2206       list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
2207       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sd,\
2208       servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2209       list.array[sliceLstIdx]->sNSSAI.sD->size);
2210    }
2211    return ROK;
2212 }
2213
2214 /*******************************************************************
2215  *
2216  * @brief Fills Nr Fdd Info required in ServCellInfo IE
2217  *
2218  * @details
2219  *
2220  *    Function : fillNrFddInfo
2221  *
2222  *    Functionality: Fills Nr Fdd Info required in ServCellInfo IE
2223  *
2224  * @params[in] Pointer to NR_Mode_Info_t *
2225  *
2226  * @return ROK     - success
2227  *         RFAILED - failure
2228  *
2229  *****************************************************************/
2230
2231 uint8_t fillNrFddInfo(NR_Mode_Info_t *nrFdd)
2232 {
2233    nrFdd->choice.fDD->uL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.\
2234       f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn;
2235    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.count = 1;
2236    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t*);
2237    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
2238          array, nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size);
2239    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2240    {
2241       return RFAILED;
2242    }
2243    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0], \
2244       sizeof(FreqBandNrItem_t));
2245    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2246    {
2247       return RFAILED;
2248    }
2249    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2250       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
2251       freqBand[0].nrFreqBand;
2252    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2253    nrFdd->choice.fDD->dL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.\
2254       dlNrFreqInfo.nrArfcn;
2255    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.count = 1;
2256    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
2257    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,nrFdd->\
2258          choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
2259    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2260    {
2261       return RFAILED;
2262    }
2263    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0],\
2264          sizeof(FreqBandNrItem_t));
2265    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2266    {
2267       return RFAILED;
2268    }
2269    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2270       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
2271       freqBand[0].nrFreqBand;
2272    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2273
2274    /*Transmission Bandwidth*/
2275    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2276       f1Mode.mode.fdd.ulTxBw.nrScs;
2277    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2278       f1Mode.mode.fdd.ulTxBw.nrb;
2279    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2280       f1Mode.mode.fdd.dlTxBw.nrScs;
2281    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2282       f1Mode.mode.fdd.dlTxBw.nrb;
2283
2284    return ROK;
2285 }
2286
2287 /*******************************************************************
2288  *
2289  * @brief Fills ServCellInfo IE
2290  *
2291  * @details
2292  *
2293  *    Function : fillServedCellInfo
2294  *
2295  *    Functionality: Fills ServCellInfo
2296  *
2297  * @params[in] Pointer to Served_Cell_Information_t *
2298  *
2299  * @return ROK     - success
2300  *         RFAILED - failure
2301  *
2302  *****************************************************************/
2303
2304 uint8_t fillServedCellInfo(Served_Cell_Information_t *srvCellInfo)
2305 {
2306    uint8_t tmp, ieIdx, ieListCnt;
2307
2308    /*nRCGI*/
2309    srvCellInfo->nRCGI.pLMN_Identity.size =3*sizeof(uint8_t);
2310    DU_ALLOC(srvCellInfo->nRCGI.pLMN_Identity.buf,\
2311          srvCellInfo->nRCGI.pLMN_Identity.size);
2312    if(srvCellInfo->nRCGI.pLMN_Identity.buf == NULLP)
2313    {
2314       return RFAILED;
2315    }
2316    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2317          srvCellInfo->nRCGI.pLMN_Identity.buf);
2318    srvCellInfo->nRCGI.nRCellIdentity.size =5*sizeof(uint8_t);
2319    DU_ALLOC(srvCellInfo->nRCGI.nRCellIdentity.buf,\
2320          srvCellInfo->nRCGI.nRCellIdentity.size);
2321    if(srvCellInfo->nRCGI.nRCellIdentity.buf == NULLP)
2322    {
2323       return RFAILED;
2324    }
2325    for (tmp = 0 ; tmp < srvCellInfo->\
2326          nRCGI.nRCellIdentity.size-1 ; tmp++)
2327    {
2328       srvCellInfo->nRCGI.nRCellIdentity.buf[tmp] = 0;
2329    }
2330    srvCellInfo->nRCGI.nRCellIdentity.buf[4] = 16;
2331    srvCellInfo->nRCGI.nRCellIdentity.bits_unused =4;
2332
2333    /*nRPCI*/
2334    srvCellInfo->nRPCI = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
2335
2336    /*servedPLMNs*/
2337    ieListCnt = 1;
2338    srvCellInfo->servedPLMNs.list.count = ieListCnt;
2339    srvCellInfo->servedPLMNs.list.size = ieListCnt*sizeof(ServedPLMNs_Item_t *);
2340    DU_ALLOC(srvCellInfo->servedPLMNs.list.array,\
2341          srvCellInfo->servedPLMNs.list.size);
2342    if(srvCellInfo->servedPLMNs.list.array == NULLP)
2343    {
2344       return RFAILED;
2345    }
2346    for(ieIdx=0; ieIdx < ieListCnt; ieIdx++)
2347    {
2348       DU_ALLOC(srvCellInfo->servedPLMNs.list.array[ieIdx],\
2349             sizeof(ServedPLMNs_Item_t));
2350       if(srvCellInfo->servedPLMNs.list.array[ieIdx]== NULLP)
2351       {
2352          return RFAILED;
2353       }
2354    }
2355    if(fillServedPlmns(&srvCellInfo->servedPLMNs))
2356    {
2357       return RFAILED;
2358    }
2359
2360    /*nR Mode Info with FDD*/
2361    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_fDD;
2362    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.fDD,\
2363          sizeof(FDD_Info_t));
2364    if(srvCellInfo->nR_Mode_Info.choice.fDD == NULLP)
2365    {
2366       return RFAILED;
2367    }
2368    if(fillNrFddInfo(&srvCellInfo->nR_Mode_Info))
2369       return RFAILED;
2370
2371    /*Measurement timing Config*/
2372    srvCellInfo->measurementTimingConfiguration.size = sizeof(uint8_t);
2373    DU_ALLOC(srvCellInfo->measurementTimingConfiguration.\
2374          buf,srvCellInfo->measurementTimingConfiguration.size);
2375    if(srvCellInfo->measurementTimingConfiguration.buf == NULLP)
2376    {
2377       return RFAILED;
2378    }
2379    srvCellInfo->measurementTimingConfiguration.\
2380          buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
2381
2382    return ROK;
2383 }
2384
2385 /*******************************************************************
2386  *
2387  * @brief Fills ServCellToModItem IE
2388  *
2389  * @details
2390  *
2391  *    Function : fillServCellToModItem
2392  *
2393  *    Functionality: Fills ServCellToModItem IE
2394  *
2395  * @params[in] Pointer to Served_Cells_To_Modify_Item_t *
2396  *
2397  * @return ROK     - success
2398  *         RFAILED - failure
2399  *
2400  *****************************************************************/
2401
2402 uint8_t fillServCellToModItem(Served_Cells_To_Modify_Item_t *modifyItem)
2403 {
2404    uint8_t ieIdx;
2405
2406    /*pLMN_Identity*/
2407    modifyItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2408    DU_ALLOC(modifyItem->oldNRCGI.pLMN_Identity.buf,modifyItem->oldNRCGI.pLMN_Identity.size);
2409    if(modifyItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2410    {
2411       return RFAILED;
2412    }
2413    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2414          modifyItem->oldNRCGI.pLMN_Identity.buf);
2415
2416    /*nRCellIdentity*/
2417    modifyItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2418    DU_ALLOC(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2419          modifyItem->oldNRCGI.nRCellIdentity.size);
2420    if(modifyItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2421    {
2422       return RFAILED;
2423    }
2424    for(ieIdx = 0; ieIdx < modifyItem->oldNRCGI.nRCellIdentity.size-1; ieIdx++)
2425    {
2426       modifyItem->oldNRCGI.nRCellIdentity.buf[ieIdx] = 0;
2427    }
2428    modifyItem->oldNRCGI.nRCellIdentity.buf[4] = 16;
2429    modifyItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
2430
2431    if(fillServedCellInfo(&modifyItem->served_Cell_Information))
2432       return RFAILED;
2433    else
2434       return ROK;
2435 }
2436
2437 /*******************************************************************
2438  *
2439  * @brief Builds ServCellToModList
2440  *
2441  * @details
2442  *
2443  *    Function : buildServCellToModList
2444  *
2445  *    Functionality: Builds the serv cell to Mod List
2446  *
2447  * @params[in] Pointer to Served_Cells_To_Modify_List_t *
2448  *
2449  * @return ROK     - success
2450  *         RFAILED - failure
2451  *
2452  *****************************************************************/
2453
2454 uint8_t buildServCellToModList(Served_Cells_To_Modify_List_t *cellsToModify)
2455 {
2456    uint8_t ieListCnt, ieIdx;
2457    Served_Cells_To_Modify_Item_t *modifyItem = NULLP;
2458
2459    ieListCnt = 1;
2460    cellsToModify->list.count = ieListCnt;
2461    cellsToModify->list.size = ieListCnt*sizeof(Served_Cells_To_Modify_ItemIEs_t *);
2462    DU_ALLOC(cellsToModify->list.array,cellsToModify->list.size);
2463    if(cellsToModify->list.array == NULLP)
2464    {
2465       return RFAILED;
2466    }
2467    for(ieIdx=0; ieIdx< ieListCnt; ieIdx++)
2468    {
2469       DU_ALLOC(cellsToModify->list.array[ieIdx],sizeof(Served_Cells_To_Modify_ItemIEs_t));
2470       if(cellsToModify->list.array[ieIdx] == NULLP)
2471       {
2472          return RFAILED;
2473       }
2474    }
2475    cellsToModify->list.array[0]->id = ProtocolIE_ID_id_Served_Cells_To_Modify_Item;
2476    cellsToModify->list.array[0]->criticality = Criticality_reject;
2477    cellsToModify->list.array[0]->value.present =\
2478       Served_Cells_To_Modify_ItemIEs__value_PR_Served_Cells_To_Modify_Item;
2479    modifyItem=&cellsToModify->list.array[0]->value.choice.Served_Cells_To_Modify_Item;
2480
2481    if(fillServCellToModItem(modifyItem))
2482       return RFAILED;
2483    else
2484       return ROK;
2485 }
2486 /*******************************************************************
2487  *
2488  * @brief filling the DeleteItemList
2489  *
2490  * @details
2491  *
2492  *    Function : fillCellToDeleteItem
2493  *
2494  *    Functionality: Filling the DeleteItemIe
2495  *
2496  * @params[in] Pointer to Served_Cells_To_Delete_ItemIEs_t
2497  *
2498  * @return ROK     - success
2499  *         RFAILED - failure
2500  *
2501  *****************************************************************/
2502 uint8_t fillCellToDeleteItem(struct Served_Cells_To_Delete_ItemIEs *deleteItemIe)
2503 {
2504    uint8_t arrIdx;
2505    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
2506
2507    deleteItemIe->id = ProtocolIE_ID_id_Served_Cells_To_Delete_Item;
2508    deleteItemIe->criticality = Criticality_reject;
2509    deleteItemIe->value.present =\
2510    Served_Cells_To_Delete_ItemIEs__value_PR_Served_Cells_To_Delete_Item;
2511    deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
2512
2513    /*pLMN_Identity*/
2514    deleteItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2515    DU_ALLOC(deleteItem->oldNRCGI.pLMN_Identity.buf,deleteItem->oldNRCGI.pLMN_Identity.size);
2516    if(deleteItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2517    {
2518       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2519       return RFAILED;
2520    }
2521    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2522          deleteItem->oldNRCGI.pLMN_Identity.buf);
2523
2524    /*nRCellIdentity*/
2525    deleteItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2526    DU_ALLOC(deleteItem->oldNRCGI.nRCellIdentity.buf,\
2527          deleteItem->oldNRCGI.nRCellIdentity.size);
2528    if(deleteItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2529    {
2530       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2531       return RFAILED;
2532    }
2533    for(arrIdx = 0; arrIdx < deleteItem->oldNRCGI.nRCellIdentity.size-1; arrIdx++)
2534    {
2535       deleteItem->oldNRCGI.nRCellIdentity.buf[arrIdx] = 0;
2536    }
2537    deleteItem->oldNRCGI.nRCellIdentity.buf[4] = 16;
2538    deleteItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
2539    return ROK;
2540 }
2541 /*******************************************************************
2542  *
2543  * @brief Builds ServCellToDeleteList
2544  *
2545  * @details
2546  *
2547  *    Function : buildServCellToDeleteList
2548  *
2549  *    Functionality: Builds the serv cell to delete List
2550  *
2551  * @params[in] Pointer to Served_Cells_To_Delete_List_t *
2552  *
2553  * @return ROK     - success
2554  *         RFAILED - failure
2555  *
2556  *****************************************************************/
2557
2558 uint8_t buildServCellToDeleteList(Served_Cells_To_Delete_List_t *cellsToDelete)
2559 {
2560    uint8_t ieListCnt, arrIdx;
2561
2562    ieListCnt = 1;
2563    cellsToDelete->list.count = ieListCnt;
2564    cellsToDelete->list.size = ieListCnt*sizeof(Served_Cells_To_Delete_ItemIEs_t *);
2565
2566    DU_ALLOC(cellsToDelete->list.array,cellsToDelete->list.size);
2567    if(cellsToDelete->list.array == NULLP)
2568    {
2569       DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2570       return RFAILED;
2571    }
2572
2573    for(arrIdx=0; arrIdx< ieListCnt; arrIdx++)
2574    {
2575       DU_ALLOC(cellsToDelete->list.array[arrIdx],sizeof(Served_Cells_To_Delete_ItemIEs_t));
2576       if(cellsToDelete->list.array[arrIdx] == NULLP)
2577       {
2578          DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2579          return RFAILED;
2580       }
2581    }
2582
2583    arrIdx=0;
2584    if(fillCellToDeleteItem((Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx]) !=ROK)
2585    {
2586       DU_LOG("\nERROR  -->  F1AP: buildServCellToDeleteList(): failed to fill Served_Cells_To_Delete_ItemIEs");
2587       return RFAILED;
2588    }
2589    return ROK;
2590 }
2591
2592 /*******************************************************************
2593  *
2594  * @brief Builds and sends the DUConfigUpdate
2595  *
2596  * @details
2597  *
2598  *    Function : BuildAndSendDUConfigUpdate
2599  *
2600  *    Functionality: Constructs the DU Update message and sends
2601  *                   it to the CU through SCTP.
2602  *
2603  * @params[in] void **buf,Buffer to which encoded pattern is written into
2604  * @params[in] int *size,size of buffer
2605  *
2606  * @return ROK     - success
2607  *         RFAILED - failure
2608  *
2609  * ****************************************************************/
2610 uint8_t BuildAndSendDUConfigUpdate(ServCellAction servCellAction)
2611 {
2612    uint8_t ret =0, ieIdx=0, elementCnt=0;
2613    bool memAlloctionFailure = false;
2614    F1AP_PDU_t                 *f1apDuCfg = NULLP;
2615    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
2616    asn_enc_rval_t encRetVal;     /* Encoder return value */
2617
2618    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2619    ret= RFAILED;
2620
2621    while(true)
2622    {
2623       DU_LOG("\nINFO   -->  F1AP : Building DU config update\n");
2624       /* Allocate the memory for F1DuCfg */
2625       DU_ALLOC(f1apDuCfg, sizeof(F1AP_PDU_t));
2626       if(f1apDuCfg == NULLP)
2627       {
2628          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2629          break;
2630       }
2631
2632       f1apDuCfg->present = F1AP_PDU_PR_initiatingMessage;
2633       DU_ALLOC(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2634       if(f1apDuCfg->choice.initiatingMessage == NULLP)
2635       {
2636          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2637          break;
2638       }
2639
2640       f1apDuCfg->choice.initiatingMessage->procedureCode = \
2641                                                            ProcedureCode_id_gNBDUConfigurationUpdate;
2642       f1apDuCfg->choice.initiatingMessage->criticality = Criticality_reject;
2643       f1apDuCfg->choice.initiatingMessage->value.present = \
2644                                                            InitiatingMessage__value_PR_GNBDUConfigurationUpdate;
2645       duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\
2646                     choice.GNBDUConfigurationUpdate;
2647       elementCnt = 3;
2648       duCfgUpdate->protocolIEs.list.count = elementCnt;
2649       duCfgUpdate->protocolIEs.list.size = \
2650                                            elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t*);
2651
2652       /* Initialize the F1Setup members */
2653       DU_ALLOC(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2654       if(duCfgUpdate->protocolIEs.list.array == NULLP)
2655       {
2656          DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2657          break;
2658       }
2659       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
2660       {
2661          DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx],sizeof(GNBDUConfigurationUpdateIEs_t));
2662          if(duCfgUpdate->protocolIEs.list.array[ieIdx] == NULLP)
2663          {
2664             DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2665             memAlloctionFailure = true;
2666             break;
2667          }
2668       }
2669
2670       if(memAlloctionFailure == true)
2671       {
2672          break;
2673       }
2674       /*TransactionID*/
2675       ieIdx = 0;
2676       duCfgUpdate->protocolIEs.list.array[ieIdx]->id=ProtocolIE_ID_id_TransactionID;
2677       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
2678       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2679       GNBDUConfigurationUpdateIEs__value_PR_TransactionID;
2680       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = TRANS_ID;
2681
2682       ieIdx++;
2683       if(servCellAction == SERV_CELL_TO_MODIFY)
2684       {
2685          /*Served Cell to Modify */
2686          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2687          ProtocolIE_ID_id_Served_Cells_To_Modify_List;
2688          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2689          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2690          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Modify_List;
2691          if(buildServCellToModList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2692                   Served_Cells_To_Modify_List))
2693          {
2694             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToModList");
2695             break;
2696          }
2697       }
2698       else
2699       {
2700          /*Served Cell to Delete */
2701          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2702          ProtocolIE_ID_id_Served_Cells_To_Delete_List;
2703          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2704          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2705          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Delete_List;
2706          if(buildServCellToDeleteList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2707          Served_Cells_To_Delete_List)!=ROK)
2708          {
2709             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToDeleteList");
2710             break;
2711          }
2712
2713       }
2714       // NOTE :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
2715       /*GNB DU ID */
2716       ieIdx++;
2717       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
2718       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
2719       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2720       GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID;
2721       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size = sizeof(uint8_t);
2722       DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2723             duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2724       if(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == NULLP)
2725       {
2726          DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): Memory allocation failed for GNB_DU_ID");
2727          break;
2728       }
2729       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] = duCfgParam.duId;
2730
2731       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
2732
2733       /* Encode the DU Config Update type as APER */
2734       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
2735       encBufSize = 0;
2736       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
2737
2738       /* Checking encode results */
2739       if(encRetVal.encoded == ENCODE_FAIL)
2740       {
2741          DU_LOG("ERROR  -->  F1AP : Could not encode DUConfigUpdate structure (at %s)\n",\
2742                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2743          break;
2744       }
2745       else
2746       {
2747          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DUConfigUpdate\n");
2748          for(ieIdx =0; ieIdx < encBufSize; ieIdx++)
2749          {
2750             printf("%x",encBuf[ieIdx]);
2751          }
2752       }
2753       /* Sending msg */
2754       if(sendF1APMsg() != ROK)
2755       {
2756          DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update failed");
2757          break;
2758       }
2759
2760       ret = ROK;
2761       break;
2762    }
2763
2764    addToReservedF1apPduList(TRANS_ID,f1apDuCfg);
2765    return ret;
2766 }
2767
2768
2769 /*******************************************************************
2770  *
2771  * @brief free the ULRRCMessageTransfer
2772  *
2773  * @details
2774  *
2775  *    Function : FreeULRRCMessageTransfer
2776  *
2777  *    Functionality: Deallocating the memory of variable allocated in
2778  *                      FreeULRRCMessageTransfer
2779  *
2780  * @params[in]
2781  *
2782  * @return ROK     - void
2783  *
2784  ******************************************************************/
2785 void FreeULRRCMessageTransfer( F1AP_PDU_t *f1apMsg)
2786 {
2787    uint8_t idx1;
2788    ULRRCMessageTransfer_t  *ulRRCMsg;
2789
2790    if(f1apMsg != NULLP)
2791    {
2792       if(f1apMsg->choice.initiatingMessage != NULLP)
2793       {
2794          ulRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2795          if(ulRRCMsg->protocolIEs.list.array != NULLP)
2796          {
2797             for(idx1=0;idx1<ulRRCMsg->protocolIEs.list.count;idx1++)
2798             {
2799                if(ulRRCMsg->protocolIEs.list.array[idx1] != NULLP)
2800                {
2801                   if(ulRRCMsg->protocolIEs.list.array[idx1]->value.present ==
2802                         ULRRCMessageTransferIEs__value_PR_RRCContainer)
2803                   {
2804                      DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2805                            ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2806                   }
2807                   DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1],sizeof(ULRRCMessageTransferIEs_t));
2808                }
2809             }
2810             DU_FREE(ulRRCMsg->protocolIEs.list.array,ulRRCMsg->protocolIEs.list.size );
2811          }
2812          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2813       }
2814       DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
2815    }
2816 }
2817 /*******************************************************************
2818  *
2819  * @brief Builds and sends the ULRRCMessageTransfer
2820  *
2821  * @details
2822  *
2823  *    Function : BuildAndSendULRRCMessageTransfer
2824  *
2825  *    Functionality: Constructs the UL RRC Message Transfer and sends
2826  *                   it to the CU through SCTP.
2827  *
2828  * @params[in]
2829  *
2830  * @return ROK     - success
2831  *         RFAILED - failure
2832  *
2833  * ****************************************************************/
2834 uint8_t BuildAndSendULRRCMessageTransfer(DuUeCb  ueCb, uint8_t lcId, \
2835       uint16_t msgLen, uint8_t *rrcMsg)
2836 {
2837    uint8_t   elementCnt =0;
2838    uint8_t   idx1 =0;
2839    uint8_t   idx =0;
2840    F1AP_PDU_t                   *f1apMsg = NULLP;
2841    ULRRCMessageTransfer_t       *ulRRCMsg = NULLP;
2842    asn_enc_rval_t               encRetVal;        /* Encoder return value */
2843    uint8_t ret =RFAILED;
2844
2845    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2846
2847    while(true)
2848    {
2849       DU_LOG("\n INFO   -->  F1AP : Building UL RRC Message Transfer Message\n");
2850
2851       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
2852       if(f1apMsg == NULLP)
2853       {
2854          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2855          break;
2856       }
2857       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
2858       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2859       if(f1apMsg->choice.initiatingMessage == NULLP)
2860       {
2861          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
2862          break;
2863       }
2864       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_ULRRCMessageTransfer;
2865       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
2866       f1apMsg->choice.initiatingMessage->value.present = \
2867                                                          InitiatingMessage__value_PR_ULRRCMessageTransfer;
2868       ulRRCMsg =
2869          &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2870       elementCnt = 4;
2871       ulRRCMsg->protocolIEs.list.count = elementCnt;
2872       ulRRCMsg->protocolIEs.list.size = \
2873                                         elementCnt * sizeof(ULRRCMessageTransferIEs_t *);
2874
2875       /* Initialize the F1Setup members */
2876       DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size);
2877       if(ulRRCMsg->protocolIEs.list.array == NULLP)
2878       {
2879          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
2880          break;
2881       }
2882       for(idx=0; idx<elementCnt; idx++)
2883       {
2884          DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t));
2885          if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP)
2886          {
2887             break;
2888          }
2889       }
2890
2891       idx1 = 0;
2892
2893       /*GNB CU UE F1AP ID*/
2894       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
2895       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2896       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2897                                                               ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
2898       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = ueCb.gnbCuUeF1apId;
2899
2900       /*GNB DU UE F1AP ID*/
2901       idx1++;
2902       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
2903       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2904       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2905                                                               ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
2906       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = ueCb.gnbDuUeF1apId;
2907
2908       /*SRBID*/
2909       idx1++;
2910       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
2911       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2912       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2913                                                               ULRRCMessageTransferIEs__value_PR_SRBID;
2914       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = lcId;
2915
2916       /*RRCContainer*/
2917       idx1++;
2918       ulRRCMsg->protocolIEs.list.array[idx1]->id  = ProtocolIE_ID_id_RRCContainer;
2919       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2920       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2921                                                               ULRRCMessageTransferIEs__value_PR_RRCContainer;
2922       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size = msgLen;
2923       DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2924             ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
2925       if(!ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
2926       {
2927          DU_LOG(" ERROR  -->  F1AP : Memory allocation for BuildAndSendULRRCMessageTransfer failed");
2928          break;
2929       }
2930       memset(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, 0, msgLen);
2931       memcpy(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, \
2932             rrcMsg, ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2933
2934       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2935
2936       /* Encode the F1SetupRequest type as APER */
2937       memset(encBuf, 0, ENC_BUF_MAX_LEN);
2938       encBufSize = 0;
2939       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
2940             encBuf);
2941       /* Encode results */
2942       if(encRetVal.encoded == ENCODE_FAIL)
2943       {
2944          DU_LOG( "\nERROR  -->  F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
2945                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2946          break;
2947       }
2948       else
2949       {
2950          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
2951          for(int i=0; i< encBufSize; i++)
2952          {
2953             printf("%x",encBuf[i]);
2954          }
2955       }
2956
2957       /* Sending  msg  */
2958       if(sendF1APMsg()  !=      ROK)
2959       {
2960          DU_LOG("\nERROR  -->   F1AP : Sending  UL RRC Message Transfer Failed");
2961          break;
2962       }
2963       ret = ROK;
2964       break;
2965    }
2966    FreeULRRCMessageTransfer(f1apMsg);
2967
2968    return ret;
2969 }/* End of BuildAndSendULRRCMessageTransfer*/
2970
2971 /*******************************************************************
2972  *
2973  * @brief Builds tag config
2974  *
2975  * @details
2976  *
2977  *    Function : BuildTagConfig
2978  *
2979  *    Functionality: Builds tag config in MacCellGroupConfig
2980  *
2981  * @params[in] TAG_Config *tag_Config
2982  *
2983  * @return ROK     - success
2984  *         RFAILED - failure
2985  *
2986  * ****************************************************************/
2987 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
2988 {
2989    struct TAG_Config__tag_ToAddModList *tagList;
2990    uint8_t                     idx, elementCnt;
2991
2992    tagConfig->tag_ToReleaseList = NULLP;
2993    tagConfig->tag_ToAddModList = NULLP;
2994    DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
2995    if(!tagConfig->tag_ToAddModList)
2996    {
2997       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2998       return RFAILED;
2999    }
3000
3001    elementCnt = 1; //ODU_VALUE_ONE;
3002    tagList = tagConfig->tag_ToAddModList;
3003    tagList->list.count = elementCnt;
3004    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
3005
3006    tagList->list.array = NULLP;
3007    DU_ALLOC(tagList->list.array, tagList->list.size);
3008    if(!tagList->list.array)
3009    {
3010       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
3011       return RFAILED;
3012    }
3013
3014    for(idx=0; idx<tagList->list.count; idx++)
3015    {
3016       tagList->list.array[idx] = NULLP;
3017       DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
3018       if(!tagList->list.array[idx])
3019       {
3020          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
3021          return RFAILED;
3022       }
3023    }
3024
3025    idx = 0;
3026    tagList->list.array[idx]->tag_Id = TAG_ID;
3027    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
3028
3029    return ROK;
3030 }
3031
3032 /*******************************************************************
3033  *
3034  * @brief Builds PHR Config
3035  *
3036  * @details
3037  *
3038  *    Function : BuildPhrConfig
3039  *
3040  *    Functionality: Builds phrConfig in MacCellGroupConfig
3041  *
3042  * @params[in] PHR Config *
3043  *
3044  * @return ROK     - success
3045  *         RFAILED - failure
3046  *
3047  * ****************************************************************/
3048 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
3049 {
3050
3051    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
3052    phrConfig->choice.setup = NULLP;
3053    DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
3054    if(!phrConfig->choice.setup)
3055    {
3056       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
3057       return RFAILED;
3058    }
3059
3060    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
3061    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
3062    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
3063    phrConfig->choice.setup->multiplePHR              = false;
3064    phrConfig->choice.setup->dummy                    = false;
3065    phrConfig->choice.setup->phr_Type2OtherCell       = false;
3066    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
3067
3068    return ROK;
3069 }
3070
3071 /*******************************************************************
3072  *
3073  * @brief Builds BSR Config
3074  *
3075  * @details
3076  *
3077  *    Function : BuildBsrConfig
3078  *
3079  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
3080  *
3081  * @params[in] BSR_Config *bsrConfig
3082  *
3083  * @return ROK     - success
3084  *         RFAILED - failure
3085  *
3086  * ****************************************************************/
3087 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
3088 {
3089    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
3090    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
3091    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
3092
3093    return ROK;
3094 }
3095
3096 /*******************************************************************
3097  *
3098  * @brief Builds scheduling request config
3099  *
3100  * @details
3101  *
3102  *    Function : BuildSchedulingReqConfig
3103  *
3104  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
3105  *
3106  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
3107  *
3108  * @return ROK     - success
3109  *         RFAILED - failure
3110  *
3111  * ****************************************************************/
3112 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
3113 {
3114    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
3115    uint8_t                     idx, elementCnt;
3116
3117    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
3118    DU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
3119          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
3120    if(!schedulingRequestConfig->schedulingRequestToAddModList)
3121    {
3122       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3123       return RFAILED;
3124    }
3125
3126    elementCnt = 1; //ODU_VALUE_ONE;
3127    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
3128    schReqList->list.count = elementCnt;
3129    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
3130
3131    schReqList->list.array = NULLP;
3132    DU_ALLOC(schReqList->list.array, schReqList->list.size);
3133    if(!schReqList->list.array)
3134    {
3135       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3136       return RFAILED;
3137    }
3138
3139    for(idx=0;idx<schReqList->list.count; idx++)
3140    {
3141       schReqList->list.array[idx] = NULLP;
3142       DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
3143       if(!schReqList->list.array[idx])
3144       {
3145          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3146          return RFAILED;
3147       }
3148    }
3149
3150    idx = 0;
3151    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
3152
3153    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
3154    DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
3155    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
3156    {
3157       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3158       return RFAILED;
3159    }
3160    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
3161    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
3162    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
3163
3164    return ROK;
3165 }
3166
3167 /*******************************************************************
3168  *
3169  * @brief Builds RLC Config
3170  *
3171  * @details
3172  *
3173  *    Function : BuildRlcConfig
3174  *
3175  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
3176  *
3177  * @params[in] RLC_Config *rlcConfig
3178  *
3179  * @return ROK     - success
3180  *         RFAILED - failure
3181  *
3182  * ****************************************************************/
3183 uint8_t BuildRlcConfig(struct RLC_Config *rlcConfig)
3184 {
3185
3186    rlcConfig->present = RLC_Config_PR_am;
3187
3188    rlcConfig->choice.am = NULLP;
3189    DU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
3190    if(!rlcConfig->choice.am)
3191    {
3192       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3193       return RFAILED;
3194    }
3195
3196    /* UL */
3197    rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
3198    DU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3199    if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
3200    {
3201       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3202       return RFAILED;
3203    }
3204    *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3205    rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
3206    rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
3207    rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
3208    rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
3209
3210    /* DL */
3211    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
3212    DU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3213    if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
3214    {
3215       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3216       return RFAILED;
3217    }
3218    *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3219    rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
3220    rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
3221
3222    return ROK;
3223 }
3224
3225 /*******************************************************************
3226  *
3227  * @brief Builds MAC LC Config
3228  *
3229  * @details
3230  *
3231  *    Function : BuildMacLCConfig
3232  *
3233  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
3234  *
3235  * @params[in] struct LogicalChannelConfig macLcConfig
3236  *
3237  * @return ROK     - success
3238  *         RFAILED - failure
3239  *
3240  * ****************************************************************/
3241 uint8_t BuildMacLCConfig(struct LogicalChannelConfig *macLcConfig)
3242 {
3243
3244    macLcConfig->ul_SpecificParameters = NULLP;
3245    DU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
3246    if(!macLcConfig->ul_SpecificParameters)
3247    {
3248       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3249       return RFAILED;
3250    }
3251
3252    macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
3253    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     PRIORTISIED_BIT_RATE;
3254    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     BUCKET_SIZE_DURATION;
3255    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
3256    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
3257    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
3258    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
3259
3260    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
3261    DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
3262    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
3263    {
3264       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3265       return RFAILED;
3266    }
3267    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
3268
3269    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
3270    DU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
3271    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
3272    {
3273       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3274       return RFAILED;
3275    }
3276    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
3277
3278    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
3279    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
3280    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
3281
3282    return ROK;
3283 }
3284
3285 /*******************************************************************
3286  *
3287  * @brief Builds RLC Bearer to Add/Mod list
3288  *
3289  * @details
3290  *
3291  *    Function :BuildRlcBearerToAddModList
3292  *
3293  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
3294  *
3295  * @params[in] rlc_BearerToAddModList
3296  *
3297  * @return ROK     - success
3298  *         RFAILED - failure
3299  *
3300  * ****************************************************************/
3301 uint8_t BuildRlcBearerToAddModList(struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
3302 {
3303    uint8_t                     idx, elementCnt;
3304
3305    elementCnt = 1;
3306    rlcBearerList->list.count = elementCnt;
3307    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
3308
3309    rlcBearerList->list.array = NULLP;
3310    DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
3311    if(!rlcBearerList->list.array)
3312    {
3313       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3314       return RFAILED;
3315    }
3316
3317    for(idx=0; idx<rlcBearerList->list.count; idx++)
3318    {
3319       rlcBearerList->list.array[idx] = NULLP;
3320       DU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
3321       if(!rlcBearerList->list.array[idx])
3322       {
3323          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3324          return RFAILED;
3325       }
3326    }
3327
3328    idx = 0;
3329    rlcBearerList->list.array[idx]->logicalChannelIdentity = SRB1_LCID;
3330
3331    DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, \
3332       sizeof(struct RLC_BearerConfig__servedRadioBearer));
3333    if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3334    {
3335       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3336       return RFAILED;
3337    }
3338
3339    rlcBearerList->list.array[idx]->servedRadioBearer->present = \
3340       RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
3341    rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = \
3342       SRB1_LCID;
3343
3344    rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3345    rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3346    DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3347    if(!rlcBearerList->list.array[idx]->rlc_Config)
3348    {
3349       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3350       return RFAILED;
3351    }
3352
3353    if(BuildRlcConfig(rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3354    {
3355       DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3356       return RFAILED;
3357    }
3358
3359    rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3360    DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, \
3361       sizeof(struct LogicalChannelConfig));
3362    if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3363    {
3364       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3365       return RFAILED;
3366    }
3367
3368    if(BuildMacLCConfig(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3369    {
3370       DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3371       return RFAILED;
3372    }
3373
3374    return ROK;
3375 }
3376
3377 /*******************************************************************
3378  *
3379  * @brief Build Control resource set to add/modify list
3380  *
3381  * @details
3382  *
3383  *    Function : BuildControlRSetToAddModList
3384  *
3385  *    Functionality: Build Control resource set to add/modify list
3386  *
3387  * @params[in]
3388  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3389  *
3390  * @return ROK     - success
3391  *         RFAILED - failure
3392  *
3393  * ****************************************************************/
3394    uint8_t BuildControlRSetToAddModList
3395 (
3396  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3397  )
3398 {
3399    uint8_t idx;
3400    uint8_t elementCnt;
3401    uint8_t numBytes, bitsUnused;
3402    struct ControlResourceSet *controlRSet;
3403    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3404    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3405
3406
3407    elementCnt = 1;
3408    controlRSetList->list.count = elementCnt;
3409    controlRSetList->list.size = \
3410                                 elementCnt * sizeof(struct ControlResourceSet *);
3411
3412    controlRSetList->list.array = NULLP;
3413    DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3414    if(!controlRSetList->list.array)
3415    {
3416       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3417       return RFAILED;
3418    }
3419
3420    for(idx = 0; idx < elementCnt; idx++)
3421    {
3422       controlRSetList->list.array[idx] = NULLP;
3423       DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3424       if(!controlRSetList->list.array[idx])
3425       {
3426          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3427          return RFAILED;
3428       }
3429    }
3430
3431    idx=0;
3432    controlRSet = controlRSetList->list.array[idx];
3433
3434    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3435
3436    /* size 6 bytes
3437     * 3 LSBs unsued
3438     * Bit string stored ff0000000000
3439     */
3440    numBytes = 6;
3441    bitsUnused = 3;
3442    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3443
3444    controlRSet->frequencyDomainResources.buf = NULLP;
3445    DU_ALLOC(controlRSet->frequencyDomainResources.buf, \
3446          controlRSet->frequencyDomainResources.size);
3447    if(!controlRSet->frequencyDomainResources.buf)
3448    {
3449       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3450       return RFAILED;
3451    }
3452
3453    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3454    coreset0EndPrb = CORESET0_END_PRB;
3455    coreset1StartPrb = coreset0EndPrb + 6;
3456    coreset1NumPrb = CORESET1_NUM_PRB;
3457    /* calculate the PRBs */
3458    fillCoresetFeqDomAllocMap(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3459    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3460    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3461
3462    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3463    controlRSet->cce_REG_MappingType.present = \
3464                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3465
3466    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3467    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3468    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3469    controlRSet->tci_PresentInDCI = NULLP;
3470 #if 0
3471    uint8_t tciStateIdx;
3472
3473    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3474          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3475    if(!controlRset->tci_StatesPDCCH_ToAddList)
3476    {
3477       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3478       return RFAILED;
3479    }
3480
3481    elementCnt = 1;
3482    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3483    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3484    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3485          controlRset->tci_StatesPDCCH_ToAddList->list.size)
3486       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3487       {
3488          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3489          return RFAILED;
3490       }
3491
3492    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3493    {
3494       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3495       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3496       {
3497          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3498          return RFAILED;
3499       }
3500    }
3501
3502    tciStateIdx = 0;
3503    /* TODO */
3504    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3505
3506    DU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3507    if(!controlRset->tci_PresentInDCI)
3508    {
3509       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3510       return RFAILED;
3511    }
3512    /* TODO */
3513    *(controlRset->tci_PresentInDCI);
3514 #endif
3515
3516    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3517    DU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3518    if(!controlRSet->pdcch_DMRS_ScramblingID)
3519    {
3520       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3521       return RFAILED;
3522    }
3523    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3524
3525    return ROK;
3526 } /* End BuildControlRSetToAddModList */
3527
3528 /*******************************************************************
3529  *
3530  * @brief Build search space to add/modify list
3531  *
3532  * @details
3533  *
3534  *    Function : BuildSearchSpcToAddModList
3535  *
3536  *    Functionality: Build search space to add/modify list
3537  *
3538  * @params[in]
3539  * @return ROK     - success
3540  *         RFAILED - failure
3541  *
3542  * ****************************************************************/
3543    uint8_t BuildSearchSpcToAddModList
3544 (
3545  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
3546  )
3547 {
3548    uint8_t idx;
3549    uint8_t numBytes;
3550    uint8_t byteIdx;
3551    uint8_t bitsUnused;
3552    uint8_t elementCnt;
3553    struct SearchSpace *searchSpc;
3554
3555    elementCnt = 1;
3556    searchSpcList->list.count = elementCnt;
3557    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3558
3559    searchSpcList->list.array = NULLP;
3560    DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3561    if(!searchSpcList->list.array)
3562    {
3563       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3564       return RFAILED;
3565    }
3566
3567    for(idx = 0; idx < elementCnt; idx++)
3568    {
3569       searchSpcList->list.array[idx] = NULLP;
3570       DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3571       if(!searchSpcList->list.array[idx])
3572       {
3573          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3574          return RFAILED;
3575       }
3576    }
3577
3578    idx = 0;
3579    searchSpc = searchSpcList->list.array[idx];
3580
3581    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3582
3583    searchSpc->controlResourceSetId = NULLP;
3584    DU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3585    if(!searchSpc->controlResourceSetId)
3586    {
3587       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3588       return RFAILED;
3589    }
3590    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3591
3592    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3593    DU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
3594          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3595    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3596    {
3597       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3598       return RFAILED;
3599    }
3600    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
3601                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3602
3603    searchSpc->duration = NULLP;
3604    searchSpc->monitoringSymbolsWithinSlot = NULLP;
3605    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3606    if(!searchSpc->monitoringSymbolsWithinSlot)
3607    {
3608       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3609       return RFAILED;
3610    }
3611
3612    /* Values taken from reference logs :
3613     * size 2 bytes
3614     * 2 LSBs unsued
3615     * Bit string stores 8000
3616     */
3617    numBytes = 2;
3618    bitsUnused = 2;
3619
3620    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3621    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3622    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
3623          searchSpc->monitoringSymbolsWithinSlot->size);
3624    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3625    {
3626       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3627       return RFAILED;
3628    }
3629
3630    byteIdx = 0;
3631    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
3632                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3633    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3634    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3635
3636    searchSpc->nrofCandidates = NULLP;
3637    DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3638    if(!searchSpc->nrofCandidates)
3639    {
3640       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3641       return RFAILED;
3642    }
3643
3644    searchSpc->nrofCandidates->aggregationLevel1 = \
3645                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3646    searchSpc->nrofCandidates->aggregationLevel2 = \
3647                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3648    searchSpc->nrofCandidates->aggregationLevel4 = \
3649                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3650    searchSpc->nrofCandidates->aggregationLevel8 = \
3651                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3652    searchSpc->nrofCandidates->aggregationLevel16 = \
3653                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3654
3655    searchSpc->searchSpaceType = NULLP;
3656    DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3657    if(!searchSpc->searchSpaceType)
3658    {
3659       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3660       return RFAILED;
3661    }
3662
3663    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3664
3665    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3666    DU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
3667          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3668    if(!searchSpc->searchSpaceType->choice.ue_Specific)
3669    {
3670       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3671       return RFAILED;
3672    }
3673    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
3674                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3675
3676    return ROK;
3677 }/* End BuildSearchSpcToAddModList */
3678
3679 /*******************************************************************
3680  *
3681  * @brief Builds BWP DL dedicated PDCCH config
3682  *
3683  * @details
3684  *
3685  *    Function : BuildBWPDlDedPdcchCfg
3686  *
3687  *    Functionality: Builds BWP DL dedicated PDCCH config
3688  *
3689  * @params[in] struct PDCCH_Config *pdcchCfg
3690  *
3691  * @return ROK     - success
3692  *         RFAILED - failure
3693  *
3694  * ****************************************************************/
3695 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
3696 {
3697    pdcchCfg->controlResourceSetToAddModList = NULLP;
3698    DU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
3699          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3700    if(!pdcchCfg->controlResourceSetToAddModList)
3701    {
3702       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3703       return RFAILED;
3704    }
3705
3706    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
3707    {
3708       return RFAILED;
3709    }
3710
3711    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3712
3713    pdcchCfg->searchSpacesToAddModList = NULLP;
3714    DU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3715          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3716    if(!pdcchCfg->searchSpacesToAddModList)
3717    {
3718       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3719       return RFAILED;
3720    }
3721
3722    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3723    {
3724       return RFAILED;
3725    }
3726
3727    pdcchCfg->searchSpacesToReleaseList = NULLP;
3728    pdcchCfg->downlinkPreemption = NULLP;
3729    pdcchCfg->tpc_PUSCH = NULLP;
3730    pdcchCfg->tpc_PUCCH = NULLP;
3731    pdcchCfg->tpc_SRS = NULLP;
3732
3733    return ROK;
3734 }
3735
3736 /*******************************************************************
3737  *
3738  * @brief Builds DMRS DL PDSCH Mapping type A
3739  *
3740  * @details
3741  *
3742  *    Function : BuildDMRSDLPdschMapTypeA
3743  *
3744  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3745  *
3746  * @params[in]
3747  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3748  * @return ROK     - success
3749  *         RFAILED - failure
3750  *
3751  * ****************************************************************/
3752    uint8_t BuildDMRSDLPdschMapTypeA
3753 (
3754  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3755  )
3756 {
3757    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3758    dmrsDlCfg->choice.setup = NULLP;
3759    DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3760    if(!dmrsDlCfg->choice.setup)
3761    {
3762       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3763       return RFAILED;
3764    }
3765
3766    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3767    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3768    DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3769    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3770    {
3771       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3772       return RFAILED;
3773    }
3774    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3775
3776    dmrsDlCfg->choice.setup->maxLength = NULLP;
3777    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3778    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3779    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3780
3781    return ROK;
3782 }
3783
3784 /*******************************************************************
3785  *
3786  * @brief Builds TCI states to add/modify list
3787  *
3788  * @details
3789  *
3790  *    Function : BuildTCIStatesToAddModList
3791  *
3792  *    Functionality:Builds TCI states to add/modify list
3793  *
3794  * @params[in]
3795  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3796  *
3797  * @return ROK     - success
3798  *         RFAILED - failure
3799  *
3800  * ****************************************************************/
3801 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3802 {
3803    return ROK;
3804 }
3805
3806 /*******************************************************************
3807  *
3808  * @brief Builds PDSCH time domain allocation list
3809  *
3810  * @details
3811  *
3812  *    Function : BuildPdschTimeDomAllocList
3813  *
3814  *    Functionality: Builds PDSCH time domain allocation list
3815  *
3816  * @params[in]
3817  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3818  *
3819  * @return ROK     - success
3820  *         RFAILED - failure
3821  *
3822  * ****************************************************************/
3823    uint8_t BuildPdschTimeDomAllocList
3824 (
3825  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3826  )
3827 {
3828    uint8_t idx;
3829    uint8_t elementCnt;
3830    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3831
3832    timeDomAllocList->present = \
3833                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3834
3835    timeDomAllocList->choice.setup = NULLP;
3836    DU_ALLOC(timeDomAllocList->choice.setup, \
3837          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3838    if(!timeDomAllocList->choice.setup)
3839    {
3840       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3841       return RFAILED;
3842    }
3843
3844    elementCnt = 2;
3845    timeDomAllocList->choice.setup->list.count = elementCnt;
3846    timeDomAllocList->choice.setup->list.size = \
3847                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3848
3849    timeDomAllocList->choice.setup->list.array = NULLP;
3850    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3851          timeDomAllocList->choice.setup->list.size);
3852    if(!timeDomAllocList->choice.setup->list.array)
3853    {
3854       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3855       return RFAILED;
3856    }
3857
3858    for(idx = 0; idx < elementCnt; idx++)
3859    {
3860       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3861       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3862             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3863       if(!timeDomAllocList->choice.setup->list.array[idx])
3864       {
3865          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3866          return RFAILED;
3867       }
3868    }
3869
3870    idx = 0;
3871    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3872    DU_ALLOC(timeDomAlloc->k0, sizeof(long));
3873    if(!timeDomAlloc->k0)
3874    {
3875       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3876       return RFAILED;
3877    }
3878    *(timeDomAlloc->k0) = 0;
3879    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3880    timeDomAlloc->startSymbolAndLength = \
3881                                         calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
3882
3883    idx++;
3884    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3885    DU_ALLOC(timeDomAlloc->k0, sizeof(long));
3886    if(!timeDomAlloc->k0)
3887    {
3888       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3889       return RFAILED;
3890    }
3891    *(timeDomAlloc->k0) = 1;
3892    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3893    timeDomAlloc->startSymbolAndLength = calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
3894
3895    return ROK;
3896 }
3897
3898 /*******************************************************************
3899  *
3900  * @brief Builds PDSCH PRB Bundling type
3901  *
3902  * @details
3903  *
3904  *    Function : BuildPdschPrbBundlingType
3905  *
3906  *    Functionality: Builds PDSCH PRB Bundling type
3907  *
3908  * @params[in]
3909  * struct PDSCH_Config__prb_BundlingType *prbBndlType
3910  *
3911  * @return ROK     - success
3912  *         RFAILED - failure
3913  *
3914  * ****************************************************************/
3915    uint8_t BuildPdschPrbBundlingType
3916 (
3917  struct PDSCH_Config__prb_BundlingType *prbBndlType
3918  )
3919 {
3920    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
3921
3922    prbBndlType->choice.staticBundling = NULLP;
3923    DU_ALLOC(prbBndlType->choice.staticBundling, \
3924          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
3925    if(!prbBndlType->choice.staticBundling)
3926    {
3927       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
3928       return RFAILED;
3929    }
3930    prbBndlType->choice.staticBundling->bundleSize = NULLP;
3931
3932    return ROK;
3933 }
3934
3935 /*******************************************************************
3936  *
3937  * @brief Builds BWP DL dedicated PDSCH config
3938  *
3939  * @details
3940  *
3941  *    Function : BuildBWPDlDedPdschCfg
3942  *
3943  *    Functionality: Builds BWP DL dedicated PDSCH config
3944  *
3945  * @params[in] struct PDSCH_Config *pdschCfg
3946  *
3947  * @return ROK     - success
3948  *         RFAILED - failure
3949  *
3950  * ****************************************************************/
3951 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
3952 {
3953    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
3954
3955    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
3956    DU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
3957          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
3958    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
3959    {
3960       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3961       return RFAILED;
3962    }
3963
3964    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
3965    {
3966       return RFAILED;
3967    }
3968
3969    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
3970    pdschCfg->tci_StatesToAddModList = NULLP;
3971    pdschCfg->tci_StatesToReleaseList = NULLP;
3972    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
3973 #if 0
3974    DU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
3975    if(!pdschCfg->tci_StatesToAddModList)
3976    {
3977       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3978       return RFAILED;
3979    }
3980    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
3981    {
3982       return RFAILED;
3983    }
3984 #endif
3985
3986    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
3987
3988    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
3989    DU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
3990          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
3991    if(!pdschCfg->pdsch_TimeDomainAllocationList)
3992    {
3993       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3994       return RFAILED;
3995    }
3996
3997    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
3998    {
3999       return RFAILED;
4000    }
4001
4002    pdschCfg->pdsch_AggregationFactor = NULLP;
4003    pdschCfg->rateMatchPatternToAddModList = NULLP;
4004    pdschCfg->rateMatchPatternToReleaseList = NULLP;
4005    pdschCfg->rateMatchPatternGroup1 = NULLP;
4006    pdschCfg->rateMatchPatternGroup2 = NULLP;
4007    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
4008    pdschCfg->mcs_Table = NULLP;
4009
4010    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
4011    DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
4012    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
4013    {
4014       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4015       return RFAILED;
4016    }
4017    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
4018
4019    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
4020    {
4021       return RFAILED;
4022    }
4023
4024    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
4025    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
4026    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4027    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4028    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4029    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4030    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
4031
4032    return ROK;
4033 }
4034
4035 /*******************************************************************
4036  *
4037  * @brief Builds intitial DL BWP
4038  * @details
4039  *
4040  *    Function : BuildInitialDlBWP
4041  *
4042  *    Functionality: Builds intitial DL BWP in spCellCfgDed
4043  *
4044  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4045  *
4046  * @return ROK     - success
4047  *         RFAILED - failure
4048  *
4049  * ****************************************************************/
4050 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
4051 {
4052    dlBwp->pdcch_Config = NULLP;
4053    DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
4054    if(!dlBwp->pdcch_Config)
4055    {
4056       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4057       return RFAILED;
4058    }
4059    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
4060
4061    dlBwp->pdcch_Config->choice.setup = NULLP;
4062    DU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
4063    if(!dlBwp->pdcch_Config->choice.setup)
4064    {
4065       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4066       return RFAILED;
4067    }
4068    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
4069    {
4070       return RFAILED;
4071    }
4072
4073    dlBwp->pdsch_Config = NULLP;
4074    DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
4075    if(!dlBwp->pdsch_Config)
4076    {
4077       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4078       return RFAILED;
4079    }
4080    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
4081
4082    dlBwp->pdsch_Config->choice.setup = NULLP;
4083    DU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
4084    if(!dlBwp->pdsch_Config->choice.setup)
4085    {
4086       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4087       return RFAILED;
4088    }
4089
4090    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
4091    {
4092       return RFAILED;
4093    }
4094
4095    dlBwp->sps_Config = NULLP;
4096    dlBwp->radioLinkMonitoringConfig = NULLP;
4097    return ROK;
4098 }
4099
4100 /*******************************************************************
4101  *
4102  * @brief Builds DMRS UL Pusch Mapping type A
4103  *
4104  * @details
4105  *
4106  *    Function : BuildDMRSULPuschMapTypeA
4107  *
4108  *    Functionality: Builds DMRS UL Pusch Mapping type A
4109  *
4110  * @params[in]
4111  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4112  * @return ROK     - success
4113  *         RFAILED - failure
4114  *
4115  * ****************************************************************/
4116    uint8_t BuildDMRSULPuschMapTypeA
4117 (
4118  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4119  )
4120 {
4121    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
4122    dmrsUlCfg->choice.setup= NULLP;
4123    DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
4124    if(!dmrsUlCfg->choice.setup)
4125    {
4126       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4127       return RFAILED;
4128    }
4129
4130    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
4131    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
4132    DU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
4133    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4134    {
4135       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4136       return RFAILED;
4137    }
4138    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
4139
4140    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
4141    dmrsUlCfg->choice.setup->maxLength = NULLP;
4142    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
4143    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
4144          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4145    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4146    {
4147       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4148       return RFAILED;
4149    }
4150
4151    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
4152    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4153          sizeof(long));
4154    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
4155    {
4156       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4157       return RFAILED;
4158    }
4159    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
4160
4161    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
4162    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
4163    return ROK;
4164 }
4165
4166 /*******************************************************************
4167  *
4168  * @brief Build PUSCH time domain allocation list
4169  *
4170  * @details
4171  *
4172  *    Function : BuildPuschTimeDomAllocList
4173  *
4174  *    Functionality: Build PUSCH time domain allocation list
4175  *
4176  * @params[in]
4177  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4178  *
4179  * @return ROK     - success
4180  *         RFAILED - failure
4181  *
4182  * ****************************************************************/
4183    uint8_t BuildPuschTimeDomAllocList
4184 (
4185  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4186  )
4187 {
4188    uint8_t idx;
4189    uint8_t elementCnt;
4190    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
4191
4192    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
4193    timeDomAllocList->choice.setup = NULLP;
4194    DU_ALLOC(timeDomAllocList->choice.setup, \
4195          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4196    if(!timeDomAllocList->choice.setup)
4197    {
4198       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4199       return RFAILED;
4200    }
4201
4202    elementCnt = 2;
4203    timeDomAllocList->choice.setup->list.count = elementCnt;
4204    timeDomAllocList->choice.setup->list.size = \
4205                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
4206    timeDomAllocList->choice.setup->list.array = NULLP;
4207    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
4208          timeDomAllocList->choice.setup->list.size);
4209    if(!timeDomAllocList->choice.setup->list.array)
4210    {
4211       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4212       return RFAILED;
4213    }
4214
4215    for(idx = 0; idx < elementCnt; idx++)
4216    {
4217       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4218       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
4219             sizeof(PUSCH_TimeDomainResourceAllocation_t));
4220       if(!timeDomAllocList->choice.setup->list.array[idx])
4221       {
4222          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4223          return RFAILED;
4224       }
4225    }
4226
4227    idx = 0;
4228    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4229    DU_ALLOC(timeDomAlloc->k2, sizeof(long));
4230    if(!timeDomAlloc->k2)
4231    {
4232       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4233       return RFAILED;
4234    }
4235    *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
4236    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4237    timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
4238
4239    idx++;
4240    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4241    DU_ALLOC(timeDomAlloc->k2, sizeof(long));
4242    if(!timeDomAlloc->k2)
4243    {
4244       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4245       return RFAILED;
4246    }
4247    *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
4248    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4249    timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
4250
4251    return ROK;
4252 }
4253
4254 /*******************************************************************
4255  *
4256  * @brief Builds BWP UL dedicated PUSCH Config
4257  *
4258  * @details
4259  *
4260  *    Function : BuildBWPUlDedPuschCfg
4261  *
4262  *    Functionality:
4263  *      Builds BWP UL dedicated PUSCH Config
4264  *
4265  * @params[in] : PUSCH_Config_t *puschCfg
4266  *
4267  * @return ROK     - success
4268  *         RFAILED - failure
4269  *
4270  * ****************************************************************/
4271 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
4272 {
4273    puschCfg->dataScramblingIdentityPUSCH = NULLP;
4274    DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4275    if(!puschCfg->dataScramblingIdentityPUSCH)
4276    {
4277       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4278       return RFAILED;
4279    }
4280    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
4281
4282    puschCfg->txConfig = NULLP;
4283    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4284    DU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4285          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4286    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4287    {
4288       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4289       return RFAILED;
4290    }
4291
4292    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4293    {
4294       return RFAILED;
4295    }
4296
4297    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4298    puschCfg->pusch_PowerControl = NULLP;
4299    puschCfg->frequencyHopping = NULLP;
4300    puschCfg->frequencyHoppingOffsetLists = NULLP;
4301    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4302
4303    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4304    DU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
4305          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4306    if(!puschCfg->pusch_TimeDomainAllocationList)
4307    {
4308       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4309       return RFAILED;
4310    }
4311
4312    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
4313    {
4314       return RFAILED;
4315    }
4316
4317    puschCfg->pusch_AggregationFactor = NULLP;
4318    puschCfg->mcs_Table = NULLP;
4319    puschCfg->mcs_TableTransformPrecoder = NULLP;
4320    puschCfg->transformPrecoder = NULLP;
4321    DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4322    if(!puschCfg->transformPrecoder)
4323    {
4324       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4325       return RFAILED;
4326    }
4327    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4328
4329    puschCfg->codebookSubset = NULLP;
4330    puschCfg->maxRank = NULLP;
4331    puschCfg->rbg_Size = NULLP;
4332    puschCfg->uci_OnPUSCH = NULLP;
4333    puschCfg->tp_pi2BPSK = NULLP;
4334
4335    return ROK;
4336 }
4337
4338 /*******************************************************************
4339  *
4340  * @brief Builds BWP UL dedicated PUCCH Config
4341  *
4342  * @details
4343  *
4344  *    Function : BuildBWPUlDedPucchCfg
4345  *
4346  *    Functionality:
4347  *      Builds BWP UL dedicated PUCCH Config
4348  *
4349  * @params[in] : PUCCH_Config_t *pucchCfg
4350  *
4351  * @return ROK     - success
4352  *         RFAILED - failure
4353  *
4354  * ****************************************************************/
4355 uint8_t BuildBWPUlDedPucchCfg(PUCCH_Config_t *pucchCfg)
4356 {
4357    uint8_t arrIdx, elementCnt;
4358
4359    DU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
4360    if(pucchCfg->dl_DataToUL_ACK == NULLP)
4361    {
4362       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4363       return RFAILED;
4364    }
4365
4366    elementCnt = 2;
4367    pucchCfg->dl_DataToUL_ACK->list.count = elementCnt;
4368    pucchCfg->dl_DataToUL_ACK->list.size = elementCnt * sizeof(long *);
4369    DU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
4370    if(pucchCfg->dl_DataToUL_ACK->list.array == NULLP)
4371    {
4372       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4373       return RFAILED;
4374    }
4375
4376    for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
4377    {
4378       DU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
4379       if(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx] == NULLP)
4380       {
4381           DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4382           return RFAILED;
4383       }
4384    }
4385
4386    arrIdx = 0;
4387    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx++]) = 1;
4388    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx]) = 2;
4389    return ROK;
4390 }
4391
4392 /*******************************************************************
4393  *
4394  * @brief Fills SRS resource to add/modify list
4395  *
4396  * @details
4397  *
4398  *    Function : BuildSrsRsrcAddModList
4399  *
4400  *    Functionality: Fills SRS resource to add/modify list
4401  *
4402  * @params[in]
4403  * @return ROK     - success
4404  *         RFAILED - failure
4405  *
4406  * ****************************************************************/
4407 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
4408 {
4409    uint8_t   elementCnt;
4410    uint8_t   rsrcIdx;
4411
4412    elementCnt = 1;
4413    resourceList->list.count = elementCnt;
4414    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
4415    resourceList->list.array = NULLP;
4416    DU_ALLOC(resourceList->list.array, resourceList->list.size);
4417    if(!resourceList->list.array)
4418    {
4419       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4420       return RFAILED;
4421    }
4422
4423    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4424    {
4425       DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4426       if(!resourceList->list.array[rsrcIdx])
4427       {
4428          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4429          return RFAILED;
4430       }
4431    }
4432
4433    rsrcIdx = 0;
4434    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
4435    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
4436    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
4437
4438    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
4439    DU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
4440          sizeof(struct SRS_Resource__transmissionComb__n2));
4441    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
4442    {
4443       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4444       return RFAILED;
4445    }
4446    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
4447       = SRS_COMB_OFFSET_N2;
4448    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
4449       = SRS_CYCLIC_SHIFT_N2;
4450
4451    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
4452                                                                       PUSCH_START_SYMBOL;
4453    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
4454                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
4455    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
4456                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
4457
4458    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
4459    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
4460    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
4461    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
4462    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
4463    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
4464                                                                SRS_Resource__groupOrSequenceHopping_neither;
4465
4466    /* Setting resource type to aperiodic for intergration purposes */
4467    resourceList->list.array[rsrcIdx]->resourceType.present = \
4468                                                              SRS_Resource__resourceType_PR_aperiodic;
4469    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
4470    DU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
4471          sizeof(struct SRS_Resource__resourceType__aperiodic));
4472    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
4473    {
4474       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4475       return RFAILED;
4476    }
4477    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
4478
4479    return ROK;
4480 }
4481
4482 /*******************************************************************
4483  *
4484  * @brief Build SRS resource set Add/mod list
4485  *
4486  * @details
4487  *
4488  *    Function : BuildSrsRsrcSetAddModList
4489  *
4490  *    Functionality: Build SRS resource set Add/mod list
4491  *
4492  * @params[in]
4493  * @return ROK     - success
4494  *         RFAILED - failure
4495  *
4496  * ****************************************************************/
4497    uint8_t BuildSrsRsrcSetAddModList
4498 (
4499  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
4500  )
4501 {
4502    uint8_t  elementCnt;
4503    uint8_t  rSetIdx;
4504    uint8_t  rsrcIdx;
4505    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
4506
4507    elementCnt = 1;
4508    rsrcSetList->list.count = elementCnt;
4509    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
4510    rsrcSetList->list.array = NULLP;
4511    DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
4512    if(!rsrcSetList->list.array)
4513    {
4514       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4515       return RFAILED;
4516    }
4517
4518    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4519    {
4520       DU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4521       if(!rsrcSetList->list.array[rSetIdx])
4522       {
4523          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4524          return RFAILED;
4525       }
4526    }
4527
4528    rSetIdx = 0;
4529    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
4530
4531    /* Fill Resource Id list in resource set */
4532    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
4533    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4534          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4535    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4536    {
4537       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4538       return RFAILED;
4539    }
4540
4541    elementCnt = 1;
4542    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4543    rsrcIdList->list.count = elementCnt;
4544    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
4545    rsrcIdList->list.array = NULLP;
4546    DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
4547    if(!rsrcIdList->list.array)
4548    {
4549       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4550       return RFAILED;
4551    }
4552
4553    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4554    {
4555       DU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4556       if(!rsrcIdList->list.array[rsrcIdx])
4557       {
4558          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4559          return RFAILED;
4560       }
4561    }
4562
4563    rsrcIdx = 0;
4564    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
4565
4566    /* Fill resource type */
4567    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
4568                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
4569
4570    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
4571    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4572          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4573    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
4574    {
4575       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4576       return RFAILED;
4577    }
4578    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
4579       = APERIODIC_SRS_RESRC_TRIGGER;
4580
4581    /* TODO : Fill values for below IEs as expected by Viavi */
4582    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
4583    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
4584
4585
4586    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
4587    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
4588    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
4589    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
4590    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
4591
4592    return ROK;
4593 }
4594
4595 /*******************************************************************
4596  *
4597  * @brief Builds BWP UL dedicated SRS Config
4598  *
4599  * @details
4600  *
4601  *    Function : BuildBWPUlDedSrsCfg
4602  *
4603  *    Functionality: Builds BWP UL dedicated SRS Config
4604  *
4605  * @params[in] SRS Config
4606  * @return ROK     - success
4607  *         RFAILED - failure
4608  *
4609  * ****************************************************************/
4610 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
4611 {
4612    srsCfg->srs_ResourceSetToReleaseList = NULLP;
4613    srsCfg->srs_ResourceSetToAddModList = NULLP;
4614    DU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
4615          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4616    if(!srsCfg->srs_ResourceSetToAddModList)
4617    {
4618       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4619       return RFAILED;
4620    }
4621    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
4622    {
4623       return RFAILED;
4624    }
4625
4626    srsCfg->srs_ResourceToReleaseList = NULLP;
4627
4628    /* Resource to Add/Modify list */
4629    srsCfg->srs_ResourceToAddModList = NULLP;
4630    DU_ALLOC(srsCfg->srs_ResourceToAddModList, \
4631          sizeof(struct SRS_Config__srs_ResourceToAddModList));
4632    if(!srsCfg->srs_ResourceToAddModList)
4633    {
4634       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4635       return RFAILED;
4636    }
4637
4638    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
4639    {
4640       return RFAILED;
4641    }
4642
4643    srsCfg->tpc_Accumulation = NULLP;
4644
4645    return ROK;
4646 }
4647
4648
4649
4650 /*******************************************************************
4651  *
4652  * @brief Builds Pusch Serving cell Config
4653  *
4654  * @details
4655  *
4656  *    Function : BuildPuschSrvCellCfg
4657  *
4658  *    Functionality: Builds Pusch Serving cell Config
4659  *
4660  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
4661  *
4662  * @return ROK     - success
4663  *         RFAILED - failure
4664  *
4665  * ****************************************************************/
4666 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
4667 {
4668    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
4669    puschCfg->choice.setup = NULLP;
4670    DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4671    if(!puschCfg->choice.setup)
4672    {
4673       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4674       return RFAILED;
4675    }
4676
4677    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4678    puschCfg->choice.setup->rateMatching = NULLP;
4679    puschCfg->choice.setup->xOverhead = NULLP;
4680    puschCfg->choice.setup->ext1 = NULLP;
4681    DU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
4682    if(!puschCfg->choice.setup->ext1)
4683    {
4684       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4685       return RFAILED;
4686    }
4687
4688    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
4689    DU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
4690    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
4691    {
4692       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4693       return RFAILED;
4694    }
4695    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
4696
4697    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
4698    DU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
4699    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
4700    {
4701       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4702       return RFAILED;
4703    }
4704    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
4705    return ROK;
4706 }
4707
4708 /*******************************************************************
4709  *
4710  * @brief Builds inital UL BWP
4711  *
4712  * @details
4713  *
4714  *    Function : BuildInitialUlBWP
4715  *
4716  *    Functionality: Builds initial UL BWP
4717  *
4718  * @params[in] BWP_UplinkDedicated_t *ulBwp
4719  * @return ROK     - success
4720  *         RFAILED - failure
4721  *
4722  * ****************************************************************/
4723 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4724 {
4725    ulBwp->pucch_Config = NULLP;
4726    DU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
4727    if(!ulBwp->pucch_Config)
4728    {
4729       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4730       return RFAILED;
4731    }
4732
4733    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
4734    ulBwp->pucch_Config->choice.setup = NULLP;
4735    DU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
4736    if(!ulBwp->pucch_Config->choice.setup)
4737    {
4738       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4739       return RFAILED;
4740    }
4741
4742    if(BuildBWPUlDedPucchCfg(ulBwp->pucch_Config->choice.setup) != ROK)
4743    {
4744       return RFAILED;
4745    }
4746
4747    /* Fill BWP UL dedicated PUSCH config */
4748    ulBwp->pusch_Config = NULLP;
4749    DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4750    if(!ulBwp->pusch_Config)
4751    {
4752       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4753       return RFAILED;
4754    }
4755
4756    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
4757    ulBwp->pusch_Config->choice.setup = NULLP;
4758    DU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4759    if(!ulBwp->pusch_Config->choice.setup)
4760    {
4761       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4762       return RFAILED;
4763    }
4764
4765    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
4766    {
4767       return RFAILED;
4768    }
4769
4770    ulBwp->configuredGrantConfig = NULLP;
4771
4772    /* Fill BPW UL dedicated SRS config */
4773    ulBwp->srs_Config = NULLP;
4774    DU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4775    if(!ulBwp->srs_Config)
4776    {
4777       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4778       return RFAILED;
4779    }
4780
4781    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
4782    ulBwp->srs_Config->choice.setup = NULLP;
4783    DU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4784    if(!ulBwp->srs_Config->choice.setup)
4785    {
4786       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4787       return RFAILED;
4788    }
4789
4790    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
4791    {
4792       return RFAILED;
4793    }
4794
4795    ulBwp->beamFailureRecoveryConfig = NULLP;
4796
4797    return ROK;
4798 }
4799
4800 /*******************************************************************
4801  *
4802  * @brief Builds UL config
4803  * @details
4804  *
4805  *    Function : BuildUlCfg
4806  *
4807  *    Functionality: Builds UL config in spCellCfgDed
4808  *
4809  * @params[in] UplinkConfig_t *ulCfg
4810  *
4811  * @return ROK     - success
4812  *         RFAILED - failure
4813  *
4814  * ****************************************************************/
4815 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
4816 {
4817    ulCfg->initialUplinkBWP = NULLP;
4818    DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4819    if(!ulCfg->initialUplinkBWP)
4820    {
4821       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4822       return RFAILED;
4823    }
4824
4825    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
4826    {
4827       return RFAILED;
4828    }
4829
4830    ulCfg->uplinkBWP_ToReleaseList = NULLP;
4831    ulCfg->uplinkBWP_ToAddModList = NULLP;
4832    ulCfg->firstActiveUplinkBWP_Id = NULLP;
4833    DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4834    if(!ulCfg->firstActiveUplinkBWP_Id)
4835    {
4836       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4837       return RFAILED;
4838    }
4839    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
4840
4841    ulCfg->pusch_ServingCellConfig = NULLP;
4842    DU_ALLOC(ulCfg->pusch_ServingCellConfig, \
4843          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4844    if(!ulCfg->pusch_ServingCellConfig)
4845    {
4846       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4847       return RFAILED;
4848    }
4849
4850    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
4851    {
4852       return RFAILED;
4853    }
4854
4855    ulCfg->carrierSwitching = NULLP;
4856    ulCfg->ext1 = NULLP;
4857    return ROK;
4858 }
4859
4860 /*******************************************************************
4861  *
4862  * @brief Builds PDSCH serving cell config
4863  * @details
4864  *
4865  *    Function : BuildPdschSrvCellCfg
4866  *
4867  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
4868  *
4869  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
4870  *
4871  * @return ROK     - success
4872  *         RFAILED - failure
4873  *
4874  * ****************************************************************/
4875 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
4876 {
4877    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
4878    pdschCfg->choice.setup = NULLP;
4879    DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
4880    if(!pdschCfg->choice.setup)
4881    {
4882       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4883       return RFAILED;
4884    }
4885
4886    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4887    pdschCfg->choice.setup->xOverhead = NULLP;
4888    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
4889    DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
4890    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
4891    {
4892       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4893       return RFAILED;
4894    }
4895    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
4896    pdschCfg->choice.setup->pucch_Cell = NULLP;
4897    pdschCfg->choice.setup->ext1 = NULLP;
4898
4899    return ROK;
4900 }
4901
4902 /*******************************************************************
4903  *
4904  * @brief Builds CSI Meas config
4905  * @details
4906  *
4907  *    Function : BuildCsiMeasCfg
4908  *
4909  *    Functionality: Builds CSI Meas config in spCellCfgDed
4910  *
4911  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
4912  *
4913  * @return ROK     - success
4914  *         RFAILED - failure
4915  *
4916  * ****************************************************************/
4917 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
4918 {
4919
4920    return ROK;
4921 }
4922
4923 /*******************************************************************
4924  *
4925  * @brief Builds Spcell config dedicated
4926  * @details
4927  *
4928  *    Function : BuildSpCellCfgDed
4929  *
4930  *    Functionality: Builds sp cell config dedicated in spCellCfg
4931  *
4932  * @params[in] ServingCellConfig_t srvCellCfg
4933  *
4934  * @return ROK     - success
4935  *         RFAILED - failure
4936  *
4937  * ****************************************************************/
4938 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
4939 {
4940    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
4941    DU_ALLOC(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
4942    if(!srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
4943    {
4944       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4945       return RFAILED;
4946    }
4947
4948    srvCellCfg->initialDownlinkBWP = NULLP;
4949    DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
4950    if(!srvCellCfg->initialDownlinkBWP)
4951    {
4952       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4953       return RFAILED;
4954    }
4955
4956    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
4957    {
4958       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
4959       return RFAILED;
4960    }
4961    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
4962    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
4963
4964    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
4965    DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
4966    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
4967    {
4968       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4969       return RFAILED;
4970    }
4971    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4972
4973    srvCellCfg->bwp_InactivityTimer = NULLP;
4974
4975    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
4976    DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
4977    if(!srvCellCfg->defaultDownlinkBWP_Id)
4978    {
4979       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4980       return RFAILED;
4981    }
4982    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4983
4984    srvCellCfg->uplinkConfig = NULLP;
4985    DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
4986    if(!srvCellCfg->uplinkConfig)
4987    {
4988       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4989       return RFAILED;
4990    }
4991
4992    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
4993    {
4994       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
4995       return RFAILED;
4996    }
4997    srvCellCfg->supplementaryUplink = NULLP;
4998    srvCellCfg->pdcch_ServingCellConfig = NULLP;
4999
5000    srvCellCfg->pdsch_ServingCellConfig = NULLP;
5001    DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
5002    if(!srvCellCfg->pdsch_ServingCellConfig)
5003    {
5004       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5005       return RFAILED;
5006    }
5007
5008    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
5009    {
5010       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
5011       return RFAILED;
5012    }
5013
5014    srvCellCfg->csi_MeasConfig = NULLP;
5015 #if 0
5016    DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
5017       if(!srvCellCfg->csi_MeasConfig)
5018       {
5019          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5020          return RFAILED;
5021       }
5022
5023    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
5024    {
5025       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
5026       return RFAILED;
5027    }
5028 #endif
5029    srvCellCfg->sCellDeactivationTimer = NULLP;
5030    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
5031    srvCellCfg->tag_Id = TAG_ID;
5032    srvCellCfg->dummy = NULLP;
5033    srvCellCfg->pathlossReferenceLinking = NULLP;
5034    srvCellCfg->servingCellMO = NULLP;
5035    srvCellCfg->ext1 = NULLP;
5036
5037    return ROK;
5038 }
5039 /*******************************************************************
5040  *
5041  * @brief Builds Spcell config
5042  *
5043  * @details
5044  *
5045  *    Function : BuildSpCellCfg
5046  *
5047  *    Functionality: Builds sp cell config in DuToCuRrcContainer
5048  *
5049  * @params[in] SpCellConfig_t spCellCfg
5050  *
5051  * @return ROK     - success
5052  *         RFAILED - failure
5053  *
5054  * ****************************************************************/
5055 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
5056 {
5057
5058    spCellCfg->servCellIndex = NULLP;
5059    DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
5060    if(!spCellCfg->servCellIndex)
5061    {
5062       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5063       return RFAILED;
5064    }
5065    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
5066
5067    spCellCfg->reconfigurationWithSync = NULLP;
5068    spCellCfg->rlf_TimersAndConstants = NULLP;
5069    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
5070    DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5071    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
5072    {
5073       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5074       return RFAILED;
5075    }
5076    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
5077
5078    spCellCfg->spCellConfigDedicated = NULLP;
5079    DU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5080    if(!spCellCfg->spCellConfigDedicated)
5081    {
5082       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5083       return RFAILED;
5084    }
5085    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
5086    {
5087       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
5088       return RFAILED;
5089    }
5090    return ROK;
5091 }
5092 /*******************************************************************
5093  *
5094  * @brief Builds Phy cell group config
5095  *
5096  * @details
5097  *
5098  *    Function : BuildPhyCellGrpCfg
5099  *
5100  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
5101  *
5102  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
5103  *
5104  * @return ROK     - success
5105  *         RFAILED - failure
5106  *
5107  * ****************************************************************/
5108 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
5109 {
5110    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
5111    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
5112
5113    phyCellGrpCfg->p_NR_FR1 = NULLP;
5114    DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5115    if(!phyCellGrpCfg->p_NR_FR1)
5116    {
5117       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
5118       return RFAILED;
5119    }
5120    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
5121    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
5122    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
5123    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
5124    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
5125    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
5126    phyCellGrpCfg->cs_RNTI = NULLP;
5127    phyCellGrpCfg->ext1 = NULLP;
5128    phyCellGrpCfg->ext2 = NULLP;
5129
5130    return ROK;
5131 }
5132 /*******************************************************************
5133  *
5134  * @brief Builds Mac cell group config
5135  *
5136  * @details
5137  *
5138  *    Function : BuildMacCellGrpCfg
5139  *
5140  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
5141  *
5142  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
5143  *
5144  * @return ROK     - success
5145  *         RFAILED - failure
5146  *
5147  * ****************************************************************/
5148 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
5149 {
5150    macCellGrpCfg->drx_Config = NULLP;
5151    macCellGrpCfg->schedulingRequestConfig = NULLP;
5152    DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5153    if(!macCellGrpCfg->schedulingRequestConfig)
5154    {
5155       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5156       return RFAILED;
5157    }
5158
5159    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
5160    {
5161       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
5162       return RFAILED;
5163    }
5164
5165    macCellGrpCfg->bsr_Config = NULLP;
5166    DU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5167    if(!macCellGrpCfg->bsr_Config)
5168    {
5169       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5170       return RFAILED;
5171    }
5172
5173    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
5174    {
5175       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
5176       return RFAILED;
5177    }
5178
5179    macCellGrpCfg->tag_Config = NULLP;
5180    DU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
5181    if(!macCellGrpCfg->tag_Config)
5182    {
5183       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5184       return RFAILED;
5185    }
5186
5187    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
5188    {
5189       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
5190       return RFAILED;
5191    }
5192
5193    macCellGrpCfg->phr_Config = NULLP;
5194    DU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
5195    if(!macCellGrpCfg->phr_Config)
5196    {
5197       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5198       return RFAILED;
5199    }
5200
5201    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
5202    {
5203       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
5204       return RFAILED;
5205    }
5206
5207    macCellGrpCfg->skipUplinkTxDynamic = false;
5208    macCellGrpCfg->ext1 = NULLP;
5209
5210    return ROK;
5211 }
5212 /*******************************************************************
5213  *
5214  * @brief Frees memeory allocated for SearchSpcToAddModList
5215  *
5216  * @details
5217  *
5218  *    Function : FreeSearchSpcToAddModList
5219  *
5220  *    Functionality: Deallocating memory of SearchSpcToAddModList
5221  *
5222  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
5223  *
5224  * @return void
5225  *
5226  4221 * ****************************************************************/
5227 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
5228 {
5229    uint8_t idx1=0;
5230    uint8_t idx2=0;
5231    struct  SearchSpace *searchSpc=NULLP;
5232
5233    if(searchSpcList->list.array)
5234    {
5235       if(searchSpcList->list.array[idx2])
5236       {
5237          searchSpc = searchSpcList->list.array[idx2];
5238          if(searchSpc->controlResourceSetId)
5239          {
5240             if(searchSpc->monitoringSlotPeriodicityAndOffset)
5241             {
5242                if(searchSpc->monitoringSymbolsWithinSlot)
5243                {
5244                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
5245                   {
5246                      if(searchSpc->nrofCandidates)
5247                      {
5248                         if(searchSpc->searchSpaceType)
5249                         {
5250                            DU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
5251                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
5252                            DU_FREE(searchSpc->searchSpaceType, sizeof(struct
5253                                     SearchSpace__searchSpaceType));
5254                         }
5255                         DU_FREE(searchSpc->nrofCandidates,
5256                               sizeof(struct SearchSpace__nrofCandidates));
5257                      }
5258                      DU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
5259                            searchSpc->monitoringSymbolsWithinSlot->size);
5260                   }
5261                   DU_FREE(searchSpc->monitoringSymbolsWithinSlot,
5262                         sizeof(BIT_STRING_t));
5263                }
5264                DU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
5265                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
5266             }
5267             DU_FREE(searchSpc->controlResourceSetId,
5268                   sizeof(ControlResourceSetId_t));
5269          }
5270       }
5271       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
5272       {
5273          DU_FREE(searchSpcList->list.array[idx1],
5274                sizeof(struct SearchSpace));
5275       }
5276       DU_FREE(searchSpcList->list.array,searchSpcList->list.size);
5277    }
5278 }
5279 /*******************************************************************
5280  *
5281  * @brief Frees memory allocated for PdschTimeDomAllocList
5282  *
5283  * @details
5284  *
5285  *    Function : FreePdschTimeDomAllocList
5286  *
5287  *    Functionality: Deallocating memory of PdschTimeDomAllocList
5288  *
5289  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
5290  *
5291  * @return void
5292  *
5293  * ****************************************************************/
5294 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
5295 {
5296    uint8_t idx1=0;
5297
5298    if(timeDomAllocList->choice.setup)
5299    {
5300       if(timeDomAllocList->choice.setup->list.array)
5301       {
5302          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
5303          {
5304             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1]->k0, sizeof(long));
5305             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
5306                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
5307          }
5308          DU_FREE(timeDomAllocList->choice.setup->list.array, \
5309                timeDomAllocList->choice.setup->list.size);
5310       }
5311       DU_FREE(timeDomAllocList->choice.setup,\
5312             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
5313    }
5314 }
5315 /*******************************************************************
5316  *
5317  * @brief Frees memory allocated for PuschTimeDomAllocList
5318  *
5319  *@details
5320  *
5321  *    Function : FreePuschTimeDomAllocList
5322  *
5323  *    Functionality: Deallocating memory of PuschTimeDomAllocList
5324  *
5325  * @params[in] PUSCH_Config_t *puschCfg
5326  *
5327  * @return void
5328  *
5329  * ****************************************************************/
5330 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
5331 {
5332    uint8_t rsrcListIdx=0;
5333    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
5334
5335    if(puschCfg->pusch_TimeDomainAllocationList)
5336    {
5337       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
5338       if(timeDomAllocList_t->choice.setup)
5339       {
5340          if(timeDomAllocList_t->choice.setup->list.array)
5341          {
5342             for(rsrcListIdx = 0; rsrcListIdx<timeDomAllocList_t->choice.setup->list.count; rsrcListIdx++)
5343             {
5344                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx]->k2, sizeof(long));
5345                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx],\
5346                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
5347             }
5348             DU_FREE(timeDomAllocList_t->choice.setup->list.array, \
5349                   timeDomAllocList_t->choice.setup->list.size);
5350          }
5351          DU_FREE(timeDomAllocList_t->choice.setup, \
5352                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
5353       }
5354       DU_FREE(puschCfg->transformPrecoder, sizeof(long));
5355       DU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
5356             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
5357    }
5358
5359 }
5360 /*******************************************************************
5361  *
5362  * @brief Frees memory allocated for InitialUlBWP
5363  *
5364  * @details
5365  *
5366  *    Function : FreeInitialUlBWP
5367  *
5368  *    Functionality: Deallocating memory of InitialUlBWP
5369  *
5370  * @params[in] BWP_UplinkDedicated_t *ulBwp
5371  *
5372  * @return void
5373  *
5374  * ****************************************************************/
5375 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5376 {
5377    uint8_t  rSetIdx, rsrcIdx, k1Idx;
5378    SRS_Config_t   *srsCfg = NULLP;
5379    PUSCH_Config_t *puschCfg = NULLP;
5380    PUCCH_Config_t *pucchCfg = NULLP;
5381    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
5382    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
5383    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
5384    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
5385
5386    if(ulBwp->pucch_Config)
5387    {
5388       if(ulBwp->pucch_Config->choice.setup)
5389       {
5390           pucchCfg = ulBwp->pucch_Config->choice.setup;
5391           if(pucchCfg->dl_DataToUL_ACK)
5392           {
5393              if(pucchCfg->dl_DataToUL_ACK->list.array)
5394              {
5395                 for(k1Idx = 0; k1Idx < pucchCfg->dl_DataToUL_ACK->list.count; k1Idx++)
5396                 {
5397                    DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[k1Idx], sizeof(long));
5398                 }
5399                 DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
5400              }
5401              DU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
5402           }
5403           DU_FREE(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
5404       }
5405       DU_FREE(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
5406    }
5407
5408    if(ulBwp->pusch_Config)
5409    {
5410       if(ulBwp->pusch_Config->choice.setup)
5411       {
5412          puschCfg=ulBwp->pusch_Config->choice.setup;
5413          if(puschCfg->dataScramblingIdentityPUSCH)
5414          {
5415             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
5416             {
5417                FreePuschTimeDomAllocList(puschCfg);
5418                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
5419                if(dmrsUlCfg->choice.setup)
5420                {
5421                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
5422                   {
5423                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
5424                      {
5425                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
5426                               sizeof(long));
5427                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
5428                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
5429                      }
5430                      DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
5431                            sizeof(long));
5432                   }
5433                   DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
5434                }
5435                DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
5436                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
5437             }
5438             DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
5439          }
5440          DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5441       }
5442       DU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5443
5444       /* Free SRS-Config */
5445       if(ulBwp->srs_Config)
5446       {
5447          if(ulBwp->srs_Config->choice.setup)
5448          {
5449             srsCfg = ulBwp->srs_Config->choice.setup;
5450
5451             /* Free Resource Set to add/mod list */
5452             if(srsCfg->srs_ResourceSetToAddModList)
5453             {
5454                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
5455                if(rsrcSetList->list.array)
5456                {
5457                   rSetIdx = 0;
5458
5459                   /* Free SRS resource Id list in this SRS resource set */
5460                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5461                   {
5462                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5463
5464                      if(rsrcIdList->list.array)
5465                      {
5466                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5467                         {
5468                            DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5469                         }
5470                         DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
5471                      }
5472                      DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5473                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5474                   }
5475
5476                   /* Free resource type info for this SRS resource set */
5477                   DU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5478                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5479
5480                   /* Free memory for each resource set */
5481                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5482                   {
5483                      DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5484                   }
5485                   DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
5486                }
5487                DU_FREE(srsCfg->srs_ResourceSetToAddModList, \
5488                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5489             }
5490
5491             /* Free resource to add/modd list */
5492             if(srsCfg->srs_ResourceToAddModList)
5493             {
5494                resourceList = srsCfg->srs_ResourceToAddModList;
5495                if(resourceList->list.array)
5496                {
5497                   rsrcIdx = 0;
5498                   DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
5499                         sizeof(struct SRS_Resource__transmissionComb__n2));
5500                   DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
5501                         sizeof(struct SRS_Resource__resourceType__aperiodic));
5502
5503                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5504                   {
5505                      DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5506                   }
5507                   DU_FREE(resourceList->list.array, resourceList->list.size);
5508                }
5509                DU_FREE(srsCfg->srs_ResourceToAddModList, \
5510                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
5511             }
5512
5513             DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5514          }
5515          DU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5516       }
5517    }
5518 }
5519 /*******************************************************************
5520  *
5521  * @brief Frees memory allocated for initialUplinkBWP
5522  *
5523  * @details
5524  *
5525  *    Function : FreeinitialUplinkBWP
5526  *
5527  *    Functionality: Deallocating memory of initialUplinkBWP
5528  *
5529  * @params[in] UplinkConfig_t *ulCfg
5530  *
5531  * @return void
5532  *
5533  *
5534  * ****************************************************************/
5535 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
5536 {
5537    BWP_UplinkDedicated_t *ulBwp=NULLP;
5538    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
5539
5540    if(ulCfg->initialUplinkBWP)
5541    {
5542       ulBwp=ulCfg->initialUplinkBWP;
5543       if(ulCfg->firstActiveUplinkBWP_Id)
5544       {
5545          if(ulCfg->pusch_ServingCellConfig)
5546          {
5547             puschCfg=ulCfg->pusch_ServingCellConfig;
5548             if(puschCfg->choice.setup)
5549             {
5550                if(puschCfg->choice.setup->ext1)
5551                {
5552                   DU_FREE(puschCfg->choice.setup->ext1->\
5553                         processingType2Enabled,sizeof(BOOLEAN_t));
5554                   DU_FREE(puschCfg->choice.setup->ext1->\
5555                         maxMIMO_Layers,sizeof(long));
5556                   DU_FREE(puschCfg->choice.setup->ext1, \
5557                         sizeof(struct PUSCH_ServingCellConfig__ext1));
5558                }
5559                DU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5560             }
5561             DU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5562          }
5563          DU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5564       }
5565       FreeInitialUlBWP(ulBwp);
5566       DU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5567    }
5568 }
5569 /*******************************************************************
5570  *
5571  * @brief Frees emmory allocated for BWPDlDedPdschCfg
5572  *
5573  * @details
5574  *
5575  *    Function : FreeBWPDlDedPdschCfg
5576  *
5577  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
5578  *
5579  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5580  *
5581  * @return void
5582  *
5583  *
5584  * ****************************************************************/
5585 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
5586 {
5587    struct PDSCH_Config *pdschCfg=NULLP;
5588    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
5589    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
5590    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
5591
5592    if(dlBwp->pdsch_Config->choice.setup)
5593    {
5594       pdschCfg=dlBwp->pdsch_Config->choice.setup;
5595       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
5596       {
5597          if(pdschCfg->pdsch_TimeDomainAllocationList)
5598          {
5599             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
5600             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
5601             {
5602                prbBndlType=&pdschCfg->prb_BundlingType;
5603                DU_FREE(prbBndlType->choice.staticBundling,\
5604                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
5605                DU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
5606             }
5607             FreePdschTimeDomAllocList(timeDomAllocList);
5608             DU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
5609                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
5610          }
5611          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
5612          if(dmrsDlCfg->choice.setup)
5613          {
5614             DU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
5615                   sizeof(long));
5616             DU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
5617          }
5618          DU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
5619                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
5620       }
5621       DU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
5622    }
5623 }
5624 /*******************************************************************
5625  *
5626  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
5627  *
5628  * @details
5629  *
5630  *    Function : FreeBWPDlDedPdcchCfg
5631  *
5632  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
5633  *
5634  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5635  *
5636  * @return void
5637  *
5638  *
5639  * ****************************************************************/
5640 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
5641 {
5642    uint8_t idx1=0;
5643    uint8_t idx2=0;
5644    struct PDCCH_Config *pdcchCfg=NULLP;
5645    struct ControlResourceSet *controlRSet=NULLP;
5646    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
5647
5648    if(dlBwp->pdcch_Config->choice.setup)
5649    {
5650       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
5651       if(pdcchCfg->controlResourceSetToAddModList)
5652       {
5653          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
5654          if(controlRSetList->list.array)
5655          {
5656             controlRSet = controlRSetList->list.array[idx2];
5657             if(controlRSet)
5658             {
5659                if(controlRSet->frequencyDomainResources.buf)
5660                {
5661                   if(controlRSet->pdcch_DMRS_ScramblingID)
5662                   {
5663                      if(pdcchCfg->searchSpacesToAddModList)
5664                      {
5665                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
5666                         DU_FREE(pdcchCfg->searchSpacesToAddModList, \
5667                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
5668                      }
5669                      DU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
5670                   }
5671                   DU_FREE(controlRSet->frequencyDomainResources.buf, \
5672                         controlRSet->frequencyDomainResources.size);
5673                }
5674             }
5675             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
5676             {
5677                DU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
5678             }
5679             DU_FREE(controlRSetList->list.array, controlRSetList->list.size);
5680          }
5681          DU_FREE(pdcchCfg->controlResourceSetToAddModList, \
5682                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
5683       }
5684       DU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
5685    }
5686 }
5687
5688 /*******************************************************************
5689  *
5690  * @brief Frees emmory allocated for DUToCURRCContainer
5691  *
5692  * @details
5693  *
5694  *    Function : FreeMemDuToCuRrcCont
5695  *
5696  *    Functionality: Deallocating memory of DuToCuRrcContainer
5697  *
5698  * @params[in] DuToCuRRCContainer, DuToCuRRCContainer
5699  *
5700  * @return ROK     - success
5701  *         RFAILED - failure
5702  *
5703  * ****************************************************************/
5704 uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg)
5705 {
5706    uint8_t idx=0;
5707    SpCellConfig_t *spCellCfg=NULLP;
5708    ServingCellConfig_t *srvCellCfg=NULLP;
5709    BWP_DownlinkDedicated_t *dlBwp=NULLP;
5710    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
5711    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
5712    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
5713    struct RLC_Config *rlcConfig=NULLP;
5714    struct LogicalChannelConfig *macLcConfig=NULLP;
5715    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
5716    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
5717    struct TAG_Config *tagConfig=NULLP;
5718    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
5719    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
5720    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
5721
5722    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
5723    if(rlcBearerList)
5724    {
5725       if(rlcBearerList->list.array)
5726       {
5727          for(idx=0; idx<rlcBearerList->list.count; idx++)
5728          {
5729             if(rlcBearerList->list.array[idx])
5730             {
5731                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
5732                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
5733                if(rlcConfig)
5734                {
5735                   if(rlcConfig->choice.am)
5736                   {
5737                      DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5738                      DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5739                      DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
5740                   }
5741                   DU_FREE(rlcConfig, sizeof(struct RLC_Config));
5742                }
5743                DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
5744                if(macLcConfig)
5745                {
5746                   if(macLcConfig->ul_SpecificParameters)
5747                   {
5748                      DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
5749                      DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
5750                      DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
5751                   }
5752                   DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
5753                }
5754                DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
5755             }
5756          }
5757          DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
5758       }
5759       DU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5760    }
5761
5762    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
5763    if(macCellGrpCfg)
5764    {
5765       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
5766       if(schedulingRequestConfig)
5767       {
5768          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
5769          if(schReqList)
5770          {
5771             if(schReqList->list.array)
5772             {
5773                for(idx=0;idx<schReqList->list.count; idx++)
5774                {
5775                   if(schReqList->list.array[idx])
5776                   {
5777                      DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
5778                      DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
5779                   }
5780                }
5781                DU_FREE(schReqList->list.array, schReqList->list.size);
5782             }
5783             DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
5784                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
5785             DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5786       }
5787       if(macCellGrpCfg->bsr_Config)
5788       {
5789          DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5790       }
5791       tagConfig = macCellGrpCfg->tag_Config;
5792       if(tagConfig)
5793       {
5794          tagList = tagConfig->tag_ToAddModList;
5795          if(tagList)
5796          {
5797             if(tagList->list.array)
5798             {
5799                for(idx=0; idx<tagList->list.count; idx++)
5800                {
5801                   DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
5802                }
5803                DU_FREE(tagList->list.array, tagList->list.size);
5804             }
5805             DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
5806          }
5807          DU_FREE(tagConfig, sizeof(struct TAG_Config));
5808       }
5809
5810       phrConfig = macCellGrpCfg->phr_Config;
5811       if(phrConfig)
5812       {
5813          DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
5814          DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
5815       }
5816
5817       DU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
5818    }
5819
5820    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
5821    if(phyCellGrpCfg)
5822    {
5823       DU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5824       DU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
5825    }
5826
5827    spCellCfg = cellGrpCfg->spCellConfig;
5828    if(spCellCfg)
5829    {
5830       if(spCellCfg->servCellIndex)
5831       {
5832          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
5833          {
5834             if(spCellCfg->spCellConfigDedicated)
5835             {
5836                srvCellCfg = spCellCfg->spCellConfigDedicated;
5837                if(srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
5838                {
5839                   if(srvCellCfg->initialDownlinkBWP)
5840                   {
5841                      dlBwp = srvCellCfg->initialDownlinkBWP;
5842                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
5843                      {
5844                         if(srvCellCfg->defaultDownlinkBWP_Id)
5845                         {
5846                            if(srvCellCfg->uplinkConfig)
5847                            {
5848                               if(srvCellCfg->pdsch_ServingCellConfig)
5849                               {
5850                                  pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
5851                                  if(pdschCfg->choice.setup)
5852                                  {
5853                                     DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
5854                                     DU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5855                                  }
5856                                  DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
5857                                           ServingCellConfig__pdsch_ServingCellConfig));
5858                               }
5859                               FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
5860                               DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
5861                            }
5862                            DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
5863                         }
5864                         DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
5865                      }
5866                      if(dlBwp->pdcch_Config)
5867                      {
5868                         if(dlBwp->pdsch_Config)
5869                         {
5870                            FreeBWPDlDedPdschCfg(dlBwp);
5871                            DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
5872                         }
5873                         FreeBWPDlDedPdcchCfg(dlBwp);
5874                         DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
5875                      }
5876                      DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
5877                   }
5878                   DU_FREE(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
5879                }
5880                DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5881             }
5882             DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5883          }
5884          DU_FREE(spCellCfg->servCellIndex, sizeof(long));
5885       }
5886       DU_FREE(spCellCfg,sizeof(SpCellConfig_t));
5887    }
5888    return ROK;
5889 }
5890 /*******************************************************************
5891  *
5892  * @brief Builds DU To CU RRC Container
5893  *
5894  * @details
5895  *
5896  *    Function : BuildDuToCuRrcContainer
5897  *
5898  *    Functionality: Builds DuToCuRrcContainer
5899  *
5900  * @params[in] idx, index in F1AP msg
5901  *             DuToCuRRCContainer, DuToCuRRCContainer
5902  *
5903  * @return ROK     - success
5904  *         RFAILED - failure
5905  *
5906  * ****************************************************************/
5907 uint8_t BuildDuToCuRrcContainer(DUtoCURRCContainer_t *duToCuRrcContainer)
5908 {
5909    uint8_t  ret = ROK;
5910    CellGroupConfigRrc_t  cellGrpCfg;
5911    asn_enc_rval_t        encRetVal;
5912    memset(&cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
5913    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
5914
5915    while(true)
5916    {
5917       cellGrpCfg.cellGroupId = CELL_GRP_ID;
5918
5919       cellGrpCfg.rlc_BearerToAddModList = NULLP;
5920       DU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5921       if(!cellGrpCfg.rlc_BearerToAddModList)
5922       {
5923          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5924          ret = RFAILED;
5925          break;
5926       }
5927       if(BuildRlcBearerToAddModList(cellGrpCfg.rlc_BearerToAddModList) != ROK)
5928       {
5929          DU_LOG("\nERROR  -->  F1AP : BuildRlcBearerToAddModList failed");
5930          ret = RFAILED;
5931          break;
5932       }
5933
5934       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
5935       cellGrpCfg.mac_CellGroupConfig = NULLP;
5936       DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
5937       if(!cellGrpCfg.mac_CellGroupConfig)
5938       {
5939          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5940          ret = RFAILED;
5941          break;
5942       }
5943       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
5944       {
5945          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
5946          ret = RFAILED;
5947          break;
5948       }
5949
5950       cellGrpCfg.physicalCellGroupConfig = NULLP;
5951       DU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
5952       if(!cellGrpCfg.physicalCellGroupConfig)
5953       {
5954          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5955          ret = RFAILED;
5956          break;
5957       }
5958       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
5959       {
5960          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
5961          ret = RFAILED;
5962          break;
5963       }
5964
5965       cellGrpCfg.spCellConfig = NULLP;
5966       DU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
5967       if(!cellGrpCfg.spCellConfig)
5968       {
5969          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5970          ret = RFAILED;
5971          break;
5972       }
5973       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
5974       {
5975          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
5976          ret = RFAILED;
5977          break;
5978       }
5979
5980       cellGrpCfg.sCellToAddModList = NULLP;
5981       cellGrpCfg.sCellToReleaseList = NULLP;
5982       cellGrpCfg.ext1 = NULLP;
5983
5984       /* encode cellGrpCfg into duToCuRrcContainer */
5985       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
5986       memset(encBuf, 0, ENC_BUF_MAX_LEN);
5987       encBufSize = 0;
5988       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
5989       /* Encode results */
5990       if(encRetVal.encoded == ENCODE_FAIL)
5991       {
5992          DU_LOG( "\nERROR  --> F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
5993                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5994          ret = RFAILED;
5995          break;
5996       }
5997       else
5998       {
5999          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
6000          for(int i=0; i< encBufSize; i++)
6001          {
6002             printf("%x",encBuf[i]);
6003          }
6004       }
6005
6006       duToCuRrcContainer->size = encBufSize;
6007       DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
6008       if(!duToCuRrcContainer->buf)
6009       {
6010          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
6011          ret = RFAILED;
6012          break;
6013       }
6014       if(ret == ROK)
6015       {
6016          memcpy(duToCuRrcContainer->buf, encBuf, duToCuRrcContainer->size);
6017       }
6018       break;
6019    }
6020    FreeMemDuToCuRrcCont(&cellGrpCfg);
6021    return ret;
6022 }
6023
6024 /*******************************************************************
6025  *
6026  * @brief Free memory allocated in InitialULRRCMessage
6027  *
6028  * @details
6029  *
6030  *    Function : freeInitUlRrcMsgTransfer
6031  *
6032  *    Functionality: Free memory allocated in InitialULRRCMessage
6033  *
6034  * @params[in]F1AP_PDU_t  *f1apMsg)
6035  *
6036  * @return ROK     - success
6037  *         RFAILED - failure
6038  *
6039  * ****************************************************************/
6040
6041 uint8_t freeInitUlRrcMsgTransfer(F1AP_PDU_t  *f1apMsg)
6042 {
6043    uint8_t ieIdx, arrIdx;
6044    InitialULRRCMessageTransfer_t *initULRRCMsg=NULLP;
6045
6046    if(f1apMsg)
6047    {
6048       if(f1apMsg->choice.initiatingMessage)
6049       {
6050          initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.\
6051             choice.InitialULRRCMessageTransfer;
6052          if(initULRRCMsg->protocolIEs.list.array)
6053          {
6054             for(ieIdx = 0; ieIdx < initULRRCMsg->protocolIEs.list.count; ieIdx++)
6055             {
6056                switch(initULRRCMsg->protocolIEs.list.array[ieIdx]->id)
6057                {
6058                   case ProtocolIE_ID_id_NRCGI:
6059                   {
6060                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf)
6061                      {
6062                         if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf)
6063                         {
6064                            DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf,\
6065                            initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.size);
6066                         }
6067                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf,\
6068                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.size);
6069                      }
6070                      break;
6071                   }
6072                   case ProtocolIE_ID_id_RRCContainer:
6073                   {
6074                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
6075                      {
6076                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,\
6077                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
6078                      }
6079                      break;
6080                   }
6081                   case ProtocolIE_ID_id_DUtoCURRCContainer:
6082                   {
6083                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf)
6084                      {
6085                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf,
6086                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.size);
6087                      }
6088                      break;
6089                   }
6090                   default:
6091                      break;
6092                }
6093              }
6094              for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
6095              {
6096                 if(initULRRCMsg->protocolIEs.list.array[arrIdx])
6097                 {
6098                    DU_FREE(initULRRCMsg->protocolIEs.list.array[arrIdx],\
6099                       sizeof(InitialULRRCMessageTransferIEs_t));
6100                 }
6101              }
6102              DU_FREE(initULRRCMsg->protocolIEs.list.array, initULRRCMsg->protocolIEs.list.size);
6103           }
6104          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
6105       }
6106       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
6107    }
6108    else
6109    {
6110       DU_LOG("\nERROR  -->  DU_APP : Recevied F1ap Pdu is null at freeInitUlRrcMsgTransfer()");
6111       return RFAILED;
6112    }
6113    return ROK;
6114 }
6115
6116 /*******************************************************************
6117  *
6118  * @brief Builds and sends the InitialULRRCMessage
6119  *
6120  * @details
6121  *
6122  *    Function : BuildAndSendInitialRrcMsgTransfer
6123  *
6124  *    Functionality: Constructs the Initial UL RRC Message Transfer and sends
6125  *                   it to the CU through SCTP.
6126  *
6127  * @params[in]
6128  *
6129  * @return ROK     - success
6130  *         RFAILED - failure
6131  *
6132  * ****************************************************************/
6133 uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti,
6134       uint16_t rrcContSize, uint8_t *rrcContainer)
6135 {
6136    uint8_t   ret;
6137    uint8_t   elementCnt;
6138    uint8_t   ieIdx;
6139    asn_enc_rval_t  encRetVal;
6140    F1AP_PDU_t  *f1apMsg = NULLP;
6141    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
6142    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
6143
6144    while(true)
6145    {
6146       DU_LOG("\n INFO   -->  F1AP : Building RRC Setup Request\n");
6147       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
6148       if(f1apMsg == NULLP)
6149       {
6150          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
6151          break;
6152       }
6153       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
6154       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
6155       if(f1apMsg->choice.initiatingMessage == NULLP)
6156       {
6157          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
6158          break;
6159       }
6160       f1apMsg->choice.initiatingMessage->procedureCode =\
6161                                                         ProcedureCode_id_InitialULRRCMessageTransfer;
6162       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
6163       f1apMsg->choice.initiatingMessage->value.present = \
6164                                                          InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
6165       initULRRCMsg =\
6166                     &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
6167       elementCnt = 5;
6168       initULRRCMsg->protocolIEs.list.count = elementCnt;
6169       initULRRCMsg->protocolIEs.list.size = \
6170                                             elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *);
6171       /* Initialize the F1Setup members */
6172       DU_ALLOC(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
6173       if(initULRRCMsg->protocolIEs.list.array == NULLP)
6174       {
6175          DU_LOG(" ERROR  -->  F1AP : Memory allocation for\
6176                RRCSetupRequestMessageTransferIEs failed");
6177          break;
6178       }
6179       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
6180       {
6181          DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx],\
6182                sizeof(InitialULRRCMessageTransferIEs_t));
6183          if(initULRRCMsg->protocolIEs.list.array[ieIdx] == NULLP)
6184          {
6185             break;
6186          }
6187       }
6188       ieIdx = 0;
6189       /*GNB DU UE F1AP ID*/
6190       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6191                                                         ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
6192       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  = Criticality_reject;
6193       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
6194                                                                   InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
6195       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
6196
6197
6198       /*NRCGI*/
6199       ieIdx++;
6200       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6201                                                         ProtocolIE_ID_id_NRCGI;
6202       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  =Criticality_reject;
6203       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
6204                                                                   InitialULRRCMessageTransferIEs__value_PR_NRCGI;
6205
6206       ret =\
6207            BuildNrcgi(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
6208       if(ret!=ROK)
6209       {
6210          break;
6211       }
6212
6213       /*CRNTI*/
6214       ieIdx++;
6215       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6216                                                         ProtocolIE_ID_id_C_RNTI;
6217       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6218       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6219                                                                  InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
6220       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.C_RNTI = crnti;
6221
6222       /*RRCContainer*/
6223       ieIdx++;
6224       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6225                                                         ProtocolIE_ID_id_RRCContainer;
6226       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6227       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6228                                                                  InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
6229
6230       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = rrcContSize;
6231       DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
6232             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size)
6233       if(!initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
6234       {
6235          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
6236          break;
6237
6238       }
6239       memcpy(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, rrcContainer,
6240             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
6241
6242
6243       /*DUtoCURRCContainer*/
6244       ieIdx++;
6245       initULRRCMsg->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCContainer;
6246       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6247       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6248                                                                  InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
6249
6250       ret = BuildDuToCuRrcContainer(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer);
6251       if(ret != ROK)
6252       {
6253          break;
6254       }
6255
6256       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
6257
6258       /* Encode the F1SetupRequest type as APER */
6259       memset(encBuf, 0, ENC_BUF_MAX_LEN);
6260       encBufSize = 0;
6261       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
6262       /* Encode results */
6263       if(encRetVal.encoded == ENCODE_FAIL)
6264       {
6265          DU_LOG( "\nERROR  --> F1AP : Could not encode Initial UL RRC Message Transfer\
6266                structure (at %s)\n",encRetVal.failed_type ? \
6267                encRetVal.failed_type->name : "unknown");
6268          ret = RFAILED;
6269          break;
6270       }
6271       else
6272       {
6273
6274          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for Initial UL RRC\
6275                Message transfer\n");
6276          for(int i=0; i< encBufSize; i++)
6277          {
6278             printf("%x",encBuf[i]);
6279          }
6280       }
6281       /* Sending  msg  */
6282       if(sendF1APMsg() != ROK)
6283       {
6284          DU_LOG("\nERROR  -->  F1AP : Sending Initial UL RRC Message Transfer Failed");
6285          ret = RFAILED;
6286          break;
6287       }
6288       break;
6289    }
6290    freeInitUlRrcMsgTransfer(f1apMsg);
6291    return ret;
6292 }/* End of BuildAndSendInitialRrcMsgTransfer*/
6293
6294 /*****  UE SETUP REQUEST *****/
6295
6296 /*******************************************************************
6297  *
6298  * @brief Free Qos And Snssai Drb Info
6299  *
6300  * @details
6301  *
6302  *    Function : freeDrbQosAndSnssaiInfo
6303  *
6304  *    Functionality: Free Qos And Snssai Drb Info
6305  *
6306  * @params[in] LcCfg *lcCfg,
6307  * @return void
6308  *
6309  * ****************************************************************/
6310 void freeDrbQosAndSnssaiInfo(LcCfg *lcCfg)
6311 {
6312    if(lcCfg->snssai)
6313    {
6314       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6315    }
6316    if(lcCfg->drbQos)
6317    {
6318       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
6319    }
6320 }
6321
6322 /******************************************************************
6323 *
6324 * @brief Function to delete the RLC Lc cfg from UE APP DB
6325 *
6326 * @details
6327 *
6328 *  Function : freeRlcLcCfg
6329 *
6330 *  Functionality: Function to delete the RLC Lc cfg from UE APP DB
6331 *
6332 *
6333  *****************************************************************/
6334
6335 void freeRlcLcCfg(RlcBearerCfg *lcCfg)
6336 {
6337    switch(lcCfg->rlcMode)
6338    {
6339       case RLC_AM :
6340          {
6341             if(lcCfg->u.amCfg)
6342             {
6343                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.amCfg, sizeof(AmBearerCfg));
6344             }
6345             break;
6346          }
6347       case RLC_UM_BI_DIRECTIONAL :
6348          {
6349             if(lcCfg->u.umBiDirCfg)
6350             {
6351                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
6352             }
6353             break;
6354          }
6355       case RLC_UM_UNI_DIRECTIONAL_UL :
6356          {
6357             if(lcCfg->u.umUniDirUlCfg)
6358             {
6359                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
6360             }
6361             break;
6362
6363          }
6364       case RLC_UM_UNI_DIRECTIONAL_DL :
6365          {
6366             if(lcCfg->u.umUniDirDlCfg)
6367             {
6368                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
6369             }
6370             break;
6371          }
6372       default:
6373          DU_LOG("\nERROR  -->  DU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
6374          break;
6375    }
6376    DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6377 }
6378
6379 /*******************************************************************
6380  *
6381  * @brief Function to free MacLcCfg
6382  *
6383  * @details
6384  *
6385  *    Function : freeMacLcCfg
6386  *
6387  *    Functionality: Function to free MacLcCfg
6388  *
6389  * @params[in] LcCfg *lcCfg,
6390  * @return void
6391  *
6392  * ****************************************************************/
6393
6394 void  freeMacLcCfg(LcCfg *lcCfg)
6395 {
6396     /* Deleting DRBQOS */
6397    if(lcCfg->drbQos)
6398    {
6399       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
6400    }
6401    /* Deleting SNSSAI */
6402    if(lcCfg->snssai)
6403    {
6404       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6405    }
6406 }
6407 /*******************************************************************
6408  *
6409  * @brief Free UE NR Capability received in UE Context setup request
6410  *
6411  * @details
6412  *
6413  *    Function : freeAperDecodeUeNrCapability
6414  *
6415  *    Functionality:
6416  *       Free UE NR Capability received in UE Context setup request
6417  *
6418  * @params[in]
6419  * @return ROK     - success
6420  *         RFAILED - failure
6421  *
6422  * ****************************************************************/
6423 void freeAperDecodeUeNrCapability(void *ueNrCapability)
6424 {
6425    uint8_t arrIdx =0;
6426    FeatureSets_t *featureSets =NULLP;
6427    UE_NR_Capability_t *ueNrCap = (UE_NR_Capability_t *)ueNrCapability;
6428
6429    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
6430    {
6431       for(arrIdx = 0; arrIdx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; arrIdx++)
6432       {
6433          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx])
6434             free(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx]);
6435       }
6436       free(ueNrCap->rf_Parameters.supportedBandListNR.list.array);
6437    }
6438
6439    if(ueNrCap->featureSets)
6440    {
6441       featureSets = ueNrCap->featureSets;
6442       if(featureSets->featureSetsDownlinkPerCC)
6443       {
6444          if(featureSets->featureSetsDownlinkPerCC->list.array)
6445          {
6446             for(arrIdx = 0; arrIdx < featureSets->featureSetsDownlinkPerCC->list.count; arrIdx++)
6447             {
6448                if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx])
6449                {
6450                   if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL)
6451                      free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL);
6452                   free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]);
6453                }
6454             }
6455             free(featureSets->featureSetsDownlinkPerCC->list.array);
6456          }
6457          free(featureSets->featureSetsDownlinkPerCC);
6458       }
6459       if(featureSets->featureSetsUplinkPerCC)
6460       {
6461          if(featureSets->featureSetsUplinkPerCC->list.array)
6462          {
6463             for(arrIdx = 0; arrIdx < featureSets->featureSetsUplinkPerCC->list.count; arrIdx++)
6464             {
6465                if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx])
6466                {
6467                   if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL)
6468                      free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL);
6469                   free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]);
6470                }
6471             }
6472             free(featureSets->featureSetsUplinkPerCC->list.array);
6473          }
6474          free(featureSets->featureSetsUplinkPerCC);
6475       }
6476       free(ueNrCap->featureSets);
6477    }
6478 }
6479
6480 /*******************************************************************
6481 *
6482 * @brief Function to free PdcchSearchSpcToAddModList
6483          where memory allocated by aper_decoder
6484 *
6485 * @details
6486 *
6487 *    Function : freeAperDecodePdcchSearchSpcToAddModList
6488 *
6489 *    Functionality: Function to free PdcchSearchSpcToAddModList
6490 *
6491 * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
6492 * @return void
6493 *
6494 * ****************************************************************/
6495
6496 void freeAperDecodePdcchSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
6497 {
6498    uint8_t searchSpcArrIdx=0;
6499    uint8_t searchSpcArrIdx1=0;
6500    struct  SearchSpace *searchSpc=NULLP;
6501
6502
6503    if(searchSpcList->list.array)
6504    {
6505       if(searchSpcList->list.array[searchSpcArrIdx1])
6506       {
6507          searchSpc = searchSpcList->list.array[searchSpcArrIdx1];
6508          if(searchSpc->controlResourceSetId)
6509          {
6510             if(searchSpc->monitoringSlotPeriodicityAndOffset)
6511             {
6512                if(searchSpc->monitoringSymbolsWithinSlot)
6513                {
6514                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
6515                   {
6516                      if(searchSpc->nrofCandidates)
6517                      {
6518                         if(searchSpc->searchSpaceType)
6519                         {
6520                            free(searchSpc->searchSpaceType->choice.ue_Specific);
6521                            free(searchSpc->searchSpaceType);
6522                         }
6523                         free(searchSpc->nrofCandidates);
6524                      }
6525                      free(searchSpc->monitoringSymbolsWithinSlot->buf);
6526                   }
6527                   free(searchSpc->monitoringSymbolsWithinSlot);
6528                }
6529                free(searchSpc->monitoringSlotPeriodicityAndOffset);
6530             }
6531             free(searchSpc->controlResourceSetId);
6532          }
6533       }
6534       for(searchSpcArrIdx = 0; searchSpcArrIdx < searchSpcList->list.count; searchSpcArrIdx++)
6535       {
6536          free(searchSpcList->list.array[searchSpcArrIdx]);
6537       }
6538       free(searchSpcList->list.array);
6539    }
6540 }
6541 /*******************************************************************
6542 *
6543 * @brief Function for free part for the memory allocated by aper_decoder
6544 *
6545 * @details
6546 *
6547 *    Function : freeAperDecodeBWPDlDedPdcchConfig
6548 *
6549 *    Functionality: Function to free BWPDlDedPdcchConfig
6550 *
6551 * @params[in]
6552 * @return void
6553 *
6554 * ****************************************************************/
6555
6556
6557 void freeAperDecodeBWPDlDedPdcchConfig(BWP_DownlinkDedicated_t *dlBwp)
6558 {
6559    uint8_t arrIdx1=0;
6560    uint8_t arrIdx2=0;
6561    struct PDCCH_Config *pdcchCfg=NULLP;
6562    struct ControlResourceSet *controlRSet=NULLP;
6563    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
6564
6565    if(dlBwp->pdcch_Config->choice.setup)
6566    {
6567       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
6568       if(pdcchCfg->controlResourceSetToAddModList)
6569       {
6570          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
6571          if(controlRSetList->list.array)
6572          {
6573             controlRSet = controlRSetList->list.array[arrIdx2];
6574             if(controlRSet)
6575             {
6576                if(controlRSet->frequencyDomainResources.buf)
6577                {
6578                   if(controlRSet->pdcch_DMRS_ScramblingID)
6579                   {
6580                      if(pdcchCfg->searchSpacesToAddModList)
6581                      {
6582                         freeAperDecodePdcchSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
6583                         free(pdcchCfg->searchSpacesToAddModList);
6584                      }
6585                      free(controlRSet->pdcch_DMRS_ScramblingID);
6586                   }
6587                   free(controlRSet->frequencyDomainResources.buf);
6588                }
6589             }
6590             for(arrIdx1 = 0; arrIdx1 <controlRSetList->list.count; arrIdx1++)
6591             {
6592                free(controlRSetList->list.array[arrIdx1]);
6593             }
6594             free(controlRSetList->list.array);
6595          }
6596          free(pdcchCfg->controlResourceSetToAddModList);
6597       }
6598       free(dlBwp->pdcch_Config->choice.setup);
6599    }
6600 }
6601 /*******************************************************************
6602 *
6603 * @brief Function to free PdschTimeDomAllocationList
6604 *     where the memory allocated by aper_decoder
6605 *
6606 * @details
6607 *
6608 *    Function : freeAperDecodePdschTimeDomAllocationList
6609 *
6610 *    Functionality: Function to free PdschTimeDomAllocationList
6611 *
6612 * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
6613 * @return void
6614 *
6615 * ****************************************************************/
6616
6617
6618 void freeAperDecodePdschTimeDomAllocationList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
6619 {
6620    uint8_t arrIdx=0;
6621
6622    if(timeDomAllocList->choice.setup)
6623    {
6624       if(timeDomAllocList->choice.setup->list.array)
6625       {
6626          for(arrIdx = 0; arrIdx <timeDomAllocList->choice.setup->list.count ; arrIdx++)
6627          {
6628             free(timeDomAllocList->choice.setup->list.array[arrIdx]);
6629          }
6630          free(timeDomAllocList->choice.setup->list.array);
6631       }
6632       free(timeDomAllocList->choice.setup);
6633    }
6634 }
6635
6636 /*******************************************************************
6637 *
6638 * @brief Function to free BWPDlDedPdschConfig
6639 *        where the memory allocated by aper_decoder
6640 *
6641 * @details
6642 *
6643 *    Function : freeAperDecodeBWPDlDedPdschConfig
6644 *
6645 *    Functionality: Function to free BWPDlDedPdschConfig
6646 *
6647 * @params[in] BWP_DownlinkDedicated_t *dlBwp
6648 * @return void
6649 *
6650 * ****************************************************************/
6651
6652
6653 void freeAperDecodeBWPDlDedPdschConfig(BWP_DownlinkDedicated_t *dlBwp)
6654 {
6655    struct PDSCH_Config *pdschCfg=NULLP;
6656    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
6657    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
6658    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
6659
6660    if(dlBwp->pdsch_Config->choice.setup)
6661    {
6662       pdschCfg=dlBwp->pdsch_Config->choice.setup;
6663       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
6664       {
6665          if(pdschCfg->pdsch_TimeDomainAllocationList)
6666          {
6667             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
6668             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
6669             {
6670                prbBndlType=&pdschCfg->prb_BundlingType;
6671                free(prbBndlType->choice.staticBundling);
6672                free(pdschCfg->maxNrofCodeWordsScheduledByDCI);
6673             }
6674             freeAperDecodePdschTimeDomAllocationList(timeDomAllocList);
6675             free(pdschCfg->pdsch_TimeDomainAllocationList);
6676          }
6677          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
6678          if(dmrsDlCfg->choice.setup)
6679          {
6680             free(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition);
6681             free(dmrsDlCfg->choice.setup);
6682          }
6683          free(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA);
6684       }
6685       free(dlBwp->pdsch_Config->choice.setup);
6686    }
6687 }
6688 /*******************************************************************
6689 *
6690 * @brief Function to free PuschTimeDomAllocListCfg
6691                  where the memory allocated by aper_decoder
6692 *
6693 * @details
6694 *
6695 *    Function : freeAperDecodePuschTimeDomAllocListCfg
6696 *
6697 *    Functionality: Function to free PuschTimeDomAllocListCfg
6698 *
6699 * @params[in] PUSCH_Config_t *puschCfg
6700 * @return void
6701 *
6702 * ****************************************************************/
6703
6704
6705 void freeAperDecodePuschTimeDomAllocListCfg(PUSCH_Config_t *puschCfg)
6706 {
6707    uint8_t arrIdx=0;
6708    uint8_t arrIdx1=0;
6709    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
6710
6711    if(puschCfg->pusch_TimeDomainAllocationList)
6712    {
6713       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
6714       if(timeDomAllocList_t->choice.setup)
6715       {
6716          if(timeDomAllocList_t->choice.setup->list.array)
6717          {
6718             free(timeDomAllocList_t->choice.setup->list.array[arrIdx1]->k2);
6719             for(arrIdx = 0; arrIdx<timeDomAllocList_t->choice.setup->list.count; arrIdx++)
6720             {
6721                free(timeDomAllocList_t->choice.setup->list.array[arrIdx]);
6722             }
6723             free(timeDomAllocList_t->choice.setup->list.array);
6724          }
6725          free(timeDomAllocList_t->choice.setup);
6726       }
6727       free(puschCfg->transformPrecoder);
6728       free(puschCfg->pusch_TimeDomainAllocationList);
6729    }
6730 }
6731 /*******************************************************************
6732 *
6733 * @brief Function to free InitialUlBWPConfig where memory allocated by aper_decoder
6734 *
6735 * @details
6736 *
6737 *    Function : freeAperDecodeInitialUlBWPConfig
6738 *
6739 *    Functionality: Function to free InitialUlBWPConfig
6740 *
6741 * @params[in]  BWP_UplinkDedicated_t *ulBwp
6742 * @return void
6743 *
6744 * ****************************************************************/
6745
6746
6747 void freeAperDecodeInitialUlBWPConfig(BWP_UplinkDedicated_t *ulBwp)
6748 {
6749    uint8_t  rSetIdx =0;
6750    uint8_t  rsrcIdx =0;
6751    SRS_Config_t   *srsCfg = NULLP;
6752    PUSCH_Config_t *puschCfg = NULLP;
6753    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
6754    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
6755    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
6756    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
6757
6758    if(ulBwp->pusch_Config)
6759    {
6760       if(ulBwp->pusch_Config->choice.setup)
6761       {
6762          puschCfg=ulBwp->pusch_Config->choice.setup;
6763          if(puschCfg->dataScramblingIdentityPUSCH)
6764          {
6765             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
6766             {
6767                freeAperDecodePuschTimeDomAllocListCfg(puschCfg);
6768                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
6769                if(dmrsUlCfg->choice.setup)
6770                {
6771                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
6772                   {
6773                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
6774                      {
6775                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0);
6776                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled);
6777                      }
6778                      free(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition);
6779                   }
6780                   free(dmrsUlCfg->choice.setup);
6781                }
6782                free(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA);
6783             }
6784             free(puschCfg->dataScramblingIdentityPUSCH);
6785          }
6786          free(ulBwp->pusch_Config->choice.setup);
6787       }
6788       free(ulBwp->pusch_Config);
6789
6790       /* Free SRS-Config */
6791       if(ulBwp->srs_Config)
6792       {
6793          if(ulBwp->srs_Config->choice.setup)
6794          {
6795             srsCfg = ulBwp->srs_Config->choice.setup;
6796
6797             /* Free Resource Set to add/mod list */
6798             if(srsCfg->srs_ResourceSetToAddModList)
6799             {
6800                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
6801                if(rsrcSetList->list.array)
6802                {
6803                   rSetIdx = 0;
6804
6805                   /* Free SRS resource Id list in this SRS resource set */
6806                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
6807                   {
6808                      rsrcIdList =
6809                         rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
6810
6811                      if(rsrcIdList->list.array)
6812                      {
6813                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count;
6814                               rsrcIdx++)
6815                         {
6816                            free(rsrcIdList->list.array[rsrcIdx]);
6817                         }
6818                         free(rsrcIdList->list.array);
6819                      }
6820                      free(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList);
6821                   }
6822
6823                   /* Free resource type info for this SRS resource set */
6824
6825                   free(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic);
6826
6827                   /* Free memory for each resource set */
6828                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
6829                   {
6830                      free(rsrcSetList->list.array[rSetIdx]);
6831                   }
6832                   free(rsrcSetList->list.array);
6833                }
6834                free(srsCfg->srs_ResourceSetToAddModList);
6835             }
6836
6837             /* Free resource to add/modd list */
6838             if(srsCfg->srs_ResourceToAddModList)
6839             {
6840                resourceList = srsCfg->srs_ResourceToAddModList;
6841                if(resourceList->list.array)
6842                {
6843                   rsrcIdx = 0;
6844
6845                   free(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2);
6846                   free(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic);
6847
6848                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
6849                   {
6850                      free(resourceList->list.array[rsrcIdx]);
6851                   }
6852                   free(resourceList->list.array);
6853                }
6854                free(srsCfg->srs_ResourceToAddModList);
6855             }
6856
6857             free(ulBwp->srs_Config->choice.setup);
6858          }
6859          free(ulBwp->srs_Config);
6860       }
6861    }
6862 }
6863 /*******************************************************************
6864 *
6865 * @brief Function to free initialUplinkBWPConfig where memory allocated by aper_decoder
6866 *
6867 * @details
6868 *
6869 *    Function : freeAperDecodeinitialUplinkBWPConfig
6870 *
6871 *    Functionality: Function to free initialUplinkBWPConfig
6872 *
6873 * @params[in] UplinkConfig_t *ulCfg
6874 * @return void
6875 *
6876 * ****************************************************************/
6877
6878
6879 void freeAperDecodeinitialUplinkBWPConfig(UplinkConfig_t *ulCfg)
6880 {
6881    BWP_UplinkDedicated_t *ulBwp=NULLP;
6882    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
6883
6884    if(ulCfg->initialUplinkBWP)
6885    {
6886       ulBwp=ulCfg->initialUplinkBWP;
6887       if(ulCfg->firstActiveUplinkBWP_Id)
6888       {
6889          if(ulCfg->pusch_ServingCellConfig)
6890          {
6891             puschCfg=ulCfg->pusch_ServingCellConfig;
6892             if(puschCfg->choice.setup)
6893             {
6894                if(puschCfg->choice.setup->ext1)
6895                {
6896                   free(puschCfg->choice.setup->ext1->processingType2Enabled);
6897                   free(puschCfg->choice.setup->ext1->maxMIMO_Layers);
6898                   free(puschCfg->choice.setup->ext1);
6899                }
6900                free(puschCfg->choice.setup);
6901             }
6902             free(ulCfg->pusch_ServingCellConfig);
6903          }
6904          free(ulCfg->firstActiveUplinkBWP_Id);
6905       }
6906       freeAperDecodeInitialUlBWPConfig(ulBwp);
6907       free(ulCfg->initialUplinkBWP);
6908    }
6909 }
6910
6911 /*******************************************************************
6912  *
6913  * @brief Function to free DuUeCfg
6914  *
6915  * @details
6916  *
6917  *    Function : freeDuUeCfg
6918  *
6919  *    Functionality: Function to free DuUeCfg
6920  *
6921  * @params[in] DuUeCfg *ueCfg
6922  * @return void
6923  *
6924  * ****************************************************************/
6925 void freeDuUeCfg(DuUeCfg *ueCfg)
6926 {
6927    uint8_t lcIdx = 0;
6928    uint8_t arrIdx = 0;
6929    SpCellConfig_t *spCellCfg = NULLP;
6930    ServingCellConfig_t *srvCellCfg = NULLP;
6931    BWP_DownlinkDedicated_t *dlBwp = NULLP;
6932    MAC_CellGroupConfig_t *macCellGrpCfg = NULLP;
6933    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
6934    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList = NULLP;
6935    struct RLC_Config *rlcConfig = NULLP;
6936    struct LogicalChannelConfig *macLcConfig = NULLP;
6937    struct SchedulingRequestConfig *schedulingRequestConfig = NULLP;
6938    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList = NULLP;
6939    struct TAG_Config *tagConfig = NULLP;
6940    struct TAG_Config__tag_ToAddModList *tagList = NULLP;
6941    struct MAC_CellGroupConfig__phr_Config *phrConfig = NULLP;
6942    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg = NULLP;
6943    CellGroupConfigRrc_t *cellGrpCfg = ueCfg->cellGrpCfg;
6944
6945    if(ueCfg->ueNrCapability)
6946    {
6947       freeAperDecodeUeNrCapability(ueCfg->ueNrCapability);
6948       DU_FREE(ueCfg->ueNrCapability, sizeof(UE_NR_Capability_t));
6949       ueCfg->ueNrCapability = NULLP;
6950    }
6951
6952    if(ueCfg->cellGrpCfg)
6953    {
6954
6955       rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6956       if(rlcBearerList)
6957       {
6958          if(rlcBearerList->list.array)
6959          {
6960             for(arrIdx=0; arrIdx<rlcBearerList->list.count; arrIdx++)
6961             {
6962                if(rlcBearerList->list.array[arrIdx])
6963                {
6964                   rlcConfig   = rlcBearerList->list.array[arrIdx]->rlc_Config;
6965                   macLcConfig = rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig;
6966
6967                   if(rlcBearerList->list.array[arrIdx]->servedRadioBearer)
6968                   {
6969                      free(rlcBearerList->list.array[arrIdx]->servedRadioBearer);
6970                   }
6971                   if(rlcConfig)
6972                   {
6973                      if(rlcConfig->choice.am)
6974                      {
6975                         free(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength);
6976                         free(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength);
6977                         free(rlcConfig->choice.am);
6978                      }
6979                      free(rlcBearerList->list.array[arrIdx]->rlc_Config);
6980                   }
6981                   if(macLcConfig)
6982                   {
6983                      if(macLcConfig->ul_SpecificParameters)
6984                      {
6985                         free(macLcConfig->ul_SpecificParameters->schedulingRequestID);
6986                         free(macLcConfig->ul_SpecificParameters->logicalChannelGroup);
6987                         free(macLcConfig->ul_SpecificParameters);
6988                      }
6989                      free(rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig);
6990                   }
6991                   free(rlcBearerList->list.array[arrIdx]);
6992                }
6993             }
6994             free(rlcBearerList->list.array);
6995          }
6996          free(cellGrpCfg->rlc_BearerToAddModList);
6997       }
6998
6999       macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
7000       if(macCellGrpCfg)
7001       {
7002          schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
7003          if(schedulingRequestConfig)
7004          {
7005             schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
7006             if(schReqList)
7007             {
7008                if(schReqList->list.array)
7009                {
7010                   for(arrIdx=0;arrIdx<schReqList->list.count; arrIdx++)
7011                   {
7012                      if(schReqList->list.array[arrIdx])
7013                      {
7014                         free(schReqList->list.array[arrIdx]->sr_ProhibitTimer);
7015                         free(schReqList->list.array[arrIdx]);
7016                      }
7017                   }
7018                   free(schReqList->list.array);
7019                }
7020                free(schedulingRequestConfig->schedulingRequestToAddModList);
7021             }
7022             free(macCellGrpCfg->schedulingRequestConfig);
7023          }
7024          if(macCellGrpCfg->bsr_Config)
7025          {
7026             free(macCellGrpCfg->bsr_Config);
7027          }
7028          tagConfig = macCellGrpCfg->tag_Config;
7029          if(tagConfig)
7030          {
7031             tagList = tagConfig->tag_ToAddModList;
7032             if(tagList)
7033             {
7034                if(tagList->list.array)
7035                {
7036                   for(arrIdx=0; arrIdx<tagList->list.count; arrIdx++)
7037                   {
7038                      free(tagList->list.array[arrIdx]);
7039                   }
7040                   free(tagList->list.array);
7041                }
7042                free(tagConfig->tag_ToAddModList);
7043             }
7044             free(tagConfig);
7045          }
7046
7047          phrConfig = macCellGrpCfg->phr_Config;
7048          if(phrConfig)
7049          {
7050             free(phrConfig->choice.setup);
7051             free(phrConfig);
7052          }
7053
7054          free(macCellGrpCfg);
7055       }
7056
7057       phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
7058       if(phyCellGrpCfg)
7059       {
7060          free(phyCellGrpCfg->p_NR_FR1);
7061          free(phyCellGrpCfg);
7062       }
7063
7064       spCellCfg = cellGrpCfg->spCellConfig;
7065       if(spCellCfg)
7066       {
7067          if(spCellCfg->servCellIndex)
7068          {
7069             if(spCellCfg->rlmInSyncOutOfSyncThreshold)
7070             {
7071                if(spCellCfg->spCellConfigDedicated)
7072                {
7073                   srvCellCfg = spCellCfg->spCellConfigDedicated;
7074                   if(srvCellCfg->initialDownlinkBWP)
7075                   {
7076                      dlBwp = srvCellCfg->initialDownlinkBWP;
7077                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
7078                      {
7079                         if(srvCellCfg->defaultDownlinkBWP_Id)
7080                         {
7081                            if(srvCellCfg->uplinkConfig)
7082                            {
7083
7084                               if(srvCellCfg->pdsch_ServingCellConfig)
7085                               {
7086                                  pdschCfg=
7087                                     srvCellCfg->pdsch_ServingCellConfig;
7088                                  if(pdschCfg->choice.setup)
7089                                  {
7090
7091                                     free(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH);
7092                                     free(pdschCfg->choice.setup);
7093                                  }
7094
7095                                  free(srvCellCfg->pdsch_ServingCellConfig);
7096                               }
7097
7098                               freeAperDecodeinitialUplinkBWPConfig(srvCellCfg->uplinkConfig);
7099                               free(srvCellCfg->uplinkConfig);
7100                            }
7101                            free(srvCellCfg->defaultDownlinkBWP_Id);
7102                         }
7103
7104                         free(srvCellCfg->firstActiveDownlinkBWP_Id);
7105                      }
7106                      if(dlBwp->pdcch_Config)
7107                      {
7108                         if(dlBwp->pdsch_Config)
7109                         {
7110                            freeAperDecodeBWPDlDedPdschConfig(dlBwp);
7111                            free(dlBwp->pdsch_Config);
7112                         }
7113                         freeAperDecodeBWPDlDedPdcchConfig(dlBwp);
7114                         free(dlBwp->pdcch_Config);
7115                      }
7116                      free(srvCellCfg->initialDownlinkBWP);
7117                   }
7118
7119                   free(spCellCfg->spCellConfigDedicated);
7120                }
7121                free(spCellCfg->rlmInSyncOutOfSyncThreshold);
7122             }
7123             free(spCellCfg->servCellIndex);
7124          }
7125          free(spCellCfg);
7126       }
7127       DU_FREE(ueCfg->cellGrpCfg, sizeof(CellGroupConfigRrc_t));
7128       ueCfg->cellGrpCfg = NULLP;
7129    }
7130    if(ueCfg->ambrCfg)
7131    {
7132       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->ambrCfg, sizeof(AmbrCfg));
7133    }
7134    for(lcIdx = 0; lcIdx < ueCfg->numRlcLcs; lcIdx++)
7135    {
7136       freeRlcLcCfg(&ueCfg->rlcLcCfg[lcIdx]);
7137    }
7138    for(lcIdx = 0; lcIdx < ueCfg->numMacLcs; lcIdx++)
7139    {
7140       freeMacLcCfg(&ueCfg->macLcCfg[lcIdx]);
7141    }
7142    for(lcIdx = 0; lcIdx < ueCfg->numDrb; lcIdx++)
7143    {
7144       DU_FREE(ueCfg->upTnlInfo[lcIdx].tnlCfg1, sizeof(GtpTnlCfg));
7145    }
7146 }
7147
7148 /*******************************************************************
7149  *
7150  * @brief Function to free UecontextSetupDb
7151  *
7152  * @details
7153  *
7154  *    Function : freeF1UeDb
7155  *
7156  *    Functionality: Function to free UecontextSetupDb
7157  *
7158  * @params[in] UecontextSetupDb *
7159  * @return void
7160  *
7161  * ****************************************************************/
7162
7163 void freeF1UeDb(F1UeContextSetupDb *f1UeDb)
7164 {
7165
7166    if(f1UeDb->dlRrcMsg)
7167    {
7168       if(f1UeDb->dlRrcMsg->rrcMsgPdu)
7169       {
7170         //DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,\
7171                f1UeDb->dlRrcMsg->rrcMsgPdu, f1UeDb->dlRrcMsg->rrcMsgSize);
7172       }
7173       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
7174    }
7175    freeDuUeCfg(&f1UeDb->duUeCfg);
7176    memset(f1UeDb, 0, sizeof(F1UeContextSetupDb));
7177    DU_FREE(f1UeDb, sizeof(F1UeContextSetupDb));
7178 }
7179
7180 /*******************************************************************
7181  *
7182  * @brief Function to build Am cfg Info
7183  *
7184  * @details
7185  *
7186  *    Function : extractRlcAmCfg
7187  *
7188  *    Functionality: Function to build Am cfg Info
7189  *
7190  * @params[in] AmBearerCfg *
7191  *             void *
7192  *
7193  * @return ROK/RFAILED
7194  *
7195  * ****************************************************************/
7196
7197 void extractRlcAmCfg(AmBearerCfg *amCfgToSet, struct RLC_Config__am *rlcAmCfg)
7198 {
7199    if(rlcAmCfg)
7200    {
7201       /* UL AM */
7202       if(rlcAmCfg->dl_AM_RLC.sn_FieldLength)
7203       {
7204          amCfgToSet->ulAmCfg.snLenUl = *(rlcAmCfg->dl_AM_RLC.sn_FieldLength);
7205          /*TODO: Check the timer value when sent by real CU */
7206          amCfgToSet->ulAmCfg.reAssemTmr = rlcAmCfg->dl_AM_RLC.t_Reassembly;
7207          amCfgToSet->ulAmCfg.statProhTmr = rlcAmCfg->dl_AM_RLC.t_StatusProhibit;
7208       }
7209
7210       /* DL AM */
7211       if(rlcAmCfg->ul_AM_RLC.sn_FieldLength)
7212       {
7213          amCfgToSet->dlAmCfg.snLenDl = *(rlcAmCfg->ul_AM_RLC.sn_FieldLength);
7214          amCfgToSet->dlAmCfg.pollRetxTmr = rlcAmCfg->ul_AM_RLC.t_PollRetransmit;
7215          amCfgToSet->dlAmCfg.pollPdu   = rlcAmCfg->ul_AM_RLC.pollPDU;
7216          amCfgToSet->dlAmCfg.pollByte  = rlcAmCfg->ul_AM_RLC.pollByte;
7217          amCfgToSet->dlAmCfg.maxRetxTh = rlcAmCfg->ul_AM_RLC.maxRetxThreshold;
7218       }
7219    }
7220 }
7221
7222 /*******************************************************************
7223  *
7224  * @brief Function to build Um Bi Info
7225  *
7226  * @details
7227  *
7228  *    Function : extractRlcUmBiCfg
7229  *
7230  *    Functionality: Function to build Um Bi Info
7231  *
7232  * @params[in] UmBiDirBearerCfg *
7233  *             void *
7234  *
7235  * @return ROK/RFAILED
7236  *
7237  * ****************************************************************/
7238
7239 void extractRlcUmBiCfg(UmBiDirBearerCfg *umBiCfgToSet, struct RLC_Config__um_Bi_Directional *rlcBiCfg)
7240 {
7241    if(rlcBiCfg)
7242    {
7243       /* UL UM BI DIR Cfg */
7244       if(rlcBiCfg->dl_UM_RLC.sn_FieldLength)
7245       {
7246          umBiCfgToSet->ulUmCfg.snLenUlUm  = *(rlcBiCfg->dl_UM_RLC.sn_FieldLength);
7247          umBiCfgToSet->ulUmCfg.reAssemTmr = rlcBiCfg->dl_UM_RLC.t_Reassembly;
7248       }
7249
7250       /* DL UM BI DIR Cfg */
7251       if(rlcBiCfg->ul_UM_RLC.sn_FieldLength)
7252          umBiCfgToSet->dlUmCfg.snLenDlUm  = *(rlcBiCfg->ul_UM_RLC.sn_FieldLength);
7253    }
7254 }
7255
7256 /*******************************************************************
7257  *
7258  * @brief Function to build Um Ul Info
7259  *
7260  * @details
7261  *
7262  *    Function : extractRlcUmUlCfg
7263  *
7264  *    Functionality: Function to build Um Ul Info
7265  *
7266  * @params[in] UmUniDirUlBearerCfg *
7267  *             void *
7268  *
7269  * @return ROK/RFAILED
7270  *
7271  * ****************************************************************/
7272
7273 void extractRlcUmUlCfg(UmUniDirUlBearerCfg *umUlCfgToSet, struct RLC_Config__um_Uni_Directional_DL *umUlCfg)
7274 {
7275    if(umUlCfg)
7276    {
7277       if(umUlCfg->dl_UM_RLC.sn_FieldLength)
7278       {
7279          umUlCfgToSet->ulUmCfg.snLenUlUm  = *(umUlCfg->dl_UM_RLC.sn_FieldLength);
7280          umUlCfgToSet->ulUmCfg.reAssemTmr = umUlCfg->dl_UM_RLC.t_Reassembly;
7281       }
7282    }
7283 }
7284
7285 /*******************************************************************
7286  *
7287  * @brief Function to build Um Uni Dl Info
7288  *
7289  * @details
7290  *
7291  *    Function : extractRlcUmDlCfg
7292  *
7293  *    Functionality: Function to build Um Uni Dl Info
7294  *
7295  * @params[in] UmUniDirDlBearerCfg *
7296  *             void *
7297  *
7298  * @return ROK/RFAILED
7299  *
7300  * ****************************************************************/
7301 void extractRlcUmDlCfg(UmUniDirDlBearerCfg *umDlCfgToSet, struct RLC_Config__um_Uni_Directional_UL *umDlCfg)
7302 {
7303    if(umDlCfg)
7304    {
7305       if(umDlCfg->ul_UM_RLC.sn_FieldLength)
7306          umDlCfgToSet->dlUmCfg.snLenDlUm  = *(umDlCfg->ul_UM_RLC.sn_FieldLength);
7307    }
7308 }
7309
7310 /*******************************************************************
7311  *
7312  * @brief Function to extractRlcModeCfg
7313  *
7314  * @details
7315  *
7316  *    Function : extractRlcModeCfg
7317  *
7318  *    Functionality: Function to extractRlcModeCfg
7319  *
7320  * @params[in] RLC_Config_t *
7321  *             RlcBearerCfg *
7322  *             void  *
7323  * @return ROK/RFAILED
7324  *
7325  * ****************************************************************/
7326 void extractRlcModeCfg(uint8_t rlcMode, RlcBearerCfg *rlcDbCfg, RLC_Config_t *lcCfg)
7327 {
7328    if(lcCfg)
7329    {
7330       switch(rlcMode)
7331       {
7332          case RLC_AM :
7333             {
7334                if(lcCfg->choice.am)
7335                {
7336                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.amCfg, sizeof(AmBearerCfg));
7337                   if(rlcDbCfg->u.amCfg)
7338                      extractRlcAmCfg(rlcDbCfg->u.amCfg, lcCfg->choice.am);
7339                }
7340                break;
7341             }
7342          case RLC_UM_BI_DIRECTIONAL :
7343             {
7344                if(lcCfg->choice.um_Bi_Directional)
7345                {
7346                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
7347                   if(rlcDbCfg->u.umBiDirCfg)
7348                      extractRlcUmBiCfg(rlcDbCfg->u.umBiDirCfg, lcCfg->choice.um_Bi_Directional);
7349                }
7350                break;
7351             }
7352          case RLC_UM_UNI_DIRECTIONAL_UL :
7353             {
7354                if(lcCfg->choice.um_Uni_Directional_DL)
7355                {
7356                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
7357                   if(rlcDbCfg->u.umUniDirUlCfg)
7358                      extractRlcUmUlCfg(rlcDbCfg->u.umUniDirUlCfg, lcCfg->choice.um_Uni_Directional_DL);
7359                }
7360                break;
7361             }
7362          case RLC_UM_UNI_DIRECTIONAL_DL :
7363             {
7364                if(lcCfg->choice.um_Uni_Directional_UL)
7365                {
7366                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
7367                   if(rlcDbCfg->u.umUniDirDlCfg)
7368                      extractRlcUmDlCfg(rlcDbCfg->u.umUniDirDlCfg, lcCfg->choice.um_Uni_Directional_UL);
7369                }
7370                break;
7371             }
7372          default:
7373             DU_LOG("\nERROR  -->  DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
7374             break;
7375       }
7376    }
7377 }
7378
7379 /*******************************************************************
7380  *
7381  * @brief Function to extract extractUlLcCfg
7382  *
7383  * @details
7384  *
7385  *    Function : extractUlLcCfg
7386  *
7387  *    Functionality: Function to extract extractUlLcCfg
7388  *
7389  * @params[in] UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg
7390  * @return void
7391  *
7392  * ****************************************************************/
7393
7394 void extractUlLcCfg(UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg)
7395 {
7396    if(ulLcCfg)
7397    {
7398       if(ulLcCfg->ul_SpecificParameters)
7399       {
7400          f1UlLcCfg->priority = \
7401             ulLcCfg->ul_SpecificParameters->priority;
7402       if(ulLcCfg->ul_SpecificParameters->logicalChannelGroup)
7403       {
7404          f1UlLcCfg->lcGroup = \
7405            *(ulLcCfg->ul_SpecificParameters->logicalChannelGroup);
7406       }
7407       if(ulLcCfg->ul_SpecificParameters->schedulingRequestID)
7408       {
7409          f1UlLcCfg->schReqId = \
7410            *(ulLcCfg->ul_SpecificParameters->schedulingRequestID);
7411       }
7412       f1UlLcCfg->pbr = \
7413          ulLcCfg->ul_SpecificParameters->prioritisedBitRate;
7414       f1UlLcCfg->bsd = \
7415          ulLcCfg->ul_SpecificParameters->bucketSizeDuration;
7416       }
7417    }
7418 }
7419
7420 /*******************************************************************
7421 *
7422 * @brief Function to extract Snssai Cfg Info from CU
7423 *
7424 * @details
7425 *
7426 *    Function : extractDrbSnssaiCfg
7427 *
7428 *    Functionality: Function to extract Drb Snssai Cfg Info from CU
7429 *
7430 * @params[in] DRB_Information_t *drbInfo, Snssai  *snssai
7431 * @return ROK/RFAILED
7432 *
7433 * ****************************************************************/
7434
7435 uint8_t extractDrbSnssaiCfg(SNSSAI_t *RecvSnssai, Snssai **snssaiToBeShared)
7436 {
7437    if(!(*snssaiToBeShared))
7438    {
7439       DU_ALLOC_SHRABL_BUF((*snssaiToBeShared), sizeof(Snssai));
7440       if(snssaiToBeShared == NULLP)
7441       {
7442          DU_LOG("\nERROR  -->  DUAPP : extractDrbSnssaiCfg(): Memory failed at allocating for SNSSAI ");
7443          return RFAILED;
7444       }
7445    }
7446    if(RecvSnssai)
7447    {
7448       memcpy(&(*snssaiToBeShared)->sst, RecvSnssai->sST.buf, RecvSnssai->sST.size);
7449       if(RecvSnssai->sD)
7450       {
7451          memcpy((*snssaiToBeShared)->sd, RecvSnssai->sD->buf,  RecvSnssai->sD->size);
7452       }
7453       else
7454       {
7455          DU_LOG("\nERROR  -->  DUAPP : extractDrbSnssaiCfg(): Received Null pointer of Snssai->SD");
7456          return RFAILED;
7457       }
7458    }
7459    return ROK;
7460 }
7461
7462 /*******************************************************************
7463  *
7464  * @brief Function to procRlcLcCfg
7465  *
7466  * @details
7467  *
7468  *    Function : procRlcLcCfg
7469  *
7470  *    Functionality: Function to procRlcLcCfg
7471  *
7472  * @params[in] rbId, lcId, rbType, rlcMod
7473  *             RLC_Config_t *, RlcBearerCfg * ,
7474  * @return void
7475  *
7476  * ****************************************************************/
7477
7478 void procRlcLcCfg(uint8_t rbId, uint8_t lcId, uint8_t rbType, uint8_t rlcMode,\
7479    uint8_t configType, RLC_Config_t *f1RlcCfg, RlcBearerCfg *lcCfg, QoSInformation_t *qoSInformation)
7480 {
7481    DRB_Information_t *drbInfo;
7482
7483    lcCfg->rbId   = rbId;
7484    lcCfg->configType = configType;
7485
7486    if(rbType == RB_TYPE_SRB)
7487    {
7488       lcCfg->rbType = RB_TYPE_SRB;
7489       lcCfg->lcId   = rbId;
7490       lcCfg->lcType = LCH_DCCH;
7491       lcCfg->rlcMode = RLC_AM;
7492    }
7493    else if(rbType == RB_TYPE_DRB)
7494    {
7495       lcCfg->rbType = RB_TYPE_DRB;
7496       lcCfg->lcId   = lcId;
7497       lcCfg->lcType = LCH_DTCH;
7498       lcCfg->rlcMode = rlcMode;
7499    }
7500    if(f1RlcCfg) /* rlc mode config recived */
7501    {
7502       extractRlcModeCfg(lcCfg->rlcMode, lcCfg, f1RlcCfg);
7503    }
7504    if(qoSInformation != NULLP)
7505    {
7506       if(qoSInformation->present == QoSInformation_PR_choice_extension)
7507       {
7508          if(qoSInformation->choice.choice_extension->value.present ==\
7509                QoSInformation_ExtIEs__value_PR_DRB_Information)
7510          {
7511             drbInfo = &qoSInformation->choice.choice_extension->value.choice.DRB_Information;
7512             if(extractDrbSnssaiCfg(&drbInfo->sNSSAI, &lcCfg->snssai) != ROK)
7513             {
7514                DU_LOG("\nERROR  -->  DUAPP: Unable to extract Snssai information at procRlcLcCfg()");
7515                return RFAILED;
7516             }
7517          }
7518       }
7519    }
7520 }
7521
7522 /*******************************************************************
7523  *
7524  * @brief Fills DrbQos Info received by CU
7525  *
7526  * @details
7527  *
7528  *    Function : extractQosInfo
7529  *
7530  *    Functionality: Fills DrbQos Info received  by CU
7531  *
7532  * @params[in] DrbQosInfo *qosToAdd,
7533  *             QoSFlowLevelQoSParameters_t *qosFlowCfg
7534  * @return void
7535  *
7536  * ****************************************************************/
7537
7538 void extractQosInfo(DrbQosInfo *qosToAdd, QoSFlowLevelQoSParameters_t *qosFlowCfg)
7539 {
7540    uint8_t qosCntIdx = 0;
7541    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
7542
7543    qosToAdd->fiveQiType = qosFlowCfg->qoS_Characteristics.present;
7544    qosToAdd->u.nonDyn5Qi.fiveQi     =\
7545                                      qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
7546    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow)
7547    {
7548       qosToAdd->u.nonDyn5Qi.avgWindow = \
7549                                         *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
7550    }
7551    qosToAdd->u.nonDyn5Qi.maxDataBurstVol = \
7552                                            *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
7553    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel)
7554    {
7555       qosToAdd->u.nonDyn5Qi.priorLevel = \
7556                                          *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel);
7557    }
7558    qosToAdd->ngRanRetPri.priorityLevel = \
7559                                          qosFlowCfg->nGRANallocationRetentionPriority.priorityLevel;
7560    qosToAdd->ngRanRetPri.preEmptionCap = \
7561                                          qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionCapability;
7562    qosToAdd->ngRanRetPri.preEmptionVul = \
7563                                          qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionVulnerability;
7564    if(qosFlowCfg->gBR_QoS_Flow_Information)
7565    {
7566       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateDl, \
7567             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.buf, \
7568             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.size);
7569       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateUl, \
7570             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.buf, \
7571             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.size);
7572       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateDl,\
7573             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.buf, \
7574             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.size);
7575       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateUl,\
7576             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.buf, \
7577             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.size);
7578    }
7579    /*Extracting PDU_SESSION_ID*/
7580    qosIeExt = (ProtocolExtensionContainer_4624P74_t *)qosFlowCfg->iE_Extensions;
7581    if(qosIeExt)
7582    {
7583       for(qosCntIdx = 0; qosCntIdx < qosIeExt->list.count; qosCntIdx++)
7584       {
7585          if(qosIeExt->list.array[qosCntIdx]->extensionValue.present == \
7586                QoSFlowLevelQoSParameters_ExtIEs__extensionValue_PR_PDUSessionID)
7587          {
7588             qosToAdd->pduSessionId = qosIeExt->list.array[qosCntIdx]->extensionValue.choice.PDUSessionID;
7589             DU_LOG("\nDEBUG -->  DU_F1AP : extractQosInfo: PDU SessionID:%d",qosToAdd->pduSessionId);
7590          }
7591       }
7592    }
7593    qosToAdd->ulPduSessAggMaxBitRate = 0;
7594 }
7595
7596 /*******************************************************************
7597  *
7598  * @brief Function to extract GTP Tunnel Info from CU
7599  *
7600  * @details
7601  *
7602  *    Function : extractUpTnlInfo
7603  *
7604  *    Functionality: Function to extract GTP Tunnel Info from CU
7605  *
7606  * @params[in] F1AP message
7607  * @return ROK/RFAILED
7608  *
7609  * ****************************************************************/
7610
7611 uint8_t extractUpTnlInfo(uint8_t drbId, uint8_t configType,\
7612    ULUPTNLInformation_ToBeSetup_List_t *tnlInfo, UpTnlCfg *upTnlInfo)
7613 {
7614    uint8_t tnlIdx;
7615    uint32_t ipv4_du = 0;
7616    GTPTunnel_t *gtpTunnel = NULLP;
7617
7618    upTnlInfo->drbId = drbId;
7619    upTnlInfo->configType = configType;
7620 #ifdef O1_ENABLE
7621    cmInetAddr((S8*)g_cfg.DU_IPV4_Addr, &ipv4_du);
7622 #else
7623    cmInetAddr((char *)DU_IP_V4_ADDR, &ipv4_du);
7624 #endif
7625
7626    for(tnlIdx=0; tnlIdx < tnlInfo->list.count; tnlIdx++)
7627    {
7628       if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
7629       {
7630          if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel)
7631          {
7632             gtpTunnel = tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel;
7633             DU_ALLOC(upTnlInfo->tnlCfg1, sizeof(GtpTnlCfg));
7634             if(upTnlInfo->tnlCfg1 == NULLP)
7635             {
7636                DU_LOG("\nERROR  -->  F1AP : extractUpTnlInfo: Failed to allocate mmeory for tunnel cfg 1");
7637                return RFAILED;
7638             }
7639             bitStringToInt(&gtpTunnel->transportLayerAddress, &upTnlInfo->tnlCfg1->ulTnlAddress);
7640             upTnlInfo->tnlCfg1->dlTnlAddress = ipv4_du;
7641             if(gtpTunnel->gTP_TEID.size > 0)
7642             {
7643                teIdStringToInt(gtpTunnel->gTP_TEID.buf, &upTnlInfo->tnlCfg1->teId);
7644             }
7645          }
7646          break;
7647       }
7648    }
7649    return ROK;
7650 }
7651
7652 /*******************************************************************
7653 *
7654 * @brief Function to extract Drb Qos Cfg Info from CU
7655 *
7656 * @details
7657 *
7658 *    Function : extractDrbQosCfg
7659 *
7660 *    Functionality: Function to extract Drb Qos Cfg Info from CU
7661 *
7662 * @params[in] DRB_Information_t *drbInfo, LcCfg *macLcToAdd
7663 * @return ROK/RFAILED
7664 *
7665 * ****************************************************************/
7666
7667 uint8_t extractDrbQosCfg(DRB_Information_t *drbInfo, LcCfg *macLcToAdd )
7668 {
7669    if(!macLcToAdd->drbQos)
7670    {
7671       DU_ALLOC_SHRABL_BUF(macLcToAdd->drbQos, sizeof(DrbQosInfo));
7672       if(macLcToAdd->drbQos == NULLP)
7673       {
7674          DU_LOG("\nERROR  -->  DUAPP:Memory failed at allocating DrbQos at extractDrbQosCfg()");
7675          return RFAILED;
7676       }
7677
7678    }
7679    if(drbInfo->dRB_QoS.qoS_Characteristics.present == QoS_Characteristics_PR_non_Dynamic_5QI)
7680    {
7681       extractQosInfo(macLcToAdd->drbQos, &drbInfo->dRB_QoS);
7682       macLcToAdd->dlLcCfg.lcp = macLcToAdd->drbQos->ngRanRetPri.priorityLevel;
7683    }
7684    if(extractDrbSnssaiCfg(&drbInfo->sNSSAI, &macLcToAdd->snssai) != ROK)
7685    {
7686       DU_LOG("\nERROR  -->  DUAPP: Unable to extract Snssai information  at extractDrbQosCfg()");
7687       return RFAILED;
7688    }
7689    return ROK;
7690 }
7691 /*******************************************************************
7692  *
7693  * @brief Function to extract DRB info received from CU
7694  *
7695  * @details
7696  *
7697  *    Function : extractDrbCfg
7698  *
7699  *    Functionality: Function to extract DRB info received from CU
7700  *
7701  * @params[in] F1AP message
7702  * @return void
7703  *
7704  * ****************************************************************/
7705 uint8_t extractDrbCfg(DRBs_ToBeSetup_Item_t *drbItem, DRBs_ToBeSetupMod_Item_t *drbSetupModItem,\
7706 DRBs_ToBeModified_Item_t *drbModItem,  LcCfg *macLcToAdd, UpTnlCfg *upTnlInfo)
7707 {
7708    DRB_Information_t *drbInfo = NULLP;
7709
7710    if(drbItem != NULLP)
7711    {
7712       if(extractUpTnlInfo(drbItem->dRBID, CONFIG_ADD, &drbItem->uLUPTNLInformation_ToBeSetup_List, upTnlInfo) != ROK)
7713       {
7714          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7715          return RFAILED;
7716       }
7717       if(drbItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7718       {
7719          if(drbItem->qoSInformation.choice.choice_extension->value.present == QoSInformation_ExtIEs__value_PR_DRB_Information)
7720          {
7721             drbInfo = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7722             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7723             {
7724                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7725                return RFAILED;
7726             }
7727          }
7728       }
7729    }
7730    else if(drbSetupModItem != NULLP)
7731    {
7732       if(extractUpTnlInfo(drbSetupModItem->dRBID, CONFIG_ADD, &drbSetupModItem->uLUPTNLInformation_ToBeSetup_List,\
7733       upTnlInfo) != ROK)
7734       {
7735          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7736          return RFAILED;
7737       }
7738       if(drbSetupModItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7739       {
7740          if(drbSetupModItem->qoSInformation.choice.choice_extension->value.present ==\
7741          QoSInformation_ExtIEs__value_PR_DRB_Information)
7742          {
7743             drbInfo = &drbSetupModItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7744             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7745             {
7746                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7747                return RFAILED;
7748             }
7749
7750          }
7751       }
7752    }
7753    else if(drbModItem != NULLP)
7754    {
7755       if(extractUpTnlInfo(drbModItem->dRBID, CONFIG_MOD, &drbModItem->uLUPTNLInformation_ToBeSetup_List,\
7756       upTnlInfo) != ROK)
7757       {
7758          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7759          return RFAILED;
7760       }
7761       if(drbModItem->qoSInformation != NULLP)
7762       {
7763          if(drbModItem->qoSInformation->present == QoSInformation_PR_choice_extension)
7764          {
7765             if(drbModItem->qoSInformation->choice.choice_extension->value.present ==\
7766                   QoSInformation_ExtIEs__value_PR_DRB_Information)
7767             {
7768                drbInfo = &drbModItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information;
7769                if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7770                {
7771                   DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7772                   return RFAILED;
7773                }
7774
7775             }
7776          }
7777       }
7778    }
7779    return ROK;
7780 }
7781
7782 /*******************************************************************
7783  *
7784  * @brief Function to extract RB info received from CU
7785  *
7786  * @details
7787  *
7788  *    Function : extractMacRbCfg
7789  *
7790  *    Functionality: Function to extract RB info received from CU
7791  *
7792  * @params[in] F1AP message
7793  * @return ROK/RFAILED
7794  *
7795  * ****************************************************************/
7796
7797 uint8_t extractMacRbCfg(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbCfg,\
7798 DRBs_ToBeSetupMod_Item_t *drbSetupModCfg,  DRBs_ToBeModified_Item_t *drbModCfg, LogicalChannelConfig_t *ulLcCfg, LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7799 {
7800    if(drbCfg != NULLP)
7801    {
7802       if(extractDrbCfg(drbCfg, NULL, NULL, lcCfg, upTnlInfo) != ROK)
7803       {
7804          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7805          return RFAILED;
7806       }
7807    }
7808    else if(drbSetupModCfg != NULLP)
7809    {
7810       if(extractDrbCfg(NULL, drbSetupModCfg, NULL, lcCfg, upTnlInfo) != ROK)
7811       {
7812          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7813          return RFAILED;
7814       }
7815    }
7816    else if(drbModCfg != NULLP)
7817    {
7818       if(extractDrbCfg(NULL, NULL, drbModCfg, lcCfg, upTnlInfo) != ROK)
7819       {
7820          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7821          return RFAILED;
7822       }
7823    }
7824    else
7825    {
7826       lcCfg->drbQos = NULLP;
7827       lcCfg->snssai = NULLP;
7828       if(lcCfg->lcId == SRB2_LCID)
7829          lcCfg->dlLcCfg.lcp = LC_PRIORITY_3;
7830       else
7831          lcCfg->dlLcCfg.lcp = LC_PRIORITY_1;
7832    }
7833    if(ulLcCfg)
7834    {
7835       lcCfg->ulLcCfgPres = true;
7836       extractUlLcCfg(&lcCfg->ulLcCfg, ulLcCfg);
7837    }
7838    else
7839       lcCfg->ulLcCfgPres = false;
7840    return ROK;
7841 }
7842
7843 /*******************************************************************
7844  *
7845  * @brief Function processing LC config info received from CU
7846  *
7847  * @details
7848  *
7849  *    Function : procMacLcCfg
7850  *
7851  *    Functionality: Function processing LC config info received from CU
7852  *
7853  * @params[in] F1AP message
7854  * @return ROK/RFAILED
7855  *
7856  * ****************************************************************/
7857
7858 uint8_t procMacLcCfg(uint8_t lcId, uint8_t rbType, uint8_t configType, DRBs_ToBeSetup_Item_t *drbItem,\
7859 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, LogicalChannelConfig_t *ulLcCfg,\
7860 LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7861 {
7862    uint8_t ret = ROK;
7863
7864    lcCfg->lcId = lcId;
7865    lcCfg->configType = configType;
7866    if(rbType == RB_TYPE_SRB)
7867    {
7868       ret = extractMacRbCfg(lcId, NULL, NULL, NULL, ulLcCfg, lcCfg, NULL);
7869    }
7870    else if(rbType == RB_TYPE_DRB)
7871    {
7872       if(drbItem != NULL)
7873         ret = extractMacRbCfg(lcId, drbItem, NULL, NULL, ulLcCfg, lcCfg, upTnlInfo);
7874       else if(drbSetupModItem != NULL)
7875         ret = extractMacRbCfg(lcId, NULL, drbSetupModItem, NULL, ulLcCfg, lcCfg, upTnlInfo);
7876       else if(drbModItem != NULL)
7877         ret = extractMacRbCfg(lcId, NULL, NULL, drbModItem, ulLcCfg, lcCfg, upTnlInfo);
7878    }
7879    return ret;
7880 }
7881
7882 /*******************************************************************
7883  *
7884  * @brief Function to extract Rlc cfg To Add/Mod in CellGrp Info
7885  *
7886  * @details
7887  *
7888  *    Function : extractRlcCfgToAddMod
7889  *
7890  *    Functionality: Function to extract Rlc cfg To Add/Mod in CellGrp Info
7891  *
7892  * @params[in] CellGroupConfigRrc__rlc_BearerTo pointer
7893  *             DuUeCfg Pointer
7894  * @return ROK/RFAILED
7895  *
7896  * ****************************************************************/
7897
7898 uint8_t extractRlcCfgToAddMod(struct CellGroupConfigRrc__rlc_BearerToAddModList *lcCfg, DuUeCfg *ueCfgDb)
7899 {
7900   uint8_t idx, rbId, lcId, rlcMode, rbType;
7901   RLC_Config_t *f1RlcCfg = NULLP;
7902   LogicalChannelConfig_t *macUlLcCfg = NULLP;
7903
7904   for(idx = 0; idx < lcCfg->list.count; idx++)
7905   {
7906      lcId = lcCfg->list.array[idx]->logicalChannelIdentity;
7907      if(lcCfg->list.array[idx]->servedRadioBearer)
7908      {
7909         /* RadioBearer for SRB/DRB */
7910         if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7911         RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
7912         {
7913            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.srb_Identity;
7914            rbType = RB_TYPE_SRB;
7915         }
7916         else if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7917         RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
7918         {
7919            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.drb_Identity;
7920            rbType = RB_TYPE_DRB;
7921         }
7922         else
7923         {
7924            DU_LOG("\nERROR  -->  No components present in Bearer config to ADD/MOD");
7925            return RFAILED;
7926         }
7927         /* MAC UL LC Config */
7928         if(lcCfg->list.array[idx]->mac_LogicalChannelConfig)
7929         {
7930            macUlLcCfg = lcCfg->list.array[idx]->mac_LogicalChannelConfig;
7931         }
7932      }
7933      else
7934      {
7935         DU_LOG("\nERROR  -->  DUAPP: Received RadioBearer config is NULL");
7936         return RFAILED;
7937      }
7938      /* RLC Mode Config */
7939      if(lcCfg->list.array[idx]->rlc_Config)
7940      {
7941         rlcMode  = lcCfg->list.array[idx]->rlc_Config->present;
7942         f1RlcCfg = lcCfg->list.array[idx]->rlc_Config;
7943      }
7944
7945      /* Filling RLC/MAC Config*/
7946      memset(&ueCfgDb->macLcCfg[idx], 0, sizeof(LcCfg));
7947      memset(&ueCfgDb->rlcLcCfg[idx], 0, sizeof(RlcBearerCfg));
7948      procRlcLcCfg(rbId, lcId, rbType, rlcMode, CONFIG_UNKNOWN, f1RlcCfg, &(ueCfgDb->rlcLcCfg[idx]), NULLP);
7949      if(procMacLcCfg(lcId, rbType, CONFIG_UNKNOWN, NULL, NULL, NULL, macUlLcCfg, &ueCfgDb->macLcCfg[idx], NULL) != ROK)
7950      {
7951         DU_LOG("\nERROR  -->  DU APP : Failed while filling MAC LC config at extractRlcCfgToAddMod()");
7952         return RFAILED;
7953      }
7954      (ueCfgDb->numRlcLcs)++;
7955      (ueCfgDb->numMacLcs)++;
7956          DU_LOG("\nDEBUG  -> DUAPP: extractRlcCfgToAddMod:RBType:%d, DrbID: %d,lcId:%d, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
7957                             rbType, rbId, lcId, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
7958   }
7959   //TODO: To send the failure cause in UeContextSetupRsp
7960   return ROK;
7961 }
7962
7963 /*******************************************************************
7964  *
7965  * @brief DeAlloc pdsch serv cell config info
7966  *
7967  * @details
7968  *
7969  *    Function : freeMacPdschServCellInfo
7970  *
7971  *    Functionality: DeAlloc pdsch serv cell config info
7972  *
7973  * @params[in] PdschServCellCfg pointer
7974  * @return void
7975  *
7976  * ****************************************************************/
7977
7978 void freeMacPdschServCellInfo(PdschServCellCfg *pdsch)
7979 {
7980    if(pdsch->xOverhead)
7981    {
7982       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->xOverhead, sizeof(PdschXOverhead));
7983    }
7984    if(pdsch->codeBlkGrpFlushInd)
7985    {
7986       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->codeBlkGrpFlushInd, sizeof(bool));
7987    }
7988    if(pdsch->maxCodeBlkGrpPerTb)
7989    {
7990       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
7991    }
7992    if(pdsch->maxMimoLayers)
7993    {
7994       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxMimoLayers, sizeof(uint8_t));
7995    }
7996 }
7997
7998 /*******************************************************************
7999  *
8000  * @brief Free Serving cell Info
8001  *
8002  * @details
8003  *
8004  *    Function : freeMacServingCellInfo
8005  *
8006  *    Functionality: Free Serving cell Info
8007  *
8008  * @params[in] ServCellCfgInfo *srvCellCfg
8009  * @return void
8010  *
8011  * ****************************************************************/
8012 void freeMacServingCellInfo(ServCellCfgInfo *srvCellCfg)
8013 {
8014    uint8_t timeDomRsrcIdx;
8015
8016    if(srvCellCfg->initDlBwp.pdschPresent)
8017    {
8018       for(timeDomRsrcIdx = 0; timeDomRsrcIdx < srvCellCfg->initDlBwp.pdschCfg.numTimeDomRsrcAlloc; timeDomRsrcIdx++)
8019       {
8020          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, \
8021             srvCellCfg->initDlBwp.pdschCfg.timeDomRsrcAllociList[timeDomRsrcIdx].k0, sizeof(uint8_t));
8022       }
8023    }
8024
8025    freeMacPdschServCellInfo(&srvCellCfg->pdschServCellCfg);
8026    if(srvCellCfg->bwpInactivityTmr)
8027    {
8028       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
8029    }
8030
8031    if(srvCellCfg->initUlBwp.pucchPresent)
8032    {
8033       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->initUlBwp.pucchCfg.dlDataToUlAck, sizeof(PucchDlDataToUlAck));
8034    }
8035 }
8036
8037 /*******************************************************************
8038  *
8039  * @brief Free cell Grp Cfg Info
8040  *
8041  * @details
8042  *
8043  *    Function : freeUeReCfgCellGrpInfo
8044  *
8045  *    Functionality: Free cell Grp Cfg Info
8046  *
8047  * @params[in] MacUeCfg*  duUeCfg
8048  * @return void
8049  *
8050  * ****************************************************************/
8051
8052 void freeUeReCfgCellGrpInfo(MacUeCfg *macUeCfg)
8053 {
8054    freeMacServingCellInfo(&macUeCfg->spCellCfg.servCellCfg);
8055 }
8056
8057 /*******************************************************************
8058  *
8059  * @brief Fills Reconfig SchReqReConfig
8060  *
8061  * @details
8062  *
8063  *    Function : extractSchReqReConfig
8064  *
8065  *    Functionality: Fills Reconfig SchReqReConfig
8066  *
8067  * @params[in] SchedulingRequestConfig_t *cuSchedReq
8068  *             SchedReqCfg*  macSchedReq
8069  * @return void
8070  *
8071  * ****************************************************************/
8072 void extractSchReqReConfig(SchedulingRequestConfig_t *cuSchedReq, SchedReqCfg *macSchedReq)
8073 {
8074    uint8_t schReqIdx = 0;
8075    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqListToAdd = NULLP;
8076    struct SchedulingRequestConfig__schedulingRequestToReleaseList *schReqListToRel = NULLP;
8077
8078    if(cuSchedReq->schedulingRequestToAddModList)
8079    {
8080       schReqListToAdd = cuSchedReq->schedulingRequestToAddModList;
8081       if(schReqListToAdd->list.count)
8082       {
8083          macSchedReq->addModListCount = schReqListToAdd->list.count;
8084          for(schReqIdx = 0; schReqIdx < schReqListToAdd->list.count; schReqIdx++)
8085          {
8086             macSchedReq->addModList[schReqIdx].schedReqId = \
8087                schReqListToAdd->list.array[schReqIdx]->schedulingRequestId;
8088             macSchedReq->addModList[schReqIdx].srProhibitTmr = \
8089                *(schReqListToAdd->list.array[schReqIdx]->sr_ProhibitTimer);
8090             macSchedReq->addModList[schReqIdx].srTransMax    =\
8091                schReqListToAdd->list.array[schReqIdx]->sr_TransMax;
8092          }
8093       }
8094    }
8095    /* Scheduling Req To release */
8096    if(cuSchedReq->schedulingRequestToReleaseList)
8097    {
8098       schReqListToRel = cuSchedReq->schedulingRequestToReleaseList;
8099       if(schReqListToRel->list.count)
8100       {
8101          macSchedReq->relListCount = schReqListToRel->list.count;
8102          for(schReqIdx = 0; schReqIdx < schReqListToRel->list.count; schReqIdx++)
8103          {
8104             macSchedReq->relList[schReqIdx] = \
8105                *schReqListToRel->list.array[schReqIdx];
8106          }
8107       }
8108    }
8109 }
8110
8111 /*******************************************************************
8112  *
8113  * @brief Fills TagReconfig
8114  *
8115  * @details
8116  *
8117  *    Function : extractTagReconfig
8118  *
8119  *    Functionality: Fills extractTagReconfig
8120  *
8121  * @params[in] TAG_Config_t *cuTagCfg
8122  *             TagCfg *macTagCfg
8123  * @return void
8124  *
8125  * ****************************************************************/
8126
8127 void extractTagReconfig(TAG_Config_t *cuTagCfg, TagCfg *macTagCfg)
8128 {
8129   uint8_t tagIdx = 0;
8130   struct TAG_Config__tag_ToAddModList  *tagListToAddMod = NULLP;
8131   struct TAG_Config__tag_ToReleaseList *tagListToRel = NULLP;
8132
8133   /* Tag config to AddMod */
8134   if(cuTagCfg->tag_ToAddModList)
8135   {
8136      tagListToAddMod = cuTagCfg->tag_ToAddModList;
8137      if(tagListToAddMod->list.count)
8138      {
8139         macTagCfg->addModListCount = tagListToAddMod->list.count;
8140         for(tagIdx = 0; tagIdx < tagListToAddMod->list.count; tagIdx++)
8141         {
8142            macTagCfg->addModList[tagIdx].tagId =\
8143               tagListToAddMod->list.array[tagIdx]->tag_Id;
8144            macTagCfg->addModList[tagIdx].timeAlignTimer = \
8145
8146               tagListToAddMod->list.array[tagIdx]->timeAlignmentTimer;
8147         }
8148      }
8149   }
8150   /* Tag config to release */
8151   if(cuTagCfg->tag_ToReleaseList)
8152   {
8153      tagListToRel = cuTagCfg->tag_ToReleaseList;
8154      if(tagListToRel->list.count)
8155      {
8156         macTagCfg->relListCount = tagListToRel->list.count;
8157         for(tagIdx = 0; tagIdx < tagListToRel->list.count; tagIdx++)
8158         {
8159            macTagCfg->relList[tagIdx] = *tagListToRel->list.array[tagIdx];
8160         }
8161      }
8162   }
8163 }
8164
8165 /*******************************************************************
8166  *
8167  * @brief Fills PdcchCfg received by CU
8168  *
8169  * @details
8170  *
8171  *    Function : extractPdcchCfg
8172  *
8173  *    Functionality: Fills PdcchCfg received  by CU
8174  *
8175  * @params[in] PDCCH_Config_t *cuPdcchCfg,
8176  *             PdcchConfig *duPdcchCfg
8177  * @return void
8178  *
8179  * ****************************************************************/
8180
8181 void extractPdcchCfg(PDCCH_Config_t *cuPdcchCfg, PdcchConfig *macPdcchCfg)
8182 {
8183    uint8_t cRsetIdx = 0;
8184    uint8_t srchSpcIdx = 0;
8185
8186    struct PDCCH_Config__controlResourceSetToAddModList *cRsetToAddModList = NULLP;
8187    struct PDCCH_Config__controlResourceSetToReleaseList *cRsetToRelList = NULLP;
8188    struct PDCCH_Config__searchSpacesToAddModList *srchSpcToAddModList = NULLP;
8189    struct PDCCH_Config__searchSpacesToReleaseList *srchSpcToRelList = NULLP;
8190
8191
8192    /* Control Resource Set To Add/Mod List */
8193    if(cuPdcchCfg->controlResourceSetToAddModList)
8194    {
8195       cRsetToAddModList = cuPdcchCfg->controlResourceSetToAddModList;
8196       if(cRsetToAddModList->list.count)
8197       {
8198          macPdcchCfg->numCRsetToAddMod = cRsetToAddModList->list.count;
8199          for(cRsetIdx = 0; cRsetIdx < cRsetToAddModList->list.count; cRsetIdx++)
8200          {
8201             macPdcchCfg->cRSetToAddModList[cRsetIdx].cRSetId = \
8202                cRsetToAddModList->list.array[cRsetIdx]->controlResourceSetId;
8203             //freqDomRsrcBitStringToInt(&cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources,\
8204                   macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc);
8205             memcpy(macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc, \
8206                cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources.buf,
8207                cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources.size);
8208
8209             macPdcchCfg->cRSetToAddModList[cRsetIdx].duration = \
8210                 cRsetToAddModList->list.array[cRsetIdx]->duration;
8211
8212             macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType = \
8213                cRsetToAddModList->list.array[cRsetIdx]->cce_REG_MappingType.present;
8214             if(macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType == CCE_REG_MAPPINGTYPE_PR_INTERLEAVED)
8215             {
8216                //TODO: handle the case for Interleaved
8217             }
8218             macPdcchCfg->cRSetToAddModList[cRsetIdx].precoderGranularity = \
8219                 cRsetToAddModList->list.array[cRsetIdx]->precoderGranularity;
8220             if(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID)
8221             {
8222                macPdcchCfg->cRSetToAddModList[cRsetIdx].dmrsScramblingId= \
8223                   *(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID);
8224             }
8225          }
8226       }
8227    }
8228    /* Control Resource Set To Release List */
8229    if(cuPdcchCfg->controlResourceSetToReleaseList)
8230    {
8231       cRsetToRelList = cuPdcchCfg->controlResourceSetToReleaseList;
8232       if(cRsetToRelList->list.count)
8233       {
8234          macPdcchCfg->numCRsetToRel = cRsetToRelList->list.count;
8235          for(cRsetIdx = 0; cRsetIdx < cRsetToRelList->list.count; cRsetIdx++)
8236          {
8237             macPdcchCfg->cRSetToRelList[cRsetIdx] = *(cRsetToRelList->list.array[cRsetIdx]);
8238          }
8239       }
8240    }
8241
8242    /* Search space To Add/Mod List */
8243    if(cuPdcchCfg->searchSpacesToAddModList)
8244    {
8245       srchSpcToAddModList = cuPdcchCfg->searchSpacesToAddModList;
8246       if(srchSpcToAddModList->list.count)
8247       {
8248          macPdcchCfg->numSearchSpcToAddMod = srchSpcToAddModList->list.count;
8249          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToAddModList->list.count; srchSpcIdx++)
8250          {
8251             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceId =\
8252                                                                           srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceId;
8253             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].cRSetId =\
8254                                                                     *(srchSpcToAddModList->list.array[srchSpcIdx]->controlResourceSetId);
8255             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset)
8256             {
8257                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset =\
8258                                                                                          srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset->present;
8259             }
8260             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot)
8261             {
8262                bitStringToInt(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot,\
8263                      macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSymbolsWithinSlot);
8264             }
8265             if(srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates)
8266             {
8267                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel1 = \
8268                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel1;
8269                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel2 = \
8270                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel2;
8271                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel4 = \
8272                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel4;
8273
8274                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel8 = \
8275                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel8;
8276
8277                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel16 = \
8278                                                                                         srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel16;
8279             }
8280             if(srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType)
8281             {
8282                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType =\
8283                                                                                srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->present;
8284                if(macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType == SEARCHSPACETYPE_PR_UE_SPECIFIC)
8285                {
8286                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].ueSpecificDciFormat =\
8287                                                                                       srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->choice.ue_Specific->dci_Formats;
8288                }
8289
8290             }
8291          }
8292       }
8293    }
8294    /* Search space To Rel List */
8295    if(cuPdcchCfg->searchSpacesToReleaseList)
8296    {
8297       srchSpcToRelList = cuPdcchCfg->searchSpacesToReleaseList;
8298       if(srchSpcToRelList->list.count)
8299       {
8300          macPdcchCfg->numSearchSpcToRel = srchSpcToRelList->list.count;
8301          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToRelList->list.count; srchSpcIdx++)
8302          {
8303             macPdcchCfg->searchSpcToRelList[srchSpcIdx] =\
8304                                                          *(srchSpcToRelList->list.array[srchSpcIdx]);
8305          }
8306       }
8307    }
8308 }
8309
8310 /*******************************************************************
8311  *
8312  * @brief Fills PdschCfg received by CU
8313  *
8314  * @details
8315  *
8316  *    Function : extractPdschCfg
8317  *
8318  *    Functionality: Fills PdschCfg received  by CU
8319  *
8320  * @params[in] PDSCH_Config_t *cuPdschCfg = Information which is send by CU,
8321  *                   which we have stored in F1UeContextSetupDb,
8322  *             PdschConfig *macPdschCfg = Used to Store the information which
8323  *                   needs to send in other layer, as well as this can be the variable
8324  *                   which stores the information in DuCb,
8325  *             PdschConfig *storedPdschCfg =  Null in case of sending the
8326  *                   information to other layer else it will have stored pdsch
8327  *                   configuration in copyOfmacUeCfg.
8328  * @return void
8329  *
8330  * ****************************************************************/
8331
8332 void extractPdschCfg(PDSCH_Config_t *cuPdschCfg, PdschConfig *macPdschCfg, PdschConfig *storedPdschCfg)
8333 {
8334    uint8_t timeDomIdx;
8335    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAlloc = NULLP;
8336
8337    if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
8338    {
8339       if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->present == \
8340             PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup)
8341       {
8342          if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup)
8343          {
8344             macPdschCfg->dmrsDlCfgForPdschMapTypeA.addPos = \
8345                *(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_AdditionalPosition);
8346          }
8347       }
8348    }
8349    macPdschCfg->resourceAllocType = cuPdschCfg->resourceAllocation;
8350    if(cuPdschCfg->pdsch_TimeDomainAllocationList)
8351    {
8352       timeDomAlloc = cuPdschCfg->pdsch_TimeDomainAllocationList;
8353       if(timeDomAlloc->present ==\
8354             PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup)
8355       {
8356          if(timeDomAlloc->choice.setup)
8357          {
8358             macPdschCfg->numTimeDomRsrcAlloc  = timeDomAlloc->choice.setup->list.count;
8359             for(timeDomIdx = 0; timeDomIdx < timeDomAlloc->choice.setup->list.count; timeDomIdx++)
8360             {
8361                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 = NULLP;
8362                if(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0)
8363                {
8364                   if(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 == NULL)
8365                   {
8366                      if(storedPdschCfg)
8367                      {
8368                         if(storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
8369                         {
8370                            macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 =\
8371                            storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0;
8372                         }
8373                         else
8374                         {
8375                            DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
8376                         }
8377                      }
8378                      else
8379                      {
8380                         DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
8381                      }
8382                      if(!macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
8383                      {
8384                         DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for k0 at extractPdschCfg()");
8385                         return RFAILED;
8386                      }
8387                   }
8388                   *(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0) = \
8389                   *(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0);
8390                }
8391                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
8392                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
8393                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
8394                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8395             }
8396          }
8397       }
8398    }
8399    macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
8400    if(cuPdschCfg->maxNrofCodeWordsScheduledByDCI)
8401       macPdschCfg->numCodeWordsSchByDci = *(cuPdschCfg->maxNrofCodeWordsScheduledByDCI);
8402    if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_staticBundling)
8403    {
8404       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
8405       if(cuPdschCfg->prb_BundlingType.choice.staticBundling)
8406       {
8407          if(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize)
8408          {
8409             macPdschCfg->bundlingInfo.StaticBundling.size = \
8410                *(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize);
8411          }
8412       }
8413    }
8414    else if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_dynamicBundling)
8415    {
8416       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
8417    }
8418
8419 }
8420
8421 /*******************************************************************
8422  *
8423  * @brief Fills PdschServingCellCfg received by CU
8424  *
8425  * @details
8426  *
8427  *    Function : extractPdschServingCellCfg
8428  *
8429  *    Functionality: Fills PdschCfg received  by CU
8430  *
8431  * @params[in] PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg,
8432  *             PdschServCellCfg *macUePdschSrvCellCfg
8433  * @return ROK/RFAILED
8434  *
8435  * ****************************************************************/
8436
8437 uint8_t extractPdschServingCellCfg(PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg, PdschServCellCfg *macUePdschSrvCellCfg)
8438 {
8439    if(cuPdschSrvCellCfg->codeBlockGroupTransmission)
8440    {
8441       if(cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup)
8442       {
8443          if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
8444          {
8445             *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
8446                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
8447          }
8448          else
8449          {
8450             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
8451             if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
8452             {
8453                *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
8454                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
8455             }
8456             else
8457             {
8458                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
8459                return RFAILED;
8460             }
8461          }
8462          if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
8463          {
8464             *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
8465                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
8466          }
8467          else
8468          {
8469             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->codeBlkGrpFlushInd , sizeof(bool));
8470             if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
8471             {
8472                *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
8473                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
8474             }
8475             else
8476             {
8477                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
8478                return RFAILED;
8479             }
8480          }
8481       }
8482    }
8483    if(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH)
8484    {
8485       macUePdschSrvCellCfg->numHarqProcForPdsch = *(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH);
8486    }
8487    if(cuPdschSrvCellCfg->ext1)
8488    {
8489       if(cuPdschSrvCellCfg->ext1->maxMIMO_Layers)
8490       {
8491         if(macUePdschSrvCellCfg->maxMimoLayers)
8492         {
8493            *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
8494         }
8495         else
8496         {
8497            DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxMimoLayers, sizeof(uint8_t));
8498            if(macUePdschSrvCellCfg->maxMimoLayers)
8499            {
8500               *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
8501            }
8502            else
8503            {
8504               DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
8505               return RFAILED;
8506            }
8507         }
8508       }
8509    }
8510    if(cuPdschSrvCellCfg->xOverhead)
8511    {
8512       if(macUePdschSrvCellCfg->xOverhead)
8513       {
8514          *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
8515       }
8516       else
8517       {
8518          DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->xOverhead, sizeof(PdschXOverhead));
8519          if(macUePdschSrvCellCfg->xOverhead)
8520          {
8521             *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
8522          }
8523          else
8524          {
8525             DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
8526             return RFAILED;
8527          }
8528       }
8529    }
8530    return ROK;
8531 }
8532
8533 /*******************************************************************
8534  *
8535  * @brief Fills PuschCfg received by CU
8536  *
8537  * @details
8538  *
8539  *    Function : extractPuschCfg
8540  *
8541  *    Functionality: Fills PuschCfg received  by CU
8542  *
8543  * @params[in] BWP_UplinkDedicated__pusch_Config *cuPuschCfg,
8544  *             PuschCfg *macPuschCfg
8545  * @return void
8546  *
8547  * ****************************************************************/
8548
8549 void extractPuschCfg(struct BWP_UplinkDedicated__pusch_Config *cuPuschCfg, PuschCfg *macPuschCfg)
8550 {
8551    uint8_t timeDomIdx = 0;
8552    DMRS_UplinkConfig_t *dmrsUlCfg = NULLP;
8553    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList = NULLP;
8554
8555    if(cuPuschCfg->present == BWP_UplinkDedicated__pusch_Config_PR_setup)
8556    {
8557       if(cuPuschCfg->choice.setup)
8558       {
8559          if(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH)
8560          {
8561              macPuschCfg->dataScramblingId = \
8562                 *(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH);
8563          }
8564          if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA)
8565          {
8566             if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->present == PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup)
8567             {
8568                if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup)
8569                {
8570                   dmrsUlCfg = (cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup);
8571                   if(dmrsUlCfg->dmrs_AdditionalPosition)
8572                   {
8573                      macPuschCfg->dmrsUlCfgForPuschMapTypeA.addPos =\
8574                         *(dmrsUlCfg->dmrs_AdditionalPosition);
8575                   }
8576                   if(dmrsUlCfg->transformPrecodingDisabled)
8577                   {
8578                      if(dmrsUlCfg->transformPrecodingDisabled->scramblingID0)
8579                      {
8580                         macPuschCfg->dmrsUlCfgForPuschMapTypeA.transPrecodDisabled.scramblingId0 = \
8581                            *(dmrsUlCfg->transformPrecodingDisabled->scramblingID0);
8582                      }
8583                   }
8584                }
8585             }
8586          }
8587          /*Res Alloc Type for UL */
8588          if(cuPuschCfg->choice.setup->resourceAllocation)
8589          {
8590             macPuschCfg->resourceAllocType = \
8591                cuPuschCfg->choice.setup->resourceAllocation;
8592          }
8593          if(cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList)
8594          {
8595             timeDomAllocList = cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList;
8596             if(timeDomAllocList->present == PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup)
8597             {
8598                if(timeDomAllocList->choice.setup)
8599                {
8600                   macPuschCfg->numTimeDomRsrcAlloc = timeDomAllocList->choice.setup->list.count;
8601                   for(timeDomIdx = 0; timeDomIdx <timeDomAllocList->choice.setup->list.count; timeDomIdx++)
8602                   {
8603                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].k2 = \
8604                         *(timeDomAllocList->choice.setup->list.array[timeDomIdx]->k2);
8605                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].mappingType = \
8606                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->mappingType;
8607                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbolAndLength = \
8608                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8609                   }
8610                }
8611             }
8612          }
8613          if(cuPuschCfg->choice.setup->transformPrecoder)
8614             macPuschCfg->transformPrecoder = *(cuPuschCfg->choice.setup->transformPrecoder);
8615       }
8616    }
8617 }
8618
8619 /*******************************************************************
8620  *
8621  * @brief Function to fill pucch Power Control
8622  *
8623  * @details
8624  *
8625  *    Function : extractPucchPowerControl
8626  *
8627  *    Functionality: Function to fill pucch Power Control
8628  *
8629  * @params[in] PucchPowerControl *pwrCtrl,
8630  *             struct PUCCH_PowerControl *cuPwrCtrlCfg
8631  * @return void
8632  *
8633  * ****************************************************************/
8634
8635 void extractPucchPowerControl(PucchPowerControl *pwrCtrl, struct PUCCH_PowerControl *cuPwrCtrlCfg)
8636 {
8637    uint8_t arrIdx;
8638
8639    if(cuPwrCtrlCfg->deltaF_PUCCH_f0)
8640       pwrCtrl->deltaF_Format0 = *cuPwrCtrlCfg->deltaF_PUCCH_f0;
8641    if(cuPwrCtrlCfg->deltaF_PUCCH_f1)
8642       pwrCtrl->deltaF_Format1 = *cuPwrCtrlCfg->deltaF_PUCCH_f1;
8643    if(cuPwrCtrlCfg->deltaF_PUCCH_f2)
8644       pwrCtrl->deltaF_Format2 = *cuPwrCtrlCfg->deltaF_PUCCH_f2;
8645    if(cuPwrCtrlCfg->deltaF_PUCCH_f3)
8646       pwrCtrl->deltaF_Format3 = *cuPwrCtrlCfg->deltaF_PUCCH_f3;
8647    if(cuPwrCtrlCfg->deltaF_PUCCH_f4)
8648       pwrCtrl->deltaF_Format4 = *cuPwrCtrlCfg->deltaF_PUCCH_f4;
8649    if(cuPwrCtrlCfg->p0_Set)
8650    {
8651       pwrCtrl->p0SetCount = cuPwrCtrlCfg->p0_Set->list.count;
8652       for(arrIdx=0; arrIdx < pwrCtrl->p0SetCount; arrIdx++)
8653       {
8654          pwrCtrl->p0Set[arrIdx].p0PucchId =\
8655             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Id;
8656          pwrCtrl->p0Set[arrIdx].p0PucchVal =\
8657             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Value;
8658       }
8659    }
8660    if(cuPwrCtrlCfg->pathlossReferenceRSs)
8661    {
8662       pwrCtrl->pathLossRefRSListCount = cuPwrCtrlCfg->pathlossReferenceRSs->list.count;
8663       for(arrIdx = 0; arrIdx < pwrCtrl->pathLossRefRSListCount; arrIdx++)
8664       {
8665          pwrCtrl->pathLossRefRSList[arrIdx].pathLossRefRSId =\
8666             cuPwrCtrlCfg->pathlossReferenceRSs->list.array[arrIdx]->pucch_PathlossReferenceRS_Id;
8667       }
8668    }
8669 }
8670
8671  /*******************************************************************
8672  *
8673  * @brief Function to extractResrcSetToAddModList sent by CU
8674  *
8675  * @details
8676  *
8677  *    Function : extractResrcSetToAddModList
8678  *
8679  *    Functionality: Fucntion to extractResrcSetToAddModList
8680  *
8681  * @params[in] PucchResrcSetCfg pointer,
8682  *             struct PUCCH_Config__resourceSetToAddModList pointer
8683  * @return void
8684  *
8685  * ****************************************************************/
8686
8687 void extractResrcSetToAddModList(PucchResrcSetCfg *macRsrcSetList, struct PUCCH_Config__resourceSetToAddModList *cuRsrcSetList)
8688 {
8689    uint8_t arrIdx, rsrcListIdx;
8690
8691    macRsrcSetList->resrcSetToAddModListCount = cuRsrcSetList->list.count;
8692    for(arrIdx = 0; arrIdx < macRsrcSetList->resrcSetToAddModListCount; arrIdx++)
8693    {
8694       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcSetId     =\
8695          cuRsrcSetList->list.array[arrIdx]->pucch_ResourceSetId;
8696       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount =\
8697          cuRsrcSetList->list.array[arrIdx]->resourceList.list.count;
8698       for(rsrcListIdx = 0; rsrcListIdx < macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount; rsrcListIdx++)
8699       {
8700          macRsrcSetList->resrcSetToAddModList[arrIdx].resrcList[rsrcListIdx] =\
8701             *cuRsrcSetList->list.array[arrIdx]->resourceList.list.array[rsrcListIdx];
8702       }
8703       macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize =\
8704          *cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1;
8705    }
8706 }/* End of extractResrcSetToAddModList */
8707
8708 /*******************************************************************
8709  *
8710  * @brief Fills extractResrcToAddModList sent by CU
8711  *
8712  * @details
8713  *
8714  *    Function : extractResrcToAddModList
8715  *
8716  *    Functionality: Fills extractResrcToAddModList
8717  *
8718  * @params[in] PucchResrcCfg pointer,
8719  *             struct PUCCH_Config__resourceToAddModList pointer
8720  * @return ROk/RFAILED
8721  *
8722  * ****************************************************************/
8723
8724 uint8_t extractResrcToAddModList(PucchResrcCfg *macResrcList, struct PUCCH_Config__resourceToAddModList *cuResrcList)
8725 {
8726    uint8_t arrIdx;
8727
8728    macResrcList->resrcToAddModListCount = cuResrcList->list.count;
8729    for(arrIdx = 0; arrIdx < macResrcList->resrcToAddModListCount; arrIdx++)
8730    {
8731       macResrcList->resrcToAddModList[arrIdx].resrcId      =\
8732         cuResrcList->list.array[arrIdx]->pucch_ResourceId;
8733       macResrcList->resrcToAddModList[arrIdx].startPrb     =\
8734         cuResrcList->list.array[arrIdx]->startingPRB;
8735       if(cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping)
8736       {
8737          macResrcList->resrcToAddModList[arrIdx].intraFreqHop =\
8738            *cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping;
8739       }
8740       if(cuResrcList->list.array[arrIdx]->secondHopPRB)
8741       {
8742          macResrcList->resrcToAddModList[arrIdx].secondPrbHop =\
8743            *cuResrcList->list.array[arrIdx]->secondHopPRB;
8744       }
8745       /* PUCCH RSRC FORMAT */
8746       if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format0)
8747       {
8748          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_0;
8749          if(cuResrcList->list.array[arrIdx]->format.choice.format0)
8750          {
8751             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0, sizeof(PucchFormat0));
8752             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0 == NULLP)
8753             {
8754                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
8755                return RFAILED;
8756             }
8757             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->initialCyclicShift =\
8758                cuResrcList->list.array[arrIdx]->format.choice.format0->initialCyclicShift;
8759             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->numSymbols =\
8760                cuResrcList->list.array[arrIdx]->format.choice.format0->nrofSymbols;
8761             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->startSymbolIdx =\
8762                cuResrcList->list.array[arrIdx]->format.choice.format0->startingSymbolIndex;
8763          }
8764       }
8765       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format1)
8766       {
8767          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_1;
8768          if(cuResrcList->list.array[arrIdx]->format.choice.format1)
8769          {
8770             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1, sizeof(PucchFormat1));
8771             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1 == NULLP)
8772             {
8773                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
8774                return RFAILED;
8775             }
8776             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->initialCyclicShift =\
8777                 cuResrcList->list.array[arrIdx]->format.choice.format1->initialCyclicShift;
8778             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->numSymbols =\
8779                 cuResrcList->list.array[arrIdx]->format.choice.format1->nrofSymbols;
8780             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->startSymbolIdx =\
8781                 cuResrcList->list.array[arrIdx]->format.choice.format1->startingSymbolIndex;
8782             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->timeDomOCC =\
8783                 cuResrcList->list.array[arrIdx]->format.choice.format1->timeDomainOCC;
8784          }
8785       }
8786       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format2)
8787       {
8788          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_2;
8789          if(cuResrcList->list.array[arrIdx]->format.choice.format2)
8790          {
8791             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
8792             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2 == NULLP)
8793             {
8794                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
8795                return RFAILED;
8796             }
8797             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numPrbs =\
8798                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofPRBs;
8799             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numSymbols =\
8800                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofSymbols;
8801             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->startSymbolIdx =\
8802                 cuResrcList->list.array[arrIdx]->format.choice.format2->startingSymbolIndex;
8803          }
8804       }
8805       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format3)
8806       {
8807          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_3;
8808          if(cuResrcList->list.array[arrIdx]->format.choice.format3)
8809          {
8810             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
8811             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3 == NULLP)
8812             {
8813                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
8814                return RFAILED;
8815             }
8816             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numPrbs =\
8817                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofPRBs;
8818             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numSymbols =\
8819                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofSymbols;
8820             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->startSymbolIdx =\
8821                 cuResrcList->list.array[arrIdx]->format.choice.format3->startingSymbolIndex;
8822          }
8823       }
8824       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format4)
8825       {
8826          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_4;
8827          if(cuResrcList->list.array[arrIdx]->format.choice.format4)
8828          {
8829             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4, sizeof(PucchFormat4));
8830             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4 == NULLP)
8831             {
8832                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
8833                return RFAILED;
8834             }
8835             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->numSymbols =\
8836                 cuResrcList->list.array[arrIdx]->format.choice.format4->nrofSymbols;
8837             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occLen =\
8838                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Length;
8839             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occIdx =\
8840                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Index;
8841             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->startSymbolIdx =\
8842                 cuResrcList->list.array[arrIdx]->format.choice.format4->startingSymbolIndex;
8843          }
8844       }
8845    }
8846    return ROK;
8847
8848 }/* End of extractResrcToAddModList */
8849
8850 /*******************************************************************
8851  *
8852  * @brief Fills fillPucchSchedReqPeriodAndOffset sent by CU
8853  *
8854  * @details
8855  *
8856  *    Function : fillPucchSchedReqPeriodAndOffset
8857  *
8858  *    Functionality: To fillPucchSchedReqPeriodAndOffset
8859  *
8860  * @params[in] macPeriodicty,
8861  *     SchedulingRequestResourceConfig__periodicityAndOffset pointer
8862  * @return void
8863  *
8864  * ****************************************************************/
8865
8866 void fillPucchSchedReqPeriodAndOffset(uint8_t macPeriodicty, uint16_t  macOffset,\
8867    struct SchedulingRequestResourceConfig__periodicityAndOffset *cuPeriodicty)
8868 {
8869    macPeriodicty = cuPeriodicty->present;
8870    switch(macPeriodicty)
8871    {
8872       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
8873          {
8874             macOffset     = cuPeriodicty->choice.sym2;
8875             break;
8876          }
8877       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
8878          {
8879             macOffset     = cuPeriodicty->choice.sym6or7;
8880             break;
8881          }
8882       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
8883          {
8884             macOffset     = cuPeriodicty->choice.sl1;
8885             break;
8886          }
8887       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
8888          {
8889             macOffset = cuPeriodicty->choice.sl2;
8890             break;
8891          }
8892       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
8893          {
8894             macOffset = cuPeriodicty->choice.sl4;
8895             break;
8896          }
8897       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
8898          {
8899             macOffset = cuPeriodicty->choice.sl5;
8900             break;
8901          }
8902       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
8903          {
8904             macOffset = cuPeriodicty->choice.sl8;
8905             break;
8906          }
8907       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
8908          {
8909             macOffset = cuPeriodicty->choice.sl10;
8910             break;
8911          }
8912       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
8913          {
8914             macOffset = cuPeriodicty->choice.sl16;
8915             break;
8916          }
8917       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
8918          {
8919             macOffset = cuPeriodicty->choice.sl20;
8920             break;
8921          }
8922       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
8923          {
8924             macOffset = cuPeriodicty->choice.sl40;
8925             break;
8926          }
8927       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
8928          {
8929             macOffset = cuPeriodicty->choice.sl80;
8930             break;
8931          }
8932       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
8933          {
8934             macOffset = cuPeriodicty->choice.sl160;
8935             break;
8936          }
8937       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
8938          {
8939             macOffset = cuPeriodicty->choice.sl320;
8940             break;
8941          }
8942       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
8943          {
8944             macOffset = cuPeriodicty->choice.sl640;
8945             break;
8946          }
8947       default :
8948          DU_LOG("\nERROR  -->  F1AP : Invalid periodicity %d", macPeriodicty);
8949    }
8950 }
8951
8952 /*******************************************************************
8953  *
8954  * @brief Function to extractPucchFormatCfg sent by CU
8955  *
8956  * @details
8957  *
8958  *    Function : extractPucchFormatCfg
8959  *
8960  *    Functionality: Function to extractPucchFormatCfg
8961  *
8962  * @params[in] PucchFormatCfg pointer,
8963  *             PUCCH_FormatConfig_t pointer
8964  * @return void
8965  *
8966  * ****************************************************************/
8967
8968 void extractPucchFormatCfg(PucchFormatCfg *macFormatCfg, PUCCH_FormatConfig_t *cuFormatCfg)
8969  {
8970     if(cuFormatCfg->interslotFrequencyHopping)
8971        macFormatCfg->interSlotFreqHop = *cuFormatCfg->interslotFrequencyHopping;
8972     if(cuFormatCfg->additionalDMRS)
8973        macFormatCfg->addDmrs = *cuFormatCfg->additionalDMRS;
8974     if(cuFormatCfg->maxCodeRate)
8975        macFormatCfg->maxCodeRate = *cuFormatCfg->maxCodeRate;
8976     if(cuFormatCfg->nrofSlots)
8977        macFormatCfg->numSlots = *cuFormatCfg->nrofSlots;
8978     if(cuFormatCfg->pi2BPSK)
8979        macFormatCfg->pi2BPSK = *cuFormatCfg->pi2BPSK;
8980     if(cuFormatCfg->simultaneousHARQ_ACK_CSI)
8981        macFormatCfg->harqAckCSI = *cuFormatCfg->simultaneousHARQ_ACK_CSI;
8982  }/* End of extractPucchFormatCfg */
8983
8984 /*******************************************************************
8985  *
8986  * @brief Function to extractSchedReqCfgToAddMod sent by CU
8987  *
8988  * @details
8989  *
8990  *    Function : extractSchedReqCfgToAddMod
8991  *
8992  *    Functionality: Function to extractSchedReqCfgToAddMod
8993  *
8994  * @params[in] PucchSchedReqCfg pointer,
8995  *      PUCCH_Config__schedulingRequestResourceToAddModList pointer
8996  * @return void
8997  *
8998  * ****************************************************************/
8999
9000 void extractSchedReqCfgToAddMod(PucchSchedReqCfg *macSchedReqCfg, struct PUCCH_Config__schedulingRequestResourceToAddModList *cuSchedReqList)
9001 {
9002    uint8_t arrIdx;
9003
9004    macSchedReqCfg->schedAddModListCount = cuSchedReqList->list.count;
9005    for(arrIdx = 0; arrIdx <  macSchedReqCfg->schedAddModListCount; arrIdx++)
9006    {
9007       macSchedReqCfg->schedAddModList[arrIdx].resrcId =\
9008          cuSchedReqList->list.array[arrIdx]->schedulingRequestResourceId;
9009       macSchedReqCfg->schedAddModList[arrIdx].requestId =\
9010          cuSchedReqList->list.array[arrIdx]->schedulingRequestID;
9011       if(cuSchedReqList->list.array[arrIdx]->periodicityAndOffset)
9012       {
9013          fillPucchSchedReqPeriodAndOffset(macSchedReqCfg->schedAddModList[arrIdx].periodicity,\
9014             macSchedReqCfg->schedAddModList[arrIdx].offset, cuSchedReqList->list.array[arrIdx]->periodicityAndOffset);
9015       }
9016       if(cuSchedReqList->list.array[arrIdx]->resource)
9017       {
9018          macSchedReqCfg->schedAddModList[arrIdx].resrc =\
9019             *cuSchedReqList->list.array[arrIdx]->resource;
9020       }
9021    }
9022
9023 }/* End of extractSchedReqCfgToAddMod */
9024
9025  /*******************************************************************
9026  *
9027  * @brief Fills PucchCfg received by CU
9028  *
9029  * @details
9030  *
9031  *    Function : extractPucchCfg
9032  *
9033  *    Functionality: Fills PucchCfg received  by CU
9034  *
9035  * @params[in] BWP_UplinkDedicated__pucch_Config *cuPucchCfg = Information which
9036  *                is send by CU, which we have stored in F1UeContextSetupDb,
9037  *             PucchCfg *macPucchCfg = Used to Store the information which
9038  *                needs to send in other layer, as well as this can be the variable
9039  *                which stores the information in DuCb,
9040  *             PucchCfg *storedPucchCfg = Null in case of sending the
9041  *                information to other layer else it will have Pucch Cfg which
9042  *                we have stored in copyOfmacUeCfg.
9043  * @return ROK/RFAILED
9044  *
9045  * ****************************************************************/
9046
9047 uint8_t extractPucchCfg(struct BWP_UplinkDedicated__pucch_Config *cuPucchCfg, PucchCfg *macPucchCfg,\
9048 PucchCfg *storedPucchCfg)
9049 {
9050    uint8_t arrIdx;
9051
9052    if(cuPucchCfg->present == BWP_UplinkDedicated__pucch_Config_PR_setup)
9053    {
9054       if(cuPucchCfg->choice.setup)
9055       {
9056          /* Resource Set Cfg */
9057          if(cuPucchCfg->choice.setup->resourceSetToAddModList)
9058          {
9059             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrcSet, sizeof(PucchResrcSetCfg));
9060             if(macPucchCfg->resrcSet == NULLP)
9061             {
9062                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
9063                return RFAILED;
9064             }
9065             memset(macPucchCfg->resrcSet, 0, sizeof(PucchResrcSetCfg));
9066             extractResrcSetToAddModList(macPucchCfg->resrcSet, cuPucchCfg->choice.setup->resourceSetToAddModList);
9067          }
9068
9069          /* Resource Cfg */
9070          if(cuPucchCfg->choice.setup->resourceToAddModList)
9071          {
9072             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrc, sizeof(PucchResrcCfg));
9073             if(macPucchCfg->resrc == NULLP)
9074             {
9075                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
9076                return RFAILED;
9077             }
9078             memset(macPucchCfg->resrc, 0, sizeof(PucchResrcCfg));
9079             extractResrcToAddModList(macPucchCfg->resrc, cuPucchCfg->choice.setup->resourceToAddModList);
9080          }
9081
9082          /* Format 1 Cfg */
9083          if(cuPucchCfg->choice.setup->format1)
9084          {
9085             DU_ALLOC_SHRABL_BUF(macPucchCfg->format1, sizeof(PucchFormatCfg));
9086             if(macPucchCfg->format1 == NULLP)
9087             {
9088                DU_LOG("\nERROR --> F1AP : Failed to extract format 1 Cfg in  extractPucchCfg()");
9089                return RFAILED;
9090             }
9091             memset(macPucchCfg->format1, 0, sizeof(PucchFormatCfg));
9092             extractPucchFormatCfg(macPucchCfg->format1,\
9093                cuPucchCfg->choice.setup->format1->choice.setup);
9094          }
9095
9096          /* Format 2 Cfg */
9097          if(cuPucchCfg->choice.setup->format2)
9098          {
9099             DU_ALLOC_SHRABL_BUF(macPucchCfg->format2, sizeof(PucchFormatCfg));
9100             if(macPucchCfg->format2 == NULLP)
9101             {
9102                DU_LOG("\nERROR --> F1AP : Failed to extract format 2 Cfg in  extractPucchCfg()");
9103                return RFAILED;
9104             }
9105             memset(macPucchCfg->format2, 0, sizeof(PucchFormatCfg));
9106             extractPucchFormatCfg(macPucchCfg->format2,\
9107                cuPucchCfg->choice.setup->format2->choice.setup);
9108          }
9109
9110          /* Format 3 Cfg */
9111          if(cuPucchCfg->choice.setup->format3)
9112          {
9113             DU_ALLOC_SHRABL_BUF(macPucchCfg->format3, sizeof(PucchFormatCfg));
9114             if(macPucchCfg->format3 == NULLP)
9115             {
9116                DU_LOG("\nERROR --> F1AP : Failed to extract format 3 Cfg in  extractPucchCfg()");
9117                return RFAILED;
9118             }
9119             memset(macPucchCfg->format3, 0, sizeof(PucchFormatCfg));
9120             extractPucchFormatCfg(macPucchCfg->format3,\
9121                cuPucchCfg->choice.setup->format3->choice.setup);
9122          }
9123
9124          /* Format 4 Cfg */
9125          if(cuPucchCfg->choice.setup->format4)
9126          {
9127             DU_ALLOC_SHRABL_BUF(macPucchCfg->format4, sizeof(PucchFormatCfg));
9128             if(macPucchCfg->format4 == NULLP)
9129             {
9130                DU_LOG("\nERROR --> F1AP : Failed to extract format 4 Cfg in  extractPucchCfg()");
9131                return RFAILED;
9132             }
9133             memset(macPucchCfg->format4, 0, sizeof(PucchFormatCfg));
9134             extractPucchFormatCfg(macPucchCfg->format4,\
9135                cuPucchCfg->choice.setup->format4->choice.setup);
9136          }
9137
9138          /* Sched Req List */
9139          if(cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList)
9140          {
9141             DU_ALLOC_SHRABL_BUF(macPucchCfg->schedReq, sizeof(PucchSchedReqCfg));
9142             if(macPucchCfg->schedReq == NULLP)
9143             {
9144                DU_LOG("\nERROR --> F1AP : Failed to extract schedReqCfg in  extractPucchCfg()");
9145                return RFAILED;
9146             }
9147             memset(macPucchCfg->schedReq, 0, sizeof(PucchSchedReqCfg));
9148             extractSchedReqCfgToAddMod(macPucchCfg->schedReq,\
9149             cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList);
9150          }
9151
9152          /*TODO: Add support for  Spatial Info */
9153
9154          /* MultiCsiCfg */
9155          if(cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList)
9156          {
9157             DU_ALLOC_SHRABL_BUF(macPucchCfg->multiCsiCfg, sizeof(PucchMultiCsiCfg));
9158             if(macPucchCfg->multiCsiCfg == NULLP)
9159             {
9160                DU_LOG("\nERROR --> F1AP : Failed to extract multiCsiCfg in  extractPucchCfg()");
9161                return RFAILED;
9162             }
9163             memset(macPucchCfg->multiCsiCfg, 0, sizeof(PucchMultiCsiCfg));
9164             macPucchCfg->multiCsiCfg->multiCsiResrcListCount = cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.count;
9165             for(arrIdx =0; arrIdx < macPucchCfg->multiCsiCfg->multiCsiResrcListCount; arrIdx++)
9166             {
9167                macPucchCfg->multiCsiCfg->multiCsiResrcList[arrIdx] =\
9168                  *cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.array[arrIdx];
9169             }
9170          }
9171
9172          /* Dl_DataToUL_ACK */
9173          if(cuPucchCfg->choice.setup->dl_DataToUL_ACK)
9174     {
9175        if(storedPucchCfg)
9176        {
9177           if(storedPucchCfg->dlDataToUlAck)
9178           {
9179              macPucchCfg->dlDataToUlAck = storedPucchCfg->dlDataToUlAck;
9180           }
9181           else
9182           {
9183             DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
9184           }
9185        }
9186        else
9187        {
9188           DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
9189        }
9190        if(macPucchCfg->dlDataToUlAck == NULLP)
9191        {
9192           DU_LOG("\nERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
9193           return RFAILED;
9194        }
9195        memset(macPucchCfg->dlDataToUlAck, 0, sizeof(PucchDlDataToUlAck));
9196        macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount = cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.count;
9197        for(arrIdx = 0; arrIdx < macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount; arrIdx++)
9198        {
9199           macPucchCfg->dlDataToUlAck->dlDataToUlAckList[arrIdx] =\
9200           *cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.array[arrIdx];
9201        }
9202          }
9203
9204          /* Power Control */
9205          if(cuPucchCfg->choice.setup->pucch_PowerControl)
9206          {
9207             DU_ALLOC_SHRABL_BUF(macPucchCfg->powerControl, sizeof(PucchPowerControl));
9208             if(macPucchCfg->powerControl == NULLP)
9209             {
9210                DU_LOG("\nERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
9211                return RFAILED;
9212             }
9213             extractPucchPowerControl(macPucchCfg->powerControl,\
9214                cuPucchCfg->choice.setup->pucch_PowerControl);
9215          }
9216       }
9217    }
9218    return ROK;
9219 }
9220
9221 /*******************************************************************
9222  *
9223  * @brief Fills ServingCellReconfig received by CU
9224  *
9225  * @details
9226  *
9227  *    Function : extractSpCellDedicatedCfg
9228  *
9229  *    Functionality: Fills ServingCellReconfig received  by CU
9230  *
9231  * @params[in] ServingCellConfig_t *cuSrvCellCfg = Information which is send by
9232  *                  CU, which we have stored in F1UeContextSetupDb,
9233  *             ServCellCfgInfo *macSrvCellCfg = Used to Store the information
9234  *                  which  needs to send in other layer, as well as this can be the
9235  *                  variable which stores the information in DuCb,
9236  *             ServCellCfgInfo *storedSrvCellCfg = Null in case of sending the
9237  *                  information to other layer else it will have ServCellCfgInfo which
9238  *                  we have stored in copyOfmacUeCfg.
9239  * @return ROK/RFAILD
9240  *
9241  * ****************************************************************/
9242 uint8_t extractSpCellDedicatedCfg(ServingCellConfig_t *cuSrvCellCfg, ServCellCfgInfo *macSrvCellCfg,\
9243 ServCellCfgInfo *storedSrvCellCfg)
9244 {
9245    uint8_t ret = ROK;
9246    BWP_DownlinkDedicated_t *dlBwp = NULLP;
9247    BWP_UplinkDedicated_t   *ulBwp = NULLP;
9248
9249    if(cuSrvCellCfg->initialDownlinkBWP)
9250    {
9251       dlBwp = ((BWP_DownlinkDedicated_t *)(cuSrvCellCfg->initialDownlinkBWP));
9252       if(dlBwp->pdcch_Config)
9253       {
9254          if(dlBwp->pdcch_Config->choice.setup)
9255          {
9256             macSrvCellCfg->initDlBwp.pdcchPresent = true;
9257             if(storedSrvCellCfg)
9258             {
9259                if(!storedSrvCellCfg->initDlBwp.pdcchPresent)
9260                {
9261                   extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
9262                }
9263                else
9264                {
9265                   extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
9266                }
9267             }
9268             else
9269             {
9270                extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
9271             }
9272          }
9273       }
9274       if(dlBwp->pdsch_Config)
9275       {
9276          if(dlBwp->pdsch_Config->choice.setup)
9277          {
9278             macSrvCellCfg->initDlBwp.pdschPresent = true;
9279
9280             if(storedSrvCellCfg)
9281             {
9282                if(!storedSrvCellCfg->initDlBwp.pdschPresent)
9283                {
9284                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
9285                }
9286                else
9287                {
9288                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg,\
9289                         &storedSrvCellCfg->initDlBwp.pdschCfg);
9290                }
9291             }
9292             else
9293             {
9294                extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
9295             }
9296          }
9297       }
9298    }
9299    if(cuSrvCellCfg->firstActiveDownlinkBWP_Id)
9300       macSrvCellCfg->firstActvDlBwpId = *(cuSrvCellCfg->firstActiveDownlinkBWP_Id);
9301    if(cuSrvCellCfg->defaultDownlinkBWP_Id)
9302       macSrvCellCfg->defaultDlBwpId = *(cuSrvCellCfg->defaultDownlinkBWP_Id);
9303    if(cuSrvCellCfg->bwp_InactivityTimer)
9304    {
9305       if(macSrvCellCfg->bwpInactivityTmr)
9306       {
9307          memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
9308       }
9309       else
9310       {
9311          macSrvCellCfg->bwpInactivityTmr = NULLP;
9312          DU_ALLOC_SHRABL_BUF(macSrvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
9313          if(macSrvCellCfg->bwpInactivityTmr)
9314          {
9315             memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
9316          }
9317          else
9318          {
9319             DU_LOG("\nERROR  --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
9320             return RFAILED;
9321          }
9322       }
9323    }
9324    if(cuSrvCellCfg->pdsch_ServingCellConfig)
9325    {
9326       if(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup)
9327       {
9328          ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
9329          if(ret == RFAILED)
9330          {
9331             DU_LOG("\nERROR --> F1AP : Failed at extractPdschServingCellCfg()");
9332             return RFAILED;
9333          }
9334       }
9335    }
9336    if(cuSrvCellCfg->uplinkConfig)
9337    {
9338       if(cuSrvCellCfg->uplinkConfig->initialUplinkBWP)
9339       {
9340          ulBwp = ((BWP_UplinkDedicated_t *)(cuSrvCellCfg->uplinkConfig->initialUplinkBWP));
9341          if(ulBwp->pusch_Config)
9342          {
9343             macSrvCellCfg->initUlBwp.puschPresent = true;
9344             extractPuschCfg(ulBwp->pusch_Config, &macSrvCellCfg->initUlBwp.puschCfg);
9345          }
9346          if(ulBwp->pucch_Config)
9347          {
9348             macSrvCellCfg->initUlBwp.pucchPresent = true;
9349             memset(&macSrvCellCfg->initUlBwp.pucchCfg, 0, sizeof(PucchCfg));
9350             if(storedSrvCellCfg)
9351             {
9352                if(!storedSrvCellCfg->initUlBwp.pucchPresent)
9353                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
9354                else
9355                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg,\
9356                   &storedSrvCellCfg->initUlBwp.pucchCfg);
9357             }
9358             else
9359             {
9360                extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
9361             }
9362          }
9363       }
9364       if(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id)
9365          macSrvCellCfg->firstActvUlBwpId = *(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id);
9366    }
9367    return ret;
9368 }
9369 /*******************************************************************
9370  *
9371  * @brief Fills Reconfig Cell group Info received by CU
9372  *
9373  * @details
9374  *
9375  *    Function : extractUeReCfgCellInfo
9376  *
9377  *    Functionality: Fills Reconfig Cell group Info received by CU
9378  *
9379  * @params[in] CellGroupConfigRrc_t *cellGrp = CellGroupConfigRrc_t information which
9380  *                       is send by CU, which we have stored in F1UeContextSetupDb
9381  *             MacUeCfg *MacUeCfg = Used to Store the information,
9382  *                      which needs to send in other layer, as well as this can be
9383  *                      the variable which stores the information in DuCb,
9384  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
9385  *                      information to other layer else it will have copyOfmacUeCfg
9386  *                      which we have stored in F1UeContextSetupDb.
9387  *
9388  * @return ROK/RFAILED
9389  *
9390  * ****************************************************************/
9391 uint8_t extractUeReCfgCellInfo(CellGroupConfigRrc_t *cellGrp, MacUeCfg *macUeCfg, MacUeCfg *storedMacUeCfg)
9392 {
9393    uint8_t ret = ROK;
9394    MAC_CellGroupConfig_t     *macCellGroup = NULLP;
9395    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
9396    SpCellConfig_t            *spcellCfg = NULLP;
9397    ServingCellConfig_t       *servCellCfg = NULLP;
9398
9399    if(cellGrp)
9400    {
9401       /* Fill MacCell Group Reconfig  */
9402       if(cellGrp->mac_CellGroupConfig)
9403       {
9404          macUeCfg->macCellGrpCfgPres = true;
9405          macCellGroup = ((MAC_CellGroupConfig_t *)(cellGrp->mac_CellGroupConfig));
9406          if(macCellGroup->schedulingRequestConfig)
9407          {
9408             extractSchReqReConfig(macCellGroup->schedulingRequestConfig, &macUeCfg->macCellGrpCfg.schReqCfg);
9409          }
9410          if(macCellGroup->tag_Config)
9411          {
9412             extractTagReconfig(macCellGroup->tag_Config, &macUeCfg->macCellGrpCfg.tagCfg);
9413          }
9414          if(macCellGroup->bsr_Config)
9415          {
9416             macUeCfg->macCellGrpCfg.bsrTmrCfg.periodicTimer = macCellGroup->bsr_Config->periodicBSR_Timer;
9417             macUeCfg->macCellGrpCfg.bsrTmrCfg.retxTimer     = macCellGroup->bsr_Config->retxBSR_Timer;
9418             if(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer)
9419             {
9420                macUeCfg->macCellGrpCfg.bsrTmrCfg.srDelayTimer  =\
9421                *(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer);
9422             }
9423          }
9424          if(macCellGroup->phr_Config)
9425          {
9426             if(macCellGroup->phr_Config->present == MAC_CellGroupConfig__phr_Config_PR_setup)
9427             {
9428                macUeCfg->macCellGrpCfg.phrCfgSetupPres = true;
9429                if(macCellGroup->phr_Config->choice.setup)
9430                {
9431                   macUeCfg->macCellGrpCfg.phrCfg.periodicTimer     = \
9432                   macCellGroup->phr_Config->choice.setup->phr_PeriodicTimer;
9433                   macUeCfg->macCellGrpCfg.phrCfg.prohibitTimer     = \
9434                   macCellGroup->phr_Config->choice.setup->phr_ProhibitTimer;
9435                   macUeCfg->macCellGrpCfg.phrCfg.txPowerFactor     = \
9436                   macCellGroup->phr_Config->choice.setup->phr_Tx_PowerFactorChange;
9437                   macUeCfg->macCellGrpCfg.phrCfg.multiplePHR       = \
9438                   macCellGroup->phr_Config->choice.setup->multiplePHR;
9439                   macUeCfg->macCellGrpCfg.phrCfg.dummy             = \
9440                   macCellGroup->phr_Config->choice.setup->dummy;
9441                   macUeCfg->macCellGrpCfg.phrCfg.phrType2OtherCell = \
9442                   macCellGroup->phr_Config->choice.setup->phr_Type2OtherCell;
9443                   macUeCfg->macCellGrpCfg.phrCfg.phrOtherCG        = \
9444                   macCellGroup->phr_Config->choice.setup->phr_ModeOtherCG;
9445                }
9446             }
9447          }
9448       }
9449       /* Fill Physical Cell Group Reconfig */
9450       if(cellGrp->physicalCellGroupConfig)
9451       {
9452          macUeCfg->phyCellGrpCfgPres = true;
9453          phyCellGrpCfg = ((PhysicalCellGroupConfig_t *)(cellGrp->physicalCellGroupConfig));
9454          if(phyCellGrpCfg->p_NR_FR1)
9455          {
9456             if(*(phyCellGrpCfg->p_NR_FR1) != macUeCfg->phyCellGrpCfg.pNrFr1)
9457                macUeCfg->phyCellGrpCfg.pNrFr1 = *(phyCellGrpCfg->p_NR_FR1);
9458          }
9459          macUeCfg->phyCellGrpCfg.pdschHarqAckCodebook = phyCellGrpCfg->pdsch_HARQ_ACK_Codebook;
9460       }
9461       /* Fill SpCell Reconfig */
9462       if(cellGrp->spCellConfig)
9463       {
9464          macUeCfg->spCellCfgPres = true;
9465          spcellCfg = ((SpCellConfig_t *)(cellGrp->spCellConfig));
9466          if(spcellCfg->servCellIndex)
9467          {
9468             macUeCfg->spCellCfg.servCellIdx = *(spcellCfg->servCellIndex);
9469          }
9470          /* Fill Serving cell Reconfig info */
9471          if(cellGrp->spCellConfig->spCellConfigDedicated)
9472          {
9473             servCellCfg = ((ServingCellConfig_t *)(cellGrp->spCellConfig->spCellConfigDedicated));
9474             if(storedMacUeCfg)
9475             {
9476                if(!storedMacUeCfg->spCellCfgPres)
9477                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
9478                else
9479                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg,\
9480                         &storedMacUeCfg->spCellCfg.servCellCfg);
9481             }
9482             else
9483             {
9484                ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
9485             }
9486             if(ret == RFAILED)
9487             {
9488                DU_LOG("\nERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
9489             }
9490          }
9491       }
9492    }
9493    return ret;
9494 }
9495 /*******************************************************************
9496 *
9497 * @brief free the memory allocated by decoder
9498 *
9499 * @details
9500 *
9501 *    Function : freeAperDecodeNrcgi
9502 *
9503 *    Functionality: Free Nrcgi values
9504 *
9505 * @params[in] NRCGI_t *nrcgi
9506 * @return void
9507 *
9508 * ****************************************************************/
9509
9510
9511 void freeAperDecodeNrcgi(NRCGI_t *nrcgi)
9512 {
9513     if(nrcgi->pLMN_Identity.buf != NULLP)
9514     {
9515        free(nrcgi->pLMN_Identity.buf);
9516     }
9517     if(nrcgi->nRCellIdentity.buf != NULLP)
9518     {
9519        free(nrcgi->nRCellIdentity.buf);
9520     }
9521 }
9522 /*******************************************************************
9523 *
9524 * @brief free the memory allocated by decoder
9525 *
9526 * @details
9527 *
9528 *    Function : freeAperDecodeCuToDuInfo
9529 *
9530 *    Functionality:  Free Cu To Du Information
9531 *
9532 * @params[in] CUtoDURRCInformation_t *rrcMsg
9533 * @return void
9534 *
9535 * ****************************************************************/
9536
9537
9538 void freeAperDecodeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
9539 {
9540    uint8_t ieIdx =0;
9541    uint8_t arrIdx =0;
9542
9543    if(rrcMsg->uE_CapabilityRAT_ContainerList)
9544    {
9545       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
9546          free(rrcMsg->uE_CapabilityRAT_ContainerList->buf);
9547       free(rrcMsg->uE_CapabilityRAT_ContainerList);
9548    }
9549
9550    if(rrcMsg->iE_Extensions)
9551    {
9552       if(rrcMsg->iE_Extensions->list.array)
9553       {
9554          for(ieIdx= 0; ieIdx < rrcMsg->iE_Extensions->list.count; ieIdx++)
9555          {
9556             if(rrcMsg->iE_Extensions->list.array[ieIdx])
9557             {
9558                switch(rrcMsg->iE_Extensions->list.array[ieIdx]->id)
9559                {
9560                   case ProtocolIE_ID_id_CellGroupConfig:
9561                      if(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
9562                      {
9563                         free(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf);
9564                      }
9565                      break;
9566                   default:
9567                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
9568                            rrcMsg->iE_Extensions->list.array[ieIdx]->id);
9569                      break;
9570                }
9571             }
9572          }
9573          for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
9574          {
9575             free(rrcMsg->iE_Extensions->list.array[arrIdx]);
9576          }
9577          free(rrcMsg->iE_Extensions->list.array);
9578
9579       }
9580
9581       free(rrcMsg->iE_Extensions);
9582    }
9583 }
9584 /*******************************************************************
9585 *
9586 * @brief free the memory allocated by decoder
9587 *
9588 * @details
9589 *
9590 *    Function : freeAperDecodeSplCellList
9591 *
9592 *    Functionality: Free Spl Cell List
9593                     where memory allocated by aper_decoder
9594 *
9595 * @params[in]  SCell_ToBeSetup_List_t *spCellLst
9596 * @return void
9597 *
9598 * ****************************************************************/
9599
9600
9601 void freeAperDecodeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
9602 {
9603     uint8_t  cellIdx =0;
9604
9605     if(spCellLst->list.array != NULLP)
9606     {
9607        for(cellIdx=0; cellIdx<spCellLst->list.count; cellIdx++)
9608        {
9609           if(cellIdx==0&&spCellLst->list.array[cellIdx]!=NULLP)
9610           {
9611              freeAperDecodeNrcgi(&spCellLst->list.array[cellIdx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
9612           }
9613           if(spCellLst->list.array[cellIdx]!=NULLP)
9614           {
9615              free(spCellLst->list.array[cellIdx]);
9616           }
9617        }
9618        free(spCellLst->list.array);
9619     }
9620 }
9621 /*******************************************************************
9622 *
9623 * @brief free the memory allocated by decoder
9624 *
9625 * @details
9626 *
9627 *    Function : freeAperDecodeSRBSetup
9628 *
9629 *    Functionality: added free part for the memory allocated by aper_decoder
9630 *
9631 * @params[in] SRBs_ToBeSetup_List_t *srbSet
9632 * @return void
9633 *
9634 ****************************************************************/
9635
9636
9637 void freeAperDecodeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
9638 {
9639     uint8_t srbIdx =0;
9640     if(srbSet->list.array != NULLP)
9641     {
9642        for(srbIdx=0; srbIdx<srbSet->list.count; srbIdx++)
9643        {
9644           if(srbSet->list.array[srbIdx]!=NULLP)
9645           {
9646              free(srbSet->list.array[srbIdx]);
9647           }
9648        }
9649        free(srbSet->list.array);
9650     }
9651 }
9652
9653 /*******************************************************************
9654 *
9655 * @brief free the memory allocated by decoder
9656 *
9657 * @details
9658 *
9659 *    Function : freeAperDecodeULTnlInfo
9660 *
9661 *    Functionality: added free part for the memory allocated by aper_decoder
9662 *
9663 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
9664 * @return void
9665 *
9666 * ****************************************************************/
9667
9668
9669 void freeAperDecodeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
9670 {
9671    uint8_t ulIdx=0;
9672    if(ulInfo->list.array != NULLP)
9673    {
9674       for(ulIdx=0; ulIdx<ulInfo->list.count; ulIdx++)
9675       {
9676          if(ulIdx==0&&ulInfo->list.array[ulIdx]!=NULLP)
9677          {
9678             if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
9679             {
9680                if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9681                      transportLayerAddress.buf != NULLP)
9682                {
9683                   if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
9684                         !=NULLP)
9685                   {
9686                      free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf);
9687                   }
9688                   free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9689                         transportLayerAddress.buf);
9690                }
9691                free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel);
9692             }
9693          }
9694          if(ulInfo->list.array[ulIdx]!=NULLP)
9695          {
9696             free(ulInfo->list.array[ulIdx]);
9697          }
9698       }
9699       free(ulInfo->list.array);
9700    }
9701 }
9702 /*******************************************************************
9703 *
9704 * @brief free the memory allocated by decoder
9705 *
9706 * @details
9707 *
9708 *    Function : freeAperDecodeDRBSetup
9709 *
9710 *    Functionality: free DRBSetup which is allocated by decoder
9711 *
9712 * @params[in]  DRBs_ToBeSetup_List_t *drbSet
9713 * @return void
9714 *
9715 * ****************************************************************/
9716
9717 void freeAperDecodeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
9718 {
9719    DRBs_ToBeSetup_Item_t *drbSetItem = NULLP;
9720    uint8_t  flowIdx =0;
9721    uint8_t  drbIdx =0;
9722
9723    if(drbSet->list.array != NULLP)
9724    {
9725       for(drbIdx=0; drbIdx<drbSet->list.count; drbIdx++)
9726       {
9727          if(drbIdx==0&&drbSet->list.array[drbIdx] != NULLP)
9728          {
9729             drbSetItem =&drbSet->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
9730             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
9731             {
9732                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9733                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
9734                {
9735                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9736                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9737                   {
9738                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9739                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9740                      {
9741
9742                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
9743                         {
9744
9745                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
9746                            {
9747
9748                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->\
9749                                     buf!=NULLP)
9750                               {
9751
9752                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
9753                                        flows_Mapped_To_DRB_List.list.array != NULLP)
9754                                  {
9755
9756                                     for(flowIdx=0;flowIdx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9757                                           DRB_Information.flows_Mapped_To_DRB_List.list.count; flowIdx++)
9758                                     {
9759
9760                                        if(flowIdx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9761                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9762                                        {
9763                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9764                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9765                                                 qoSFlowLevelQoSParameters.\
9766                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
9767                                           {
9768                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9769                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9770                                                    qoSFlowLevelQoSParameters.\
9771                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9772                                              {
9773
9774                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9775                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9776                                                       qoSFlowLevelQoSParameters.\
9777                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9778                                                 {
9779
9780
9781                                                    free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9782                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9783                                                          qoSFlowLevelQoSParameters.\
9784                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9785                                                 }
9786
9787                                                 free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9788                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9789                                                       qoSFlowLevelQoSParameters.\
9790                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9791                                              }
9792
9793                                              free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9794
9795                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9796                                                    qoSFlowLevelQoSParameters.\
9797                                                    qoS_Characteristics.choice.non_Dynamic_5QI);
9798                                           }
9799                                        }
9800                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9801                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9802                                        {
9803
9804                                           free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9805                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]);
9806                                        }
9807                                     }
9808
9809                                     free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9810                                           DRB_Information.flows_Mapped_To_DRB_List.list.array);
9811                                  }
9812
9813                                  free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9814                                        DRB_Information.sNSSAI.sD->buf);
9815                               }
9816
9817                               free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD);
9818                            }
9819
9820                            free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf);
9821
9822                         }
9823
9824                         free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9825
9826                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9827                      }
9828
9829                      free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9830                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9831                   }
9832
9833                   free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9834                         qoS_Characteristics.choice.non_Dynamic_5QI);
9835                }
9836                free(drbSetItem->qoSInformation.choice.choice_extension);
9837             }
9838             freeAperDecodeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
9839             if(drbSetItem->uLConfiguration)
9840             {
9841                free(drbSetItem->uLConfiguration);
9842             }
9843          }
9844          if(drbSet->list.array[drbIdx]!=NULLP)
9845          {
9846             free(drbSet->list.array[drbIdx]);
9847          }
9848       }
9849       free(drbSet->list.array);
9850    }
9851 }
9852
9853
9854 /*******************************************************************
9855  *
9856  * @brief builds Mac Cell Cfg
9857  *
9858  * @details
9859  *
9860  *    Function : procUeReCfgCellInfo
9861  *
9862  *    Functionality: builds Mac Cell Cfg
9863  *
9864  * @params[in] MacUeCfg *macUeCfgToSend = Used to Store the information which
9865  *                       needs to send in other layer, as well as this can be
9866  *                       the variable which stores the information in DuCb.
9867  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
9868  *                       information to other layer else it will have copyOfmacUeCfg
9869  *                       which we have stored in F1UeContextSetupDb
9870  *             void *cellInfo = CellGroupConfigRrc_t information which is send
9871  *                        by CU, which we have stored in F1UeContextSetupDb
9872  *
9873  * @return void
9874  *
9875  * ****************************************************************/
9876 uint8_t procUeReCfgCellInfo(MacUeCfg *macUeCfgToSend,MacUeCfg *storedMacUeCfg, void *cellInfo)
9877 {
9878    uint8_t ret = ROK;
9879    CellGroupConfigRrc_t *cellGrp = NULLP;
9880
9881    if(cellInfo)
9882    {
9883       cellGrp = (CellGroupConfigRrc_t *)cellInfo;
9884       ret = extractUeReCfgCellInfo(cellGrp, macUeCfgToSend, storedMacUeCfg);
9885       if(ret == RFAILED)
9886          DU_LOG("\nERROR  -->  F1AP : Failed at procUeReCfgCellInfo()");
9887    }
9888    if(ret == RFAILED)
9889    {
9890       freeUeReCfgCellGrpInfo(macUeCfgToSend);
9891    }
9892    return ret;
9893 }
9894
9895 /*******************************************************************
9896  *
9897  * @brief Filling modulation info in mac ue cfg
9898  *
9899  * @details
9900  *
9901  *    Function : duFillModulationDetails
9902  *
9903  *    Functionality: Filling modulation info in mac ue cfg
9904  *
9905  * @params[in] MAC UE Config to be updated
9906  *             Current UE configuration
9907  *             UE NR capability from CU
9908  * @return ROK     - success
9909  *         RFAILED - failure
9910  *
9911  * ****************************************************************/
9912 void duFillModulationDetails(MacUeCfg *ueCfg, MacUeCfg *oldUeCfg, void *ueCap)
9913 {
9914    UE_NR_Capability_t *ueNrCap=NULLP;
9915
9916    if(!ueCap)
9917    {
9918       memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9919       memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9920    }
9921    else
9922    {
9923       ueNrCap = (UE_NR_Capability_t *)ueCap;
9924
9925       /* Filling DL modulation info */
9926       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsDownlinkPerCC && \
9927          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0] && \
9928          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL)
9929       {
9930          switch(*(ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL))
9931          {
9932             case ModulationOrder_qpsk:
9933                {
9934                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
9935                   break;
9936                }
9937             case ModulationOrder_qam16:
9938                {
9939                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM16;
9940                   break;
9941                }
9942             case ModulationOrder_qam64:
9943                {
9944                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM64;
9945                   ueCfg->dlModInfo.mcsIndex = PDSCH_MCS_INDEX;
9946                   ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64;
9947                   break;
9948                }
9949             case ModulationOrder_qam256:
9950                {
9951                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM256;
9952                   break;
9953                }
9954             default:
9955                {
9956                   DU_LOG("\nERROR  -->  DU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
9957                   memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9958                   break;
9959                }
9960          }
9961       }
9962       else
9963       {
9964          memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9965       }
9966
9967       /* Filling UL modulation info */
9968       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsUplinkPerCC && \
9969          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0] && \
9970          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL)
9971       {
9972          switch(*(ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL))
9973          {
9974             case ModulationOrder_qpsk:
9975                {
9976                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
9977                   break;
9978                }
9979             case ModulationOrder_qam16:
9980                {
9981                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM16;
9982                   ueCfg->ulModInfo.mcsIndex = PUSCH_MCS_INDEX;
9983                   ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64;
9984                   break;
9985                }
9986             case ModulationOrder_qam64:
9987                {
9988                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM64;
9989                   break;
9990                }
9991             case ModulationOrder_qam256:
9992                {
9993                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM256;
9994                   break;
9995                }
9996             default:
9997                {
9998                   DU_LOG("\nERROR  -->  DU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
9999                   memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
10000                   break;
10001                }
10002          }
10003       }
10004       else
10005       {
10006          memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
10007       }
10008    }
10009 }
10010
10011 /*******************************************************************
10012  *
10013  * @brief Function to extract cellGrp Info present in cutoDu cont
10014  *
10015  * @details
10016  *
10017  *    Function : extractCellGrpInfo
10018  *
10019  *    Functionality: Function to extract cellGrp Info present
10020  *                   in cutoDu cont
10021  *
10022  * @params[in] ProtocolExtensionContainer_4624P16_t pointer
10023  *
10024  * @return CellGroupConfigRrc_t *
10025  *
10026  * ****************************************************************/
10027
10028 CellGroupConfigRrc_t *extractCellGrpInfo(ProtocolExtensionContainer_4624P16_t *protocolIeExtn,\
10029       DuUeCfg *ueCfgDb)
10030 {
10031    uint8_t idx2 =0;
10032    uint16_t id =0;
10033    uint16_t recvBufLen =0;
10034    CellGroupConfigRrc_t *cellGrpCfg = NULLP;
10035    CUtoDURRCInformation_ExtIEs_t *extIeInfo = NULLP;
10036    asn_dec_rval_t rval; /* Decoder return value */
10037    memset(&rval, 0, sizeof(asn_dec_rval_t));
10038
10039    if(protocolIeExtn)
10040    {
10041       for(idx2 = 0; idx2 < protocolIeExtn->list.count; idx2++)
10042       {
10043          extIeInfo = ((CUtoDURRCInformation_ExtIEs_t *)(protocolIeExtn->list.array[idx2]));
10044          id = extIeInfo->id;
10045          switch(id)
10046          {
10047             case ProtocolIE_ID_id_CellGroupConfig:
10048             {
10049                recvBufLen = extIeInfo->extensionValue.choice.CellGroupConfig.size;
10050                /* decoding the CellGroup Buf received */
10051                DU_ALLOC(cellGrpCfg, sizeof(CellGroupConfigRrc_t));
10052                if(cellGrpCfg)
10053                {
10054                   memset(cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
10055                   rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfg,
10056                      extIeInfo->extensionValue.choice.CellGroupConfig.buf, recvBufLen, 0, 0);
10057                   if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10058                   {
10059                      DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
10060                      return NULLP;
10061                   }
10062                   xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfg);
10063                   if(extractRlcCfgToAddMod(cellGrpCfg->rlc_BearerToAddModList, ueCfgDb))
10064                      return NULLP;
10065                }
10066                break;
10067             }
10068             default:
10069                DU_LOG("\nERROR  -->  F1AP : Invalid IE received CUtoDURRCInformation:%d at decodeCellGrpCfg()", id);
10070                break;
10071          }
10072       }
10073    }
10074    return cellGrpCfg;
10075 }
10076
10077 /*******************************************************************
10078  *
10079  * @brief Fills Srb List received by CU
10080  *
10081  * @details
10082  *
10083  *    Function : procSrbListToSetup
10084  *
10085  *    Functionality: Fills Srb List received  by CU
10086  *
10087  * @params[in] SRBs_ToBeSetup_Item_t *cuSrbItem
10088  *             LcCfg pointer
10089  *             RlcBearerCfg pointer
10090  * @return void
10091  *
10092  * ****************************************************************/
10093 uint8_t procSrbListToSetup(SRBs_ToBeSetup_Item_t * srbItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd)
10094 {
10095
10096    /* Filling RLC INFO */
10097    procRlcLcCfg(srbItem->sRBID, srbItem->sRBID, RB_TYPE_SRB, RLC_AM, CONFIG_ADD, NULL, rlcLcToAdd, NULL);
10098
10099    /* Filling MAC INFO */
10100    if(procMacLcCfg(srbItem->sRBID, RB_TYPE_SRB, CONFIG_ADD, NULL,NULL, NULL, NULL, macLcToAdd, NULL)  != ROK)
10101    {
10102       DU_LOG("\nERROR  -->  F1AP : Failed at MAC LC Cfg in procSrbListToSetup()");
10103       return RFAILED;
10104    }
10105
10106    return ROK;
10107 }
10108
10109
10110
10111 /*******************************************************************
10112  *
10113  * @brief extract Srb List received by CU
10114  *
10115  * @details
10116  *
10117  *    Function : extractSrbListToSetup
10118  *
10119  *    Functionality: extract Srb List received by CU
10120  *                   for both MAC and RLC
10121  *
10122  * @params[in] SRBs_ToBeSetup_Item_t pointer
10123  *             DuUeCfg pointer
10124  * @return ROK/RFAIED
10125  *
10126  * ****************************************************************/
10127
10128 uint8_t extractSrbListToSetup(SRBs_ToBeSetup_List_t *srbCfg, DuUeCfg *ueCfgDb)
10129 {
10130    uint8_t ret, srbIdx;
10131    SRBs_ToBeSetup_Item_t *srbItem = NULLP;
10132
10133    if(srbCfg)
10134    {
10135       for(srbIdx = 0; srbIdx < srbCfg->list.count; srbIdx++)
10136       {
10137          srbItem = &srbCfg->list.array[srbIdx]->value.choice.SRBs_ToBeSetup_Item;
10138          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
10139          {
10140             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in MAC");
10141             ret = RFAILED;
10142             break;
10143          }
10144          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
10145          {
10146             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in RLC");
10147             ret = RFAILED;
10148             break;
10149          }
10150          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
10151          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
10152          ret = procSrbListToSetup(srbItem, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
10153             &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs]);
10154          ueCfgDb->numRlcLcs++;
10155          ueCfgDb->numMacLcs++;
10156          DU_LOG("\nDEBUG --> DUAPP: extractSrbListToSetup: SRBID: %d [RLC,MAC,NumDrb]:[%x,%x,%x]",\
10157                             srbItem->sRBID, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
10158          if(ret == RFAILED)
10159          {
10160             DU_LOG("\nERROR  -->  F1AP:  Failed at extractSrbListToSetup()");
10161             break;
10162          }
10163       }
10164    }
10165    else
10166       ret = RFAILED;
10167
10168    return ret;
10169 }
10170
10171 /*******************************************************************
10172  *
10173  * @brief Fills Drb List received by CU
10174  *
10175  * @details
10176  *
10177  *    Function : procDrbListToSetupMod
10178  *
10179  *    Functionality: Fills Drb List received by CU
10180  *                   for both MAC and RLC
10181  *
10182  * @params[in] DRBs_ToBeSetup_Item_t , DRBs_ToBeSetupMod_Item_t,
10183  *             DRBs_ToBeModified_Item_t , lcId, LcCfg pointer,
10184  *             RlcBearerCfg , UpTnlCfg, RlcUeCfg
10185  * @return void
10186  *
10187  * ****************************************************************/
10188
10189 uint8_t procDrbListToSetupMod(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbItem,\
10190 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd, UpTnlCfg *upTnlInfo, RlcUeCfg *storedRlcUeCfg)
10191 {
10192    uint8_t cfgIdx = 0;
10193    RlcMode rlcModeInfo;
10194
10195    if(drbItem != NULLP)
10196    {
10197       /* Filling RLC INFO */
10198       procRlcLcCfg(drbItem->dRBID, lcId, RB_TYPE_DRB, drbItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd, &drbItem->\
10199       qoSInformation);
10200
10201       /* Filling MAC INFO */
10202       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, drbItem, NULL, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
10203       {
10204          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
10205          return RFAILED;
10206       }
10207    }
10208    else if(drbSetupModItem != NULLP)
10209    {
10210       procRlcLcCfg(drbSetupModItem->dRBID, lcId, RB_TYPE_DRB, drbSetupModItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd,
10211       &drbSetupModItem->qoSInformation);
10212
10213       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, NULL, drbSetupModItem, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
10214       {
10215          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
10216          return RFAILED;
10217       }
10218    }
10219    else if(drbModItem != NULLP)
10220    {
10221       /* Drb to Mod IEs doesnot have rlcMode to be modified
10222        * in ASN. Hence no change in RLC configurations */
10223       if(storedRlcUeCfg != NULLP)
10224       {
10225          for(cfgIdx = 0; cfgIdx < storedRlcUeCfg->numLcs; cfgIdx++)
10226          {
10227             if(storedRlcUeCfg->rlcLcCfg[cfgIdx].lcId == lcId)
10228             {
10229                rlcModeInfo = storedRlcUeCfg->rlcLcCfg[cfgIdx].rlcMode;
10230                break;
10231             }
10232          }
10233       }
10234
10235       procRlcLcCfg(drbModItem->dRBID, lcId, RB_TYPE_DRB, rlcModeInfo, CONFIG_MOD, NULL, rlcLcToAdd, drbModItem->qoSInformation);
10236       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_MOD, NULL, NULL, drbModItem, NULL, macLcToAdd, upTnlInfo) != ROK)
10237       {
10238          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
10239          return RFAILED;
10240       }
10241    }
10242    return ROK;
10243 }
10244
10245 /*******************************************************************
10246  *
10247  * @brief extract Drb List received by CU
10248  *
10249  * @details
10250  *
10251  *    Function : extractDrbListToSetupMod
10252  *
10253  *    Functionality: extract Drb List received by CU
10254  *                   for both MAC and RLC
10255  *
10256  * @params[in] DRBs_ToBeSetup_Item_t pointer
10257  *             DuUeCfg pointer
10258  * @return ROK/RFAIED
10259  *
10260  * ****************************************************************/
10261
10262 uint8_t extractDrbListToSetupMod(DRBs_ToBeSetup_List_t *drbCfg, DRBs_ToBeSetupMod_List_t *drbSetupModCfg,\
10263  DRBs_ToBeModified_List_t *drbModCfg, uint8_t drbCount, DuUeCfg *ueCfgDb, uint32_t *drbBitMap, RlcUeCfg *rlcUeCfg)
10264 {
10265    uint8_t ret, drbIdx, lcId = 0;
10266    DRBs_ToBeSetup_Item_t *drbItem = NULLP;
10267    DRBs_ToBeSetupMod_ItemIEs_t *drbSetupModItem = NULLP;
10268    DRBs_ToBeModified_ItemIEs_t *drbModItem = NULLP;
10269
10270    ret = ROK;
10271    if(drbCount > 0)
10272    {
10273       for(drbIdx = 0; drbIdx < drbCount; drbIdx++)
10274       {
10275          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
10276          {
10277             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in MAC at extractDrbListToSetupMod()");
10278             ret = RFAILED;
10279             break;
10280          }
10281          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
10282          {
10283             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in RLC at extractDrbListToSetupMod()");
10284             ret = RFAILED;
10285             break;
10286          }
10287          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
10288          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
10289
10290          if(drbModCfg != NULLP)
10291          {
10292             drbModItem = (DRBs_ToBeModified_ItemIEs_t *) drbModCfg->list.array[drbIdx];
10293             lcId = fetchLcId(drbModItem->value.choice.DRBs_ToBeModified_Item.dRBID);
10294             if(lcId < MIN_DRB_LCID)
10295             {
10296                DU_LOG("\nERROR  --> F1AP : Failed fetching LCID %d in extractDrbListToSetupMod() for Modified List", lcId);
10297                break;
10298             }
10299             ret = procDrbListToSetupMod(lcId, NULL, NULL, &(drbModItem->value.choice.DRBs_ToBeModified_Item),\
10300             &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs],\
10301             &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
10302             if(ret == RFAILED)
10303             {
10304                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for Modified List");
10305                break;
10306             }
10307
10308          }
10309          else
10310          {
10311             lcId = getDrbLcId(drbBitMap);
10312             if(lcId == RFAILED)
10313             {
10314                DU_LOG("\nERROR  -->  F1AP :  InCorrect LCID extractDrbListToSetupMod()");
10315                ret = RFAILED;
10316                break;
10317             }
10318             if(drbCfg != NULL)
10319             {
10320                drbItem = &drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
10321                ret = procDrbListToSetupMod(lcId, drbItem, NULL, NULL, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
10322                      &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
10323                if(ret == RFAILED)
10324                {
10325                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetup List");
10326                   break;
10327                }
10328             }
10329             else if(drbSetupModCfg != NULL)
10330             {
10331                drbSetupModItem = (DRBs_ToBeSetupMod_ItemIEs_t *) drbSetupModCfg->list.array[drbIdx];
10332                ret = procDrbListToSetupMod(lcId, NULL, &(drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item), NULL,\
10333                      &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs],\
10334                      &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
10335                if(ret == RFAILED)
10336                {
10337                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetupMod List");
10338                   break;
10339                }
10340             }
10341          }
10342          ueCfgDb->numRlcLcs++;
10343          ueCfgDb->numMacLcs++;
10344          ueCfgDb->numDrb++;
10345
10346          DU_LOG("\nDEBUG --> DUAPP: extractDrbListToSetupMod:lcId:%x ,BitMap:%x, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
10347                             lcId,*drbBitMap, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
10348          if(ret == RFAILED)
10349          {
10350             DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod()");
10351             break;
10352          }
10353       }
10354    }
10355    else
10356       ret = RFAILED;
10357
10358    return ret;
10359 }
10360
10361 /*******************************************************************
10362  *
10363  * @brief Function to extract Dl RRC Msg received from CU
10364  *
10365  * @details
10366  *
10367  *    Function : extractDlRrcMsg
10368  *
10369  *    Functionality: Function to extract Dl RRC Msg received from CU
10370  *
10371  * @params[in] F1AP message
10372  * @return ROK     - success
10373  *         RFAILED - failure
10374  *
10375  * ****************************************************************/
10376
10377 uint8_t extractDlRrcMsg(uint32_t gnbDuUeF1apId, uint32_t gnbCuUeF1apId, \
10378    F1DlRrcMsg *dlRrcMsg, RRCContainer_t *rrcContainer)
10379 {
10380    uint8_t ret = ROK;
10381    dlRrcMsg->rrcMsgSize = rrcContainer->size;
10382    if(dlRrcMsg->rrcMsgSize > 0)
10383    {
10384       DU_ALLOC_SHRABL_BUF(dlRrcMsg->rrcMsgPdu, dlRrcMsg->rrcMsgSize);
10385       if(!dlRrcMsg->rrcMsgPdu)
10386       {
10387          DU_LOG("\nERROR  --> DU APP : Memory allocation failed for RRC Msg in extractDlRrcMsg()");
10388          ret = RFAILED;
10389       }
10390       else
10391       {
10392          dlRrcMsg->gnbDuUeF1apId = gnbDuUeF1apId;
10393          dlRrcMsg->gnbCuUeF1apId = gnbCuUeF1apId;
10394          dlRrcMsg->srbId = SRB1_LCID;
10395          memcpy(dlRrcMsg->rrcMsgPdu, rrcContainer->buf, dlRrcMsg->rrcMsgSize);
10396       }
10397    }
10398    return ret;
10399 }
10400
10401 /*******************************************************************
10402  *
10403  * @brief Extract UE capability info
10404  *
10405  * @details
10406  *
10407  *    Function : extractUeCapability
10408  *
10409  *    Functionality: Extract UE capability info and stores in ue Cb
10410  *
10411  * @params[in] Octet string of UE capability RAT container list
10412  * @return ROK     - success
10413  *         RFAILED - failure
10414  *
10415  * ****************************************************************/
10416 UE_NR_Capability_t *extractUeCapability(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf, DuUeCb *ueCb)
10417 {
10418    uint8_t  idx;
10419    uint16_t recvBufLen;
10420    asn_dec_rval_t rval;
10421    UE_NR_Capability_t  *ueNrCap = NULLP;
10422    UE_CapabilityRAT_ContainerListRRC_t  *ueCapRatContList = NULLP;
10423
10424    /* Decoding UE Capability RAT Container List */
10425    recvBufLen = ueCapablityListBuf->size;
10426    DU_ALLOC(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10427    if(!ueCapRatContList)
10428    {
10429       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
10430       return NULLP;
10431    }
10432    memset(ueCapRatContList, 0, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10433    memset(&rval, 0, sizeof(asn_dec_rval_t));
10434    rval = aper_decode(0, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, (void **)&ueCapRatContList,
10435           ueCapablityListBuf->buf, recvBufLen, 0, 0);
10436    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10437    {
10438       DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
10439       return NULLP;
10440    }
10441    xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, ueCapRatContList);
10442
10443    /* Free encoded buffer after decoding */
10444
10445    for(idx = 0; idx < ueCapRatContList->list.count; idx++)
10446    {
10447       if(ueCapRatContList->list.array[idx]->rat_Type == RAT_Type_nr)
10448       {
10449          /* Decoding UE NR Capability */
10450           recvBufLen = ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.size;
10451           DU_ALLOC(ueNrCap, sizeof(UE_NR_Capability_t));
10452           if(!ueNrCap)
10453           {
10454              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
10455              DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10456              return NULLP;
10457           }
10458           memset(ueNrCap, 0, sizeof(UE_NR_Capability_t));
10459           memset(&rval, 0, sizeof(asn_dec_rval_t));
10460           rval = aper_decode(0, &asn_DEF_UE_NR_Capability, (void **)&ueNrCap,
10461                  ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf, recvBufLen, 0, 0);
10462           if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10463           {
10464              DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
10465              return NULLP;
10466           }
10467           xer_fprint(stdout, &asn_DEF_UE_NR_Capability, ueNrCap);
10468
10469           /* Free encoded buffer after decoding */
10470           free(ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf);
10471       }
10472       free(ueCapRatContList->list.array[idx]);
10473    }
10474
10475    /* Free Memory*/
10476    free(ueCapRatContList->list.array);
10477    DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10478    return ueNrCap;
10479 }
10480
10481 /*******************************************************************
10482 *
10483 * @brief free UE context setup request from CU
10484 *
10485 * @details
10486 *
10487 *    Function : freeAperDecodeF1UeContextSetupReq
10488 *
10489 *    Functionality: freeing part for the memory allocated by aper_decoder
10490 *
10491 * @params[in] F1AP message
10492 * @return ROK     - success
10493 *         RFAILED - failure
10494 *
10495 * ****************************************************************/
10496 void freeAperDecodeF1UeContextSetupReq(UEContextSetupRequest_t   *ueSetReq)
10497 {
10498    uint8_t ieIdx = 0;
10499
10500    if(ueSetReq->protocolIEs.list.array != NULLP)
10501    {
10502       for(ieIdx = 0; ieIdx < ueSetReq->protocolIEs.list.count; ieIdx++)
10503       {
10504          if(ueSetReq->protocolIEs.list.array[ieIdx])
10505          {
10506             switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
10507             {
10508                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10509                   break;
10510                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10511                   break;
10512                case ProtocolIE_ID_id_SpCell_ID:
10513                   freeAperDecodeNrcgi(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
10514                   break;
10515                case ProtocolIE_ID_id_ServCellIndex:
10516                   break;
10517                case ProtocolIE_ID_id_SpCellULConfigured:
10518                   break;
10519                case ProtocolIE_ID_id_CUtoDURRCInformation:
10520
10521                   freeAperDecodeCuToDuInfo(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation);
10522                   break;
10523                case ProtocolIE_ID_id_SCell_ToBeSetup_List:
10524
10525                   freeAperDecodeSplCellList(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SCell_ToBeSetup_List);
10526                   break;
10527                case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
10528
10529                   freeAperDecodeSRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List);
10530                   break;
10531                case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
10532
10533                   freeAperDecodeDRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List);
10534                   break;
10535                case ProtocolIE_ID_id_RRCContainer:
10536                   {
10537
10538                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf != NULLP)
10539                      {
10540
10541                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
10542                      }
10543                      break;
10544                   }
10545                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10546                   break;
10547                case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
10548                   {
10549                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf)
10550                      {
10551                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf);
10552                      }
10553                      break;
10554                   }
10555                default:
10556                   DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld " ,ueSetReq->protocolIEs.list.array[ieIdx]->id);
10557             }
10558             free(ueSetReq->protocolIEs.list.array[ieIdx]);
10559          }
10560       }
10561       free(ueSetReq->protocolIEs.list.array);
10562    }
10563 }
10564 /*******************************************************************
10565  *
10566  * @brief Process UE context setup request from CU
10567  *
10568  * @details
10569  *
10570  *    Function : procF1UeContextSetupReq
10571  *
10572  *    Functionality: Process UE context setup request from CU
10573  *
10574  * @params[in] F1AP message
10575  * @return ROK     - success
10576  *         RFAILED - failure
10577  *
10578  * ****************************************************************/
10579 uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
10580 {
10581    uint8_t  ret=0, ieIdx=0, ueIdx=0, cellIdx=0;
10582    bool ueCbFound = false;
10583    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0, bitRateSize=0;
10584    DuUeCb   *duUeCb = NULL;
10585    UEContextSetupRequest_t   *ueSetReq = NULL;
10586    DRBs_ToBeSetup_List_t *drbCfg = NULL;
10587
10588    ret = ROK;
10589
10590    ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
10591    for(ieIdx=0; (ieIdx < ueSetReq->protocolIEs.list.count && ret == ROK); ieIdx++)
10592    {
10593       switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
10594       {
10595          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10596             {
10597                gnbCuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
10598                break;
10599             }
10600          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10601             {
10602                gnbDuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
10603                break;
10604             }
10605          case ProtocolIE_ID_id_ServCellIndex:
10606             {
10607                cellIdx = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.ServCellIndex;
10608                for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
10609                {
10610                   if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
10611                         (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
10612                   {
10613                      ueCbFound = true;
10614                      duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
10615                      DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
10616                      if(duUeCb->f1UeDb)
10617                      {
10618                         memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
10619                         duUeCb->f1UeDb->actionType = UE_CTXT_SETUP;
10620                         duUeCb->f1UeDb->cellIdx = cellIdx;
10621                      }
10622                      else
10623                      {
10624                         DU_LOG("\nERROR  -->  F1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
10625                         ret = RFAILED;
10626                      }
10627                      break;
10628                   }
10629                   else
10630                      ueCbFound = false;
10631
10632                }
10633                if(!ueCbFound)
10634                {
10635                   DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
10636                   ret = RFAILED;
10637                }
10638                break;
10639             }
10640          case ProtocolIE_ID_id_SpCellULConfigured:
10641             /* Indicates whether the gNB-CU requests the gNB-DU to configure the uplink as no UL,
10642                UL, SUL or UL+SUL for the indicated cell for the UE */
10643             break;
10644          case ProtocolIE_ID_id_CUtoDURRCInformation:
10645             {
10646                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.uE_CapabilityRAT_ContainerList)
10647                {
10648                   duUeCb->f1UeDb->duUeCfg.ueNrCapability = \
10649                   extractUeCapability(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.\
10650                   uE_CapabilityRAT_ContainerList, duUeCb);
10651                }
10652                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.iE_Extensions)
10653                {
10654                   duUeCb->f1UeDb->duUeCfg.cellGrpCfg = extractCellGrpInfo(ueSetReq->protocolIEs.list.array[ieIdx]->\
10655                         value.choice.CUtoDURRCInformation.iE_Extensions, &duUeCb->f1UeDb->duUeCfg);
10656                   if(!duUeCb->f1UeDb->duUeCfg.cellGrpCfg)
10657                   {
10658                      DU_LOG("\nERROR  -->  F1AP: Failed to extract cell Grp Info");
10659                      //TODO: Update the failure cause in ue context Setup Response
10660                      ret = RFAILED;
10661                   }
10662                }
10663                break;
10664             }
10665          case ProtocolIE_ID_id_SCell_ToBeSetup_List:
10666             {
10667                DU_LOG("\nINFO   -->  DU_APP: Received SCell_ToBeSetup_List but  Not processing the list");
10668                break;
10669             }
10670          case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
10671             {
10672                if(extractSrbListToSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List,\
10673                &duUeCb->f1UeDb->duUeCfg))
10674                {
10675                   DU_LOG("\nERROR  -->  DU APP : Failed at extractSrbListToSetup()");
10676                   //TODO: Update the failure cause in ue context Setup Response
10677                   ret = RFAILED;
10678                }
10679                break;
10680             }
10681          case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
10682             {
10683                   drbCfg = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List;
10684
10685                   if(extractDrbListToSetupMod(drbCfg, NULL, NULL, drbCfg->list.count, &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, NULLP))
10686                   {
10687                      DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod()");
10688                      //TODO: Update the failure cause in ue context Setup Response
10689                      ret = RFAILED;
10690                   }
10691                break;
10692             }
10693          case ProtocolIE_ID_id_RRCContainer:
10694             {
10695                /* Filling Dl RRC Msg Info */
10696                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
10697                if(!duUeCb->f1UeDb->dlRrcMsg)
10698                {
10699                   DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
10700                   ret = RFAILED;
10701                }
10702                else
10703                {
10704                   duUeCb->f1UeDb->dlRrcMsgPres = true;
10705                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
10706                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
10707                         &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer);
10708                }
10709                break;
10710             }
10711          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10712             {
10713                if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
10714                {
10715                   duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
10716                }
10717                else
10718                {
10719                   DU_LOG("\nERROR  -->  Ignoring delivery report, since rrcContainer is not present");
10720                }
10721                break;
10722             }
10723          case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
10724             {
10725                /* MaximumBitRate Uplink */
10726                bitRateSize = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.size;
10727                if(bitRateSize > 0)
10728                {
10729                   DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.ambrCfg, bitRateSize);
10730                   if(!duUeCb->f1UeDb->duUeCfg.ambrCfg)
10731                   {
10732                      DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
10733                      ret = RFAILED;
10734                   }
10735                   else
10736                   {
10737                      memset(duUeCb->f1UeDb->duUeCfg.ambrCfg, 0, sizeof(AmbrCfg));
10738                      memcpy(&duUeCb->f1UeDb->duUeCfg.ambrCfg->ulBr,
10739                            ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf, bitRateSize);
10740                   }
10741                }
10742                else
10743                   ret = RFAILED;
10744                break;
10745             }
10746          default:
10747             {
10748                break;
10749             }
10750       }
10751    }
10752    if(ret == RFAILED)
10753    {
10754       /*TODO : Negative case*/
10755       // BuildAndSendUeContextSetupRsp(cellId,ueIdx);
10756       DU_LOG("\nERROR  -->  F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
10757    }
10758    else
10759       ret = duProcUeContextSetupRequest(duUeCb);
10760
10761    freeAperDecodeF1UeContextSetupReq(ueSetReq);
10762    return ret;
10763
10764 }
10765 /*******************************************************************
10766  * @brief Free the memory allocated for Dl Tunnel Info
10767  *
10768  * @details
10769  *
10770  *    Function : freeDlTnlInfo
10771  *
10772  *    Functionality:
10773  *       Free the memory allocated for Dl Tunnel Info
10774  *
10775  * @params[in] DLUPTNLInformation_ToBeSetup_List_t *
10776  * @return void
10777  *
10778  * ****************************************************************/
10779
10780 void freeDlTnlInfo(DLUPTNLInformation_ToBeSetup_List_t *tnlInfo)
10781 {
10782    uint8_t arrIdx = 0;
10783
10784    if(tnlInfo)
10785    {
10786       for(arrIdx=0; arrIdx < tnlInfo->list.count; arrIdx++)
10787       {
10788          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf,\
10789                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
10790          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf,\
10791                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
10792          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
10793          DU_FREE(tnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
10794       }
10795       DU_FREE(tnlInfo->list.array, tnlInfo->list.size);
10796    }
10797 }
10798
10799 /*******************************************************************
10800  * @brief Free the memory allocated for DRB setup List
10801  *
10802  * @details
10803  *
10804  *    Function : freeDrbSetupList
10805  *
10806  *    Functionality:
10807  *       Free the memory allocated for DRB setup list
10808  *
10809  * @params[in] DRBs_Setup_List_t *
10810  * @return void
10811  *
10812  * ****************************************************************/
10813 void freeDrbSetupList(DRBs_Setup_List_t *drbSetupList)
10814 {
10815    uint8_t arrIdx = 0;
10816    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
10817
10818    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
10819    {
10820       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
10821       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
10822       DU_FREE(drbSetupList->list.array[arrIdx],  sizeof(DRBs_Setup_Item_t));
10823    }
10824    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
10825 }
10826
10827 /*******************************************************************
10828  * @brief Free the memory allocated for UE Setup response
10829  *
10830  * @details
10831  *
10832  *    Function : FreeUeContextSetupRsp
10833  *
10834  *    Functionality:
10835  *       Free the memory allocated for UE Setup response
10836  *
10837  * @params[in] F1AP PDU for UE setup response
10838  * @return ROK     - success
10839  *         RFAILED - failure
10840  *
10841  * ****************************************************************/
10842 void FreeUeContextSetupRsp(F1AP_PDU_t *f1apMsg)
10843 {
10844    uint8_t idx;
10845    UEContextSetupResponse_t *ueSetRsp = NULLP;
10846
10847    if(f1apMsg)
10848    {
10849       if(f1apMsg->choice.successfulOutcome)
10850       {
10851          ueSetRsp = &f1apMsg->choice.successfulOutcome->value.choice.\
10852                     UEContextSetupResponse;
10853          if(ueSetRsp->protocolIEs.list.array)
10854          {
10855             for(idx = 0; idx < ueSetRsp->protocolIEs.list.count; idx++)
10856             {
10857                if(ueSetRsp->protocolIEs.list.array[idx])
10858                {
10859                   switch(ueSetRsp->protocolIEs.list.array[idx]->id)
10860                   {
10861                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10862                         break;
10863                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10864                         break;
10865                      case ProtocolIE_ID_id_DUtoCURRCInformation:
10866                         {
10867                            CellGroupConfig_t *cellGrpCfg = NULLP;
10868                            cellGrpCfg  = &ueSetRsp->protocolIEs.list.array[idx]->value.choice.\
10869                                          DUtoCURRCInformation.cellGroupConfig;
10870                            if(cellGrpCfg->buf != NULLP)
10871                            {
10872                               DU_FREE(cellGrpCfg->buf, cellGrpCfg->size);
10873                               cellGrpCfg = NULLP;
10874                            }
10875                            break;
10876                         }
10877                     case ProtocolIE_ID_id_DRBs_Setup_List:
10878                         {
10879                            freeDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
10880                            break;
10881                         }
10882                      default:
10883                         DU_LOG("\nERROR  -->  DUAPP: Invalid Id %ld at FreeUeContextSetupRsp()",\
10884                         ueSetRsp->protocolIEs.list.array[idx]->id);
10885                         break;
10886                   }
10887                   DU_FREE(ueSetRsp->protocolIEs.list.array[idx],\
10888                         sizeof(UEContextSetupResponseIEs_t));
10889                }
10890             }
10891             DU_FREE(ueSetRsp->protocolIEs.list.array, \
10892                   ueSetRsp->protocolIEs.list.size);
10893          }
10894          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
10895       }
10896       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10897    }
10898 }
10899
10900 /*******************************************************************
10901  *
10902  * @brief Builds Ue context Setup Rsp DU To CU Info
10903  *
10904  * @details
10905  *
10906  *    Function : EncodeUeCntxtDuToCuInfo
10907  *
10908  *    Functionality: Builds Ue context Setup Rsp DU To CU Info
10909  *
10910  * @params[in] CellGroupConfig_t *, CellGroupConfigRrc_t *
10911  *
10912  * @return ROK     - success
10913  *         RFAILED - failure
10914  *
10915  ******************************************************************/
10916
10917 uint8_t EncodeUeCntxtDuToCuInfo(CellGroupConfig_t *duToCuCellGrp, CellGroupConfigRrc_t *duCellGrpCfg)
10918 {
10919    asn_enc_rval_t        encRetVal;
10920
10921    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, duCellGrpCfg);
10922    memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
10923    encBufSize = 0;
10924    encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, duCellGrpCfg, PrepFinalEncBuf, encBuf);
10925    /* Encode results */
10926    if(encRetVal.encoded == ENCODE_FAIL)
10927    {
10928       DU_LOG( "\nERROR  -->  F1AP : Could not encode UeCntxtDuToCuInfo (at %s)\n",\
10929             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10930       return RFAILED;
10931    }
10932    else
10933    {
10934       DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
10935       for(int i=0; i< encBufSize; i++)
10936       {
10937          printf("%x",encBuf[i]);
10938       }
10939    }
10940    duToCuCellGrp->size = encBufSize;
10941    DU_ALLOC(duToCuCellGrp->buf, duToCuCellGrp->size);
10942    if(!duToCuCellGrp->buf)
10943    {
10944       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in UeCntxtDuToCuInfo");
10945    }
10946    memcpy(duToCuCellGrp->buf, encBuf, duToCuCellGrp->size);
10947    return ROK;
10948 }
10949
10950 /*******************************************************************
10951  *
10952  * @brief Fills Dl Gtp tunnel Info
10953  *
10954  * @details
10955  *
10956  *    Function : fillGtpTunnelforDl
10957  *
10958  *    Functionality: Fills Dl Gtp tunnel Info
10959  *
10960  * @params[in]
10961  *
10962  * @return ROK     - success
10963  *         RFAILED - failure
10964  *
10965  * ****************************************************************/
10966
10967 uint8_t fillGtpTunnelforDl(GTPTunnel_t *gtpDl, GtpTnlCfg *gtpUeCfg)
10968 {
10969    uint8_t bufSize = 0;
10970
10971    gtpDl->transportLayerAddress.size    = 4*sizeof(uint8_t);
10972    DU_ALLOC(gtpDl->transportLayerAddress.buf, gtpDl->transportLayerAddress.size);
10973    if(gtpDl->transportLayerAddress.buf == NULLP)
10974    {
10975       return RFAILED;
10976    }
10977    memcpy(gtpDl->transportLayerAddress.buf, &gtpUeCfg->dlTnlAddress, gtpDl->transportLayerAddress.size);
10978
10979    /*GTP TEID*/
10980    gtpDl->gTP_TEID.size = 4 * sizeof(uint8_t);
10981    DU_ALLOC(gtpDl->gTP_TEID.buf, gtpDl->gTP_TEID.size);
10982    if(gtpDl->gTP_TEID.buf == NULLP)
10983    {
10984       return RFAILED;
10985    }
10986    bufSize = 3; /*forming an Octect String*/
10987    fillTeIdString(bufSize, gtpUeCfg->teId, gtpDl->gTP_TEID.buf);
10988
10989    return ROK;
10990 }
10991
10992 /*******************************************************************
10993  *
10994  * @brief Fills DL Tunnel Setup List
10995  *
10996  * @details
10997  *
10998  *    Function : fillDlTnlSetupList
10999  *
11000  *    Functionality: Fills the DL Tunnel Setup List
11001  *
11002  * @params[in]
11003  *
11004  * @return ROK     - success
11005  *         RFAILED - failure
11006  *
11007  * ****************************************************************/
11008
11009 uint8_t fillDlTnlSetupList(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo, UpTnlCfg *tnlCfg)
11010 {
11011    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
11012
11013    eleCount = 1;
11014    dlTnlInfo->list.count = eleCount;
11015    dlTnlInfo->list.size = (eleCount * sizeof(DLUPTNLInformation_ToBeSetup_Item_t *));
11016
11017    /* Initialize the DL Tnl Setup List Members */
11018    DU_ALLOC(dlTnlInfo->list.array, dlTnlInfo->list.size);
11019    if(dlTnlInfo->list.array == NULLP)
11020    {
11021       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL Tnl Setup List in fillDlTnlSetupList()");
11022       ret = RFAILED;
11023    }
11024    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
11025    {
11026       DU_ALLOC(dlTnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
11027       if(dlTnlInfo->list.array[arrIdx] == NULLP)
11028       {
11029          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDlTnlSetupList()", arrIdx);
11030          return RFAILED;
11031       }
11032       dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
11033       DU_ALLOC(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
11034       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel == NULLP)
11035       {
11036          DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL tunnel info in fillDlTnlSetupList()");
11037          return RFAILED;
11038       }
11039       ret = fillGtpTunnelforDl(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel,\
11040                tnlCfg->tnlCfg1);
11041       if(ret != ROK)
11042          break;
11043    }
11044    return ret;
11045 }
11046
11047 /*******************************************************************
11048  *
11049  * @brief Fills the Drb Setup List for Ue Context Setup Response
11050  *
11051  * @details
11052  *
11053  *    Function : fillDrbSetupList
11054  *
11055  *    Functionality: Fills the Drb Setup List for Ue Context Setup Response
11056  *
11057  * @params[in]
11058  *
11059  * @return ROK     - success
11060  *         RFAILED - failure
11061  *
11062  * ****************************************************************/
11063 uint8_t fillDrbSetupList(DRBs_Setup_List_t *drbSetupList, DuUeCfg *ueCfg)
11064 {
11065    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
11066    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
11067
11068    eleCount = ueCfg->numDrb;
11069    drbSetupList->list.count = eleCount;
11070    drbSetupList->list.size = \
11071         (eleCount * sizeof(DRBs_Setup_Item_t *));
11072
11073    /* Initialize the Drb Setup List Members */
11074    DU_ALLOC(drbSetupList->list.array, drbSetupList->list.size);
11075    if(drbSetupList->list.array == NULLP)
11076    {
11077       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DRB Setup List in fillDrbSetupList()");
11078       ret = RFAILED;
11079    }
11080
11081    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
11082    {
11083       DU_ALLOC(drbSetupList->list.array[arrIdx], sizeof(DRBs_Setup_Item_t));
11084       if(drbSetupList->list.array[arrIdx] == NULLP)
11085       {
11086          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDrbSetupList()", arrIdx);
11087          return RFAILED;
11088       }
11089       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
11090       drbItemIe->id = ProtocolIE_ID_id_DRBs_Setup_Item;
11091       drbItemIe->criticality = Criticality_reject;
11092       drbItemIe->value.present = DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item;
11093       drbItemIe->value.choice.DRBs_Setup_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
11094       ret = fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List,\
11095           &ueCfg->upTnlInfo[arrIdx]);
11096       if(ret != ROK)
11097          break;
11098    }
11099    return ret;
11100 }
11101
11102 /*******************************************************************
11103  *
11104  * @brief Builds and sends the UE Setup Response
11105  *
11106  * @details
11107  *
11108  *    Function : BuildAndSendUeContextSetupRsp
11109  *
11110  *    Functionality: Constructs the UE Setup Response and sends
11111  *                   it to the DU through SCTP.
11112  *
11113  * @params[in] uint8_t cellId,uint8_t ueIdx
11114  *
11115  * @return ROK     - success
11116  *         RFAILED - failure
11117  *
11118  * ****************************************************************/
11119 uint8_t BuildAndSendUeContextSetupRsp(uint8_t cellId,uint8_t ueIdx)
11120 {
11121    uint8_t   idx, ret, cellIdx, elementCnt;
11122    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
11123    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
11124    asn_enc_rval_t  encRetVal;        /* Encoder return value */
11125    F1AP_PDU_t               *f1apMsg = NULLP;
11126    UEContextSetupResponse_t *ueSetRsp = NULLP;
11127    CellGroupConfigRrc_t     *cellGrpCfg = NULLP;
11128    DuUeCb                   *ueCb = NULLP;
11129
11130    DU_LOG("\n INFO   -->  F1AP : Building UE Context Setup Response for cellId %d, ueIdx %d\n", cellId, ueIdx);
11131
11132    while(true)
11133    {
11134       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11135       if(f1apMsg == NULLP)
11136       {
11137          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11138          ret = RFAILED;
11139          break;
11140       }
11141
11142       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
11143       DU_ALLOC(f1apMsg->choice.successfulOutcome,
11144             sizeof(SuccessfulOutcome_t));
11145       if(f1apMsg->choice.successfulOutcome == NULLP)
11146       {
11147          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
11148          ret = RFAILED;
11149          break;
11150       }
11151
11152       f1apMsg->choice.successfulOutcome->procedureCode = \
11153                                                          ProcedureCode_id_UEContextSetup;
11154       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
11155       f1apMsg->choice.successfulOutcome->value.present = \
11156                                                          SuccessfulOutcome__value_PR_UEContextSetupResponse;
11157
11158       ueSetRsp =
11159          &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
11160       elementCnt = 4;
11161       ueSetRsp->protocolIEs.list.count = elementCnt;
11162       ueSetRsp->protocolIEs.list.size = \
11163                                         elementCnt * sizeof(UEContextSetupResponse_t *);
11164
11165       /* Initialize the UESetup members */
11166       DU_ALLOC(ueSetRsp->protocolIEs.list.array, \
11167             ueSetRsp->protocolIEs.list.size);
11168       if(ueSetRsp->protocolIEs.list.array == NULLP)
11169       {
11170          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
11171          ret = RFAILED;
11172          break;
11173       }
11174
11175       for(idx=0; idx<elementCnt; idx++)
11176       {
11177          DU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
11178                sizeof(UEContextSetupResponseIEs_t));
11179          if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
11180          {
11181             DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
11182             ret = RFAILED;
11183             break;
11184          }
11185       }
11186       /* Fetching Ue Cb Info*/
11187       GET_CELL_IDX(cellId, cellIdx);
11188       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
11189       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
11190       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
11191
11192       idx = 0;
11193       /*GNB CU UE F1AP ID*/
11194       ueSetRsp->protocolIEs.list.array[idx]->id = \
11195                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11196       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11197       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
11198                                                              UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
11199       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
11200
11201       /*GNB DU UE F1AP ID*/
11202       idx++;
11203       ueSetRsp->protocolIEs.list.array[idx]->id = \
11204                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11205       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11206       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
11207                                                              UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
11208       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
11209
11210
11211       /*DUtoCURRC Information */
11212       idx++;
11213       ueSetRsp->protocolIEs.list.array[idx]->id  = \
11214                                                    ProtocolIE_ID_id_DUtoCURRCInformation;
11215       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11216       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
11217                                                             UEContextSetupResponseIEs__value_PR_DUtoCURRCInformation;
11218       if(ueCb->f1UeDb)
11219       {
11220          if(ueCb->f1UeDb->duUeCfg.cellGrpCfg)
11221          {
11222             cellGrpCfg = (CellGroupConfigRrc_t*)ueCb->f1UeDb->duUeCfg.cellGrpCfg;
11223             ret = EncodeUeCntxtDuToCuInfo(&ueSetRsp->protocolIEs.list.array[idx]->value.\
11224                      choice.DUtoCURRCInformation.cellGroupConfig, cellGrpCfg);
11225             if(ret == RFAILED)
11226             {
11227                DU_LOG("\nERROR  -->  F1AP : Failed to EncodeUeCntxtDuToCuInfo in BuildAndSendUeContextSetupRsp()");
11228                freeF1UeDb(ueCb->f1UeDb);
11229                ueCb->f1UeDb = NULLP;
11230                break;
11231             }
11232          }
11233       }
11234       else
11235       {
11236          DU_LOG("\nERROR  -->  F1AP : Failed to form DUtoCU RRCInfo at BuildAndSendUeContextSetupRsp()");
11237          ret = RFAILED;
11238          break;
11239       }
11240
11241       /* Drb Setup List */
11242       idx++;
11243       ueSetRsp->protocolIEs.list.array[idx]->id  = \
11244                                  ProtocolIE_ID_id_DRBs_Setup_List;
11245       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11246       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
11247                                  UEContextSetupResponseIEs__value_PR_DRBs_Setup_List;
11248       ret = fillDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List,\
11249                &ueCb->f1UeDb->duUeCfg);
11250       if(ret == RFAILED)
11251       {
11252          DU_LOG("\nERROR  -->  F1AP : Failed to fillDrbSetupList in BuildAndSendUeContextSetupRsp()");
11253          freeF1UeDb(ueCb->f1UeDb);
11254          ueCb->f1UeDb = NULLP;
11255          break;
11256       }
11257
11258        /* Free UeContext Db created during Ue context Req */
11259        freeF1UeDb(ueCb->f1UeDb);
11260        ueCb->f1UeDb = NULLP;
11261
11262       /* TODO: To send Drb list */
11263       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11264
11265       /* Encode the UE context setup response type as APER */
11266       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
11267       encBufSize = 0;
11268       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11269             encBuf);
11270       /* Encode results */
11271       if(encRetVal.encoded == ENCODE_FAIL)
11272       {
11273          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Response structure (at %s)\n",\
11274                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11275          ret = RFAILED;
11276          break;
11277       }
11278       else
11279       {
11280          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Setup Response\n");
11281          for(int i=0; i< encBufSize; i++)
11282          {
11283             printf("%x",encBuf[i]);
11284          }
11285       }
11286
11287       /* Sending  msg  */
11288       if(sendF1APMsg()  != ROK)
11289       {
11290          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Response failed");
11291          ret = RFAILED;
11292          break;
11293       }
11294       break;
11295    }
11296    FreeUeContextSetupRsp(f1apMsg);
11297    return ret;
11298 }/* End of BuildAndSendUeContextSetupRsp */
11299 /*******************************************************************
11300 *
11301 * @brief  Build And Send Ue Context Rsp
11302 *
11303 * @details
11304 *
11305 *    Function : BuildAndSendUeCtxtRsp
11306 *
11307 *    Functionality : Build And Send Ue Context Rsp
11308
11309 * @params[in]
11310 * @return sucess = ROK
11311 *         failure = RFAILED
11312 *
11313 * ****************************************************************/
11314 uint8_t BuildAndSendUeCtxtRsp(uint8_t cellId, uint8_t ueIdx)
11315 {
11316    uint8_t cellIdx = 0, actionType = 0;
11317
11318    GET_CELL_IDX(cellId, cellIdx);
11319    actionType = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].f1UeDb->actionType;
11320
11321    switch(actionType)
11322    {
11323       case UE_CTXT_SETUP:
11324          {
11325             BuildAndSendUeContextSetupRsp(cellId,ueIdx);
11326             break;
11327          }
11328       case UE_CTXT_MOD:
11329          {
11330             BuildAndSendUeContextModRsp(cellId, ueIdx);
11331             break;
11332          }
11333       default:
11334          DU_LOG("ERROR  -->  F1AP: Invalid Action Type %d at BuildAndSendUeCtxtRsp()", actionType);
11335          break;
11336
11337    }
11338    return ROK;
11339 }
11340
11341 /*******************************************************************
11342  *
11343  * @brief deallocating the memory of  F1reset msg
11344  *
11345  * @details
11346  *
11347  *    Function : FreeF1ResetReq
11348  *
11349  *    Functionality :
11350  *         - freeing memory of F1reset request msg
11351  *
11352  * @params[in]
11353  * @return void
11354  *
11355  *
11356  * ****************************************************************/
11357 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
11358 {
11359    uint8_t idx =0 ;
11360    Reset_t *f1ResetMsg;
11361
11362    if(f1apMsg)
11363    {
11364       if(f1apMsg->choice.initiatingMessage)
11365       {
11366          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11367
11368          if(f1ResetMsg->protocolIEs.list.array)
11369          {
11370             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
11371             {
11372                if(f1ResetMsg->protocolIEs.list.array[idx])
11373                {
11374                   DU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
11375                }
11376             }
11377             DU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
11378          }
11379          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11380       }
11381       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11382    }
11383 }
11384 /*******************************************************************
11385  *
11386  * @brief Build and Send F1reset request
11387  *
11388  * @details
11389  *
11390  *    Function : BuildAndSendF1ResetReq
11391  *
11392  *    Functionality:
11393  *         - Build and Send F1reset request msg
11394  *
11395  * @params[in]
11396  * @return ROK     - success
11397  *         RFAILED - failure
11398  *
11399  * ****************************************************************/
11400 uint8_t BuildAndSendF1ResetReq()
11401 {
11402    uint8_t          elementCnt=0;
11403    uint8_t          idx=0;
11404    uint8_t          ret= RFAILED;
11405    Reset_t          *f1ResetMsg = NULLP;
11406    F1AP_PDU_t       *f1apMsg = NULLP;
11407    asn_enc_rval_t   encRetVal;
11408    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset request \n");
11409    do
11410    {
11411       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11412       if(f1apMsg == NULLP)
11413       {
11414          break;
11415       }
11416       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
11417       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11418       if(f1apMsg->choice.initiatingMessage == NULLP)
11419       {
11420          break;
11421       }
11422       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
11423       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
11424       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
11425
11426       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11427
11428       elementCnt = 3;
11429       f1ResetMsg->protocolIEs.list.count = elementCnt;
11430       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
11431
11432       /* Initialize the F1Setup members */
11433       DU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
11434       if(f1ResetMsg->protocolIEs.list.array == NULLP)
11435       {
11436          break;
11437       }
11438       for(idx=0; idx<elementCnt; idx++)
11439       {
11440          DU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
11441          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
11442          {
11443             break;
11444          }
11445       }
11446
11447       /*TransactionID*/
11448       idx=0;
11449       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
11450       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11451       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
11452       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
11453
11454       /*Cause*/
11455       idx++;
11456       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
11457       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
11458       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
11459       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
11460       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
11461
11462       /*Reset Type*/
11463       idx++;
11464       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
11465       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11466       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
11467       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
11468       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
11469
11470       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11471
11472       /* Encode the F1SetupRequest type as APER */
11473       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11474       encBufSize = 0;
11475       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11476             encBuf);
11477
11478       /* Encode results */
11479       if(encRetVal.encoded == ENCODE_FAIL)
11480       {
11481          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
11482                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11483          break;
11484       }
11485       else
11486       {
11487          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1Reset\n");
11488          for(idx=0; idx< encBufSize; idx++)
11489          {
11490             printf("%x",encBuf[idx]);
11491          }
11492       }
11493
11494       if(sendF1APMsg() != ROK)
11495       {
11496          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
11497          break;
11498       }
11499
11500       ret = ROK;
11501       break;
11502    }while(true);
11503
11504    FreeF1ResetReq(f1apMsg);
11505    return ret;
11506 }
11507 /*******************************************************************
11508  *
11509  * @brief Build And Send F1ResetAck
11510  *
11511  * @details
11512  *
11513  *    Function : BuildAndSendF1ResetAck
11514  *
11515  *    Functionality:
11516  *         - Build And Send  F1ResetRSP
11517  *
11518  * @return ROK     - success
11519  *         RFAILED - failure
11520  *
11521  * ****************************************************************/
11522 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
11523 {
11524    uint8_t idx;
11525    ResetAcknowledge_t *f1ResetAck;
11526
11527    if(f1apMsg)
11528    {
11529       if(f1apMsg->choice.successfulOutcome)
11530       {
11531          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
11532
11533          if(f1ResetAck->protocolIEs.list.array)
11534          {
11535             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
11536             {
11537                if(f1ResetAck->protocolIEs.list.array[idx])
11538                {
11539                   DU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
11540                }
11541             }
11542             DU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
11543          }
11544          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11545       }
11546       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11547    }
11548 }
11549
11550 /*******************************************************************
11551  *
11552  * @brief Build And Send F1ResetAck
11553  *
11554  * @details
11555  *
11556  *    Function : BuildAndSendF1ResetAck
11557  *
11558  *    Functionality:
11559  *         - Build And Send  F1ResetRSP
11560  *
11561  *  @params[in]
11562  * @return ROK     - success
11563  *         RFAILED - failure
11564  *
11565  * ****************************************************************/
11566 uint8_t BuildAndSendF1ResetAck()
11567 {
11568    uint8_t                idx = 0;
11569    uint8_t                elementCnt = 0;
11570    uint8_t                ret = RFAILED;
11571    F1AP_PDU_t             *f1apMsg = NULL;
11572    ResetAcknowledge_t     *f1ResetAck = NULLP;
11573    asn_enc_rval_t         encRetVal;
11574    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset Acknowledgment \n");
11575
11576    do{
11577       /* Allocate the memory for F1ResetRequest_t */
11578       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11579       if(f1apMsg == NULLP)
11580       {
11581          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11582          break;
11583       }
11584
11585       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
11586
11587       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11588       if(f1apMsg->choice.successfulOutcome == NULLP)
11589       {
11590          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11591          break;
11592       }
11593       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
11594       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
11595       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
11596
11597       elementCnt = 1;
11598
11599       f1ResetAck->protocolIEs.list.count = elementCnt;
11600       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
11601
11602       DU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
11603       if(f1ResetAck->protocolIEs.list.array == NULLP)
11604       {
11605          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
11606          break;
11607       }
11608
11609       for(idx=0; idx<elementCnt; idx++)
11610       {
11611          DU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
11612          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
11613          {
11614             break;
11615          }
11616       }
11617       /*TransactionID*/
11618       idx = 0;
11619       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
11620       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11621       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
11622       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
11623
11624       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11625
11626       /* Encode the F1SetupRequest type as UPER */
11627       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11628       encBufSize = 0;
11629       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
11630
11631       /* Check encode results */
11632       if(encRetVal.encoded == ENCODE_FAIL)
11633       {
11634          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
11635                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11636          break;
11637       }
11638       else
11639       {
11640          DU_LOG("\nDUBUG   -->  F1AP : Created APER encoded buffer for F1ResetAck\n");
11641          for(int i=0; i< encBufSize; i++)
11642          {
11643             printf("%x",encBuf[i]);
11644          }
11645       }
11646       /* Sending msg */
11647       if(sendF1APMsg() != ROK)
11648       {
11649          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Acknowledgement failed");
11650          break;
11651       }
11652
11653       ret = ROK;
11654       break;
11655    }while(true);
11656
11657    FreeF1ResetAck(f1apMsg);
11658    return ret;
11659 }
11660 /******************************************************************
11661 *
11662 * @brief free F1 reset msg allocated by aper_decoder
11663 *
11664 * @details
11665 *
11666 *    Function : freeAperDecodeF1ResetMsg
11667 *
11668 *    Functionality: free F1 reset msg allocated by aper_decoder
11669 *
11670 * @params[in] Reset_t *f1ResetMsg
11671 * @return void
11672 *
11673 * ****************************************************************/
11674
11675 void freeAperDecodeF1ResetMsg(Reset_t *f1ResetMsg)
11676 {
11677    uint8_t ieIdx =0;
11678    if(f1ResetMsg->protocolIEs.list.array)
11679    {
11680       for(ieIdx=0 ;ieIdx < f1ResetMsg->protocolIEs.list.count ; ieIdx++)
11681       {
11682          if(f1ResetMsg->protocolIEs.list.array[ieIdx])
11683          {
11684             free(f1ResetMsg->protocolIEs.list.array[ieIdx]);
11685          }
11686       }
11687       free(f1ResetMsg->protocolIEs.list.array);
11688    }
11689 }
11690
11691 /******************************************************************
11692  *
11693  * @brief Processes DL RRC Message Transfer  sent by CU
11694  *
11695  * @details
11696  *
11697  *    Function : procF1ResetReq
11698  *
11699  *    Functionality: Processes DL RRC Message Transfer sent by CU
11700  *
11701  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11702  * @return ROK     - success
11703  *         RFAILED - failure
11704  *
11705  * ****************************************************************/
11706 uint8_t procF1ResetReq(F1AP_PDU_t *f1apMsg)
11707 {
11708    /* we are currently not supporting Ue release. right now we are supporting only init case of fireset */
11709    uint8_t       ieIdx = 0;
11710    uint8_t        ret = ROK;
11711    Reset_t       *f1ResetMsg = NULLP;
11712
11713    DU_LOG("\nINFO   -->  Processing F1 reset request");
11714    f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11715
11716    for(ieIdx=0; ieIdx<f1ResetMsg->protocolIEs.list.count; ieIdx++)
11717    {
11718       switch(f1ResetMsg->protocolIEs.list.array[ieIdx]->id)
11719       {
11720          case ProtocolIE_ID_id_TransactionID:
11721             break;
11722
11723          case ProtocolIE_ID_id_Cause:
11724             break;
11725
11726          case ProtocolIE_ID_id_ResetType:
11727             {
11728                break;
11729             }
11730
11731          default:
11732             break;
11733       }
11734    }
11735    ret = BuildAndSendF1ResetAck();
11736    DU_LOG("\nINFO   -->  UE release is not supported for now");
11737
11738    freeAperDecodeF1ResetMsg(f1ResetMsg);
11739
11740    return ret;
11741 }
11742
11743 /*******************************************************************
11744  *
11745  * @brief free the RRC delivery report
11746  *
11747  * @details
11748  *
11749  *    Function : freeRrcDeliveryReport
11750  *
11751  *    Functionality: free the RRC delivery report
11752  *
11753  * @params[in]
11754  * @return ROK     - success
11755  *         RFAILED - failure
11756  *
11757  * ****************************************************************/
11758 void freeRrcDeliveryReport(F1AP_PDU_t  *f1apMsg )
11759 {
11760    uint8_t idx=0;
11761    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11762
11763    if(f1apMsg)
11764    {
11765       if(f1apMsg->choice.initiatingMessage)
11766       {
11767          rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11768          if(rrcDeliveryReport->protocolIEs.list.array)
11769          {
11770             for(idx =0 ;idx <rrcDeliveryReport->protocolIEs.list.count ;
11771                   idx++)
11772             {
11773                if(rrcDeliveryReport->protocolIEs.list.array[idx])
11774                {
11775                   DU_FREE(rrcDeliveryReport->protocolIEs.list.array[idx],
11776                         sizeof(RRCDeliveryReportIEs_t));
11777                }
11778             }
11779             DU_FREE(rrcDeliveryReport->protocolIEs.list.array,
11780                   rrcDeliveryReport->protocolIEs.list.size);
11781          }
11782          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11783       }
11784       DU_FREE(f1apMsg,
11785             sizeof(F1AP_PDU_t));
11786    }
11787 }
11788
11789 /*******************************************************************
11790 *
11791 * @brief Builds and sends the RRC delivery report
11792 *
11793 * @details
11794 *
11795 *    Function : BuildAndSendRrcDeliveryReport
11796 *
11797 *    Functionality: Builds and sends the RRC delivery report
11798 *
11799 * @params[in]
11800 *
11801 * @return ROK     - success
11802 *         RFAILED - failure
11803 *
11804 * ****************************************************************/
11805 uint8_t BuildAndSendRrcDeliveryReport(uint32_t gnbCuUeF1apId, \
11806    uint32_t gnbDuUeF1apId, RrcDeliveryReport *rrcDelivery)
11807 {
11808    uint8_t             ret = RFAILED;
11809    uint8_t             idx    = 0;
11810    uint8_t             idx1   = 0;
11811    uint8_t             elementCnt = 0;
11812    F1AP_PDU_t          *f1apMsg = NULLP;
11813    asn_enc_rval_t      encRetVal;
11814    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11815
11816    do{
11817
11818       DU_LOG("\nINFO   -->  F1AP : Building RRC delivery Message Transfer Message\n");
11819       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11820       if(f1apMsg == NULLP)
11821       {
11822          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11823          break;
11824       }
11825       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
11826       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11827       if(f1apMsg->choice.initiatingMessage == NULLP)
11828       {
11829          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU  failed");
11830          break;
11831       }
11832       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_RRCDeliveryReport;
11833       f1apMsg->choice.initiatingMessage->criticality   = Criticality_ignore;
11834       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RRCDeliveryReport;
11835
11836       rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11837       elementCnt = 4;
11838       rrcDeliveryReport->protocolIEs.list.count = elementCnt;
11839       rrcDeliveryReport->protocolIEs.list.size = elementCnt * sizeof(RRCDeliveryReportIEs_t *);
11840
11841       /* Initialize the F1Setup members */
11842       DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array, rrcDeliveryReport->protocolIEs.list.size);
11843       if(rrcDeliveryReport->protocolIEs.list.array == NULLP)
11844       {
11845          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRC Delivery  failed");
11846          break;
11847       }
11848       for(idx =0 ;idx <elementCnt; idx++)
11849       {
11850          DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array[idx], sizeof(RRCDeliveryReportIEs_t));
11851          if(rrcDeliveryReport->protocolIEs.list.array[idx] == NULLP)
11852          {
11853             break;
11854          }
11855       }
11856
11857       idx1 = 0;
11858
11859       /*GNB CU UE F1AP ID*/
11860       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11861       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
11862       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_CU_UE_F1AP_ID;
11863       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
11864
11865       /*GNB DU UE F1AP ID*/
11866       idx1++;
11867       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11868       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
11869       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_DU_UE_F1AP_ID;
11870       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
11871
11872       /*RRC delivery status*/
11873       idx1++;
11874       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_RRCDeliveryStatus;
11875       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
11876       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_RRCDeliveryStatus;
11877       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.delivery_status =\
11878       rrcDelivery->rrcDeliveryStatus.deliveryStatus;
11879       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.triggering_message =\
11880       rrcDelivery->rrcDeliveryStatus.triggeringMessage;
11881
11882       /* SRB ID */
11883       idx1++;
11884       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
11885       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
11886       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_SRBID;
11887       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.SRBID =  rrcDelivery->srbId;
11888
11889       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11890
11891       /* Encode the RRC DELIVERY REPORT type as APER */
11892       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11893       encBufSize = 0;
11894       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11895             encBuf);
11896
11897       /* Encode results */
11898       if(encRetVal.encoded == ENCODE_FAIL)
11899       {
11900          DU_LOG("\nERROR  -->  F1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
11901                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11902          break;
11903       }
11904       else
11905       {
11906          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for RRC Delivery Msg \n");
11907          for(idx=0; idx< encBufSize; idx++)
11908          {
11909             printf("%x",encBuf[idx]);
11910          }
11911       }
11912
11913       /* Sending msg */
11914       if(sendF1APMsg() != ROK)
11915       {
11916          DU_LOG("\nERROR  -->  F1AP : Sending RRC delivery  msg request failed");
11917          break;
11918       }
11919       ret = ROK;
11920       break;
11921
11922    }while(true);
11923
11924    freeRrcDeliveryReport(f1apMsg);
11925    return ret;
11926 }
11927
11928 /*******************************************************************
11929  *
11930  * @brief Processes cells to be activated
11931  *
11932  * @details
11933  *
11934  *    Function : extractCellsToBeActivated
11935  *
11936  *    Functionality:
11937  *      - Processes cells to be activated list received in F1SetupRsp
11938  *
11939  * @params[in] void
11940  * @return ROK     - success
11941  *         RFAILED - failure
11942  *
11943  * ****************************************************************/
11944
11945 uint8_t extractCellsToBeActivated(Cells_to_be_Activated_List_t cellsToActivate)
11946 {
11947    uint8_t  ret = ROK;
11948    uint16_t idx, nci, pci = 0;
11949    Cells_to_be_Activated_List_Item_t cell;
11950
11951    for(idx=0; idx<cellsToActivate.list.count; idx++)
11952    {
11953       nci = 0;
11954       cell = cellsToActivate.list.array[idx]->value.choice.Cells_to_be_Activated_List_Item;
11955       bitStringToInt(&cell.nRCGI.nRCellIdentity, &nci);
11956
11957       if(cell.nRPCI)
11958       {
11959          pci = *cell.nRPCI;
11960       }
11961       ret = duProcCellsToBeActivated(cell.nRCGI.pLMN_Identity.buf, nci, pci);
11962    }
11963    return ret;
11964 }
11965 /******************************************************************
11966 *
11967 * @brief Processes F1 Setup Response allocated by aper_decoder
11968 *
11969 * @details
11970 *
11971 *    Function : freeF1SetupRsp
11972 *
11973 *    Functionality: free F1 Setup Response allocated by aper_decoder
11974 *
11975 * @params[in] F1SetupResponse_t *f1SetRspMsg
11976 * @return void
11977 *
11978 * ****************************************************************/
11979
11980 void freeAperDecodeF1SetupRsp(F1SetupResponse_t *f1SetRspMsg)
11981 {
11982    uint8_t ieIdx =0;
11983    uint8_t arrIdx =0;
11984    Cells_to_be_Activated_List_t *cellToActivate =NULLP;
11985    RRC_Version_t      *rrcVer =NULLP;
11986
11987    if(f1SetRspMsg->protocolIEs.list.array)
11988    {
11989       for(ieIdx=0; ieIdx<f1SetRspMsg->protocolIEs.list.count; ieIdx++)
11990       {
11991          if(f1SetRspMsg->protocolIEs.list.array[ieIdx])
11992          {
11993             switch(f1SetRspMsg->protocolIEs.list.array[ieIdx]->id)
11994             {
11995                case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11996                   {
11997                      cellToActivate =
11998                         &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.Cells_to_be_Activated_List;
11999                      if(cellToActivate->list.array)
12000                      {
12001                         for(arrIdx=0; arrIdx<cellToActivate->list.count ; arrIdx++)
12002                         {
12003                            if(cellToActivate->list.array[arrIdx])
12004                            {
12005
12006                               if(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.\
12007                               pLMN_Identity.buf)
12008                               {
12009                                  if(cellToActivate->list.array[0]->value.choice.\
12010                                        Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf)
12011                                  {
12012                                     free(cellToActivate->list.array[0]->value.choice.\
12013                                           Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf);
12014                                  }
12015
12016                                  free(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
12017                                        nRCGI.pLMN_Identity.buf);
12018                               }
12019                               free(cellToActivate->list.array[arrIdx]);
12020                            }
12021                         }
12022                         free(cellToActivate->list.array);
12023                      }
12024                      break;
12025                   }
12026                case ProtocolIE_ID_id_TransactionID:
12027                   {
12028                      break;
12029                   }
12030                case ProtocolIE_ID_id_gNB_CU_Name:
12031                   {
12032                      free(f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_Name.buf);
12033                      break;
12034                   }
12035                case ProtocolIE_ID_id_GNB_CU_RRC_Version:
12036                   {
12037                      rrcVer = &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
12038                      if(rrcVer->latest_RRC_Version.buf)
12039                      {
12040                         if(rrcVer->iE_Extensions)
12041                         {
12042                            if(rrcVer->iE_Extensions->list.array)
12043                            {
12044                               if(rrcVer->iE_Extensions->list.array[0])
12045                               {
12046                                  if(rrcVer->iE_Extensions->list.\
12047                                        array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf)
12048                                  {
12049                                     free(rrcVer->iE_Extensions->list.\
12050                                           array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf);
12051                                  }
12052                                  free(rrcVer->iE_Extensions->list.array[0]);
12053                               }
12054                               free(rrcVer->iE_Extensions->list.array);
12055                            }
12056                            free(rrcVer->iE_Extensions);
12057                         }
12058                         free(rrcVer->latest_RRC_Version.buf);
12059                      }
12060                      break;
12061
12062                   }
12063                default:
12064                   {
12065                      DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
12066                            f1SetRspMsg->protocolIEs.list.array[ieIdx]->id);
12067                   }
12068             }
12069             free(f1SetRspMsg->protocolIEs.list.array[ieIdx]);
12070          }
12071       }
12072       free(f1SetRspMsg->protocolIEs.list.array);
12073    }
12074 }
12075 /******************************************************************
12076  *
12077  * @brief Processes F1 Setup Response sent by CU
12078  *
12079  * @details
12080  *
12081  *    Function : procF1SetupRsp
12082  *
12083  *    Functionality: Processes F1 Setup Response sent by CU
12084  *
12085  * @params[in] F1AP_PDU_t ASN decoded F1AP message
12086  * @return ROK     - success
12087  *         RFAILED - failure
12088  *
12089  * ****************************************************************/
12090 uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg)
12091 {
12092    uint8_t ret = ROK;
12093    uint16_t idx =0;
12094    F1SetupResponse_t *f1SetRspMsg = NULLP;
12095    GNB_CU_Name_t     *cuName = NULLP;
12096    F1SetupRsp  f1SetRspDb;
12097    RRC_Version_t      *rrcVer =NULLP;
12098
12099    memset(&f1SetRspDb, 0, sizeof(F1SetupRsp));
12100
12101    DU_LOG("\nINFO   -->  F1AP : F1 Setup Response received");
12102    f1SetRspMsg = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
12103
12104    for(idx=0; idx<f1SetRspMsg->protocolIEs.list.count; idx++)
12105    {
12106       switch(f1SetRspMsg->protocolIEs.list.array[idx]->id)
12107       {
12108          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
12109             {
12110                extractCellsToBeActivated(f1SetRspMsg->protocolIEs.list.array[idx]->\
12111                      value.choice.Cells_to_be_Activated_List);
12112                break;
12113             }
12114          case ProtocolIE_ID_id_TransactionID:
12115             {
12116                f1SetRspDb.transId = f1SetRspMsg->protocolIEs.list.array[idx]->\
12117                                     value.choice.TransactionID;
12118                break;
12119             }
12120          case ProtocolIE_ID_id_gNB_CU_Name:
12121             {
12122                cuName = &f1SetRspMsg->protocolIEs.list.array[idx]->\
12123                         value.choice.GNB_CU_Name;
12124                strcpy(f1SetRspDb.cuName, (const char*)cuName->buf);
12125                break;
12126             }
12127          case ProtocolIE_ID_id_GNB_CU_RRC_Version:
12128             {
12129                rrcVer = &f1SetRspMsg->protocolIEs.list.array[idx]->value.choice.RRC_Version;
12130                strcpy(f1SetRspDb.rrcVersion.rrcVer,
12131                      (const char*)rrcVer->latest_RRC_Version.buf);
12132                break;
12133             }
12134          default:
12135             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
12136                   f1SetRspMsg->protocolIEs.list.array[idx]->id);
12137       }
12138       duProcF1SetupRsp();
12139    }
12140
12141    freeAperDecodeF1SetupRsp(f1SetRspMsg);
12142    return ret;
12143 }
12144 /*******************************************************************
12145 *
12146 * @brief free GNB DU config update ack
12147 *
12148 * @details
12149 *
12150 *    Function : freeAperDecodeGnbDuAck
12151 *
12152 *    Functionality: Processes GNB DU config update ack And
12153 *                     added free part for the memory allocated by aper_decoder
12154 *
12155 * @params[in] F1AP_PDU_t ASN decoded F1AP message
12156 * @return ROK     - success
12157 *         RFAILED - failure
12158 *
12159 * ****************************************************************/
12160
12161 void freeAperDecodeGnbDuAck(GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck)
12162 {
12163    uint8_t ieIdx = 0;
12164
12165    if(gnbDuAck->protocolIEs.list.array)
12166    {
12167       for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
12168       {
12169          if(gnbDuAck->protocolIEs.list.array[ieIdx])
12170          {
12171             free(gnbDuAck->protocolIEs.list.array[ieIdx]);
12172          }
12173       }
12174       free(gnbDuAck->protocolIEs.list.array);
12175    }
12176 }
12177
12178 /*******************************************************************
12179 *
12180 * @brief Building  result of gnb-du config update ack output
12181 *
12182 * @details
12183 *
12184 *    Function : duProcGnbDuCfgUpdAckMsg
12185 *
12186 *    Functionality:
12187 *        Building output of gnb-du config update ack
12188 *
12189 * @params[in] transId
12190 * @return void
12191 *
12192 * ****************************************************************/
12193
12194 uint8_t duProcGnbDuCfgUpdAckMsg(uint8_t transId)
12195 {
12196    uint8_t  ieIdx=0, arrIdx=0,ret=ROK;
12197    uint8_t  ueId =0 , ueIdx =0, totalActiveUe = 0;
12198    uint16_t cellId =0, cellIdx =0, crnti=0;
12199    CmLList *f1apPduNode = NULLP;
12200    ReservedF1apPduInfo *f1apPduInfo =NULLP;
12201    F1AP_PDU_t *f1apMsgPdu = NULLP;
12202    GNBDUConfigurationUpdate_t *gnbDuConfigUpdate = NULLP;
12203    BIT_STRING_t *cellIdentity=NULLP;
12204    struct Served_Cells_To_Delete_ItemIEs *deleteItemIe=NULLP;
12205    Served_Cells_To_Delete_List_t *cellsToDelete=NULLP;
12206    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
12207
12208    DU_LOG("\nINFO   -->  DU APP: GNB-DU config update Ack received ");
12209    f1apPduNode = searchFromReservedF1apPduList(transId);
12210    f1apPduInfo = (ReservedF1apPduInfo *)f1apPduNode->node;
12211    f1apMsgPdu = (F1AP_PDU_t *)f1apPduInfo->f1apMsg;
12212
12213    if(f1apMsgPdu)
12214    {
12215       if(f1apMsgPdu->choice.initiatingMessage)
12216       {
12217          gnbDuConfigUpdate = &f1apMsgPdu->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
12218          for(ieIdx=0; ieIdx < gnbDuConfigUpdate->protocolIEs.list.count; ieIdx++)
12219          {
12220             switch(gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->id)
12221             {
12222                case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
12223                   {
12224                      cellsToDelete = &gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
12225                                      Served_Cells_To_Delete_List;
12226                      if(cellsToDelete->list.array)
12227                      {
12228                         if(cellsToDelete->list.array[arrIdx])
12229                         {
12230                            deleteItemIe = (Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx];
12231                            deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
12232                            if(deleteItem->oldNRCGI.nRCellIdentity.buf)
12233                            {
12234                               cellIdentity = &deleteItem->oldNRCGI.nRCellIdentity;
12235                               bitStringToInt(cellIdentity, &cellId);
12236                            }
12237                         }
12238                      }
12239
12240                      GET_CELL_IDX(cellId, cellIdx);
12241                      if(duCb.actvCellLst[cellIdx] != NULLP)
12242                      {
12243                         if(duCb.actvCellLst[cellIdx]->numActvUes == 0)
12244                         {
12245                            duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
12246                            ret = duSendCellDeletReq(cellId);
12247                            if(ret == RFAILED)
12248                            {
12249                               DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to send cell delete\
12250                               request for cellId[%d]", cellId);
12251                            }
12252                         }
12253                         else
12254                         {
12255                            totalActiveUe = duCb.actvCellLst[cellIdx]->numActvUes;
12256                            while(totalActiveUe)
12257                            {
12258                               if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].ueState != UE_ACTIVE)
12259                               {
12260                                  ueIdx++;
12261                                  continue;
12262                               }
12263
12264                               crnti = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].crnti;
12265                               GET_UE_IDX(crnti,ueId);
12266                               /* Sending Ue Context release request only for maximum supporting UEs */
12267                               ret = BuildAndSendUeContextReleaseReq(cellId, ueId);
12268                               if(ret == RFAILED)
12269                               {
12270                                  DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to build and send UE delete\
12271                                  request for cellId[%d]", cellId);
12272                               }
12273                               ueIdx++;
12274                               totalActiveUe--;
12275                            }
12276                         }
12277                      }
12278                      else
12279                      {
12280                         DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): CellId [%d] not found", cellId);
12281                         ret = RFAILED;
12282                      }
12283                      break;
12284                   }
12285
12286                default:
12287                   break;
12288             }
12289          }
12290       }
12291    }
12292
12293    FreeDUConfigUpdate(f1apMsgPdu);
12294    deleteFromReservedF1apPduList(f1apPduNode);
12295    return ret;
12296 }
12297
12298 /*******************************************************************
12299 *
12300 * @brief Processes GNB DU config update ack
12301 *
12302 * @details
12303 *
12304 *    Function : procF1GNBDUCfgUpdAck
12305 *
12306 *    Functionality: added free part for the memory allocated by aper_decoder
12307 *
12308 * @params[in] F1AP_PDU_t *f1apMsg
12309 * @return void
12310 *
12311 * ****************************************************************/
12312 uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
12313 {
12314    uint8_t ieIdx=0,transId=0;
12315    GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
12316
12317    DU_LOG("\nINFO   -->  F1AP : GNB-DU config update acknowledgment");
12318    gnbDuAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
12319
12320    for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
12321    {
12322       switch(gnbDuAck->protocolIEs.list.array[ieIdx]->id)
12323       {
12324          case ProtocolIE_ID_id_TransactionID:
12325             {
12326                transId = gnbDuAck->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
12327                break;
12328             }
12329          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
12330             {
12331                break;
12332             }
12333          default :
12334             {
12335                DU_LOG("\nERROR  -->  F1AP: procF1GNBDUCfgUpdAck(): Invalid IE Received: %ld", \
12336                      gnbDuAck->protocolIEs.list.array[ieIdx]->id);
12337                break;
12338             }
12339       }
12340    }
12341
12342    duProcGnbDuCfgUpdAckMsg(transId);
12343
12344 #if 0
12345    /* presently we are not supporting F1 Reset from DU to CU , we are only
12346     * supporting F1 Reset from CU to DU */
12347
12348    if(BuildAndSendF1ResetReq() != ROK)
12349    {
12350       return RFAILED;
12351    }
12352 #endif
12353
12354    freeAperDecodeGnbDuAck(gnbDuAck);
12355    return ROK;
12356 }
12357 /******************************************************************
12358 *
12359 * @brief free DL RRC Message Transfer allocated by aper_decoder
12360 *
12361 * @details
12362 *
12363 *    Function : freeAperDecodef1DlRrcMsg
12364 *
12365 *    Functionality: free DL RRC Message Transfer allocated by aper_decoder
12366 *
12367 * @params[in] DLRRCMessageTransfer_t *f1DlRrcMsg
12368 * @return ROK     - success
12369 *         RFAILED - failure
12370 *
12371 * ****************************************************************/
12372
12373 void freeAperDecodef1DlRrcMsg(DLRRCMessageTransfer_t *f1DlRrcMsg)
12374 {
12375    uint8_t ieIdx =0;
12376    RRCContainer_t *rrcContainer = NULLP;
12377
12378    if(f1DlRrcMsg->protocolIEs.list.array)
12379    {
12380       for(ieIdx=0; ieIdx<f1DlRrcMsg->protocolIEs.list.count; ieIdx++)
12381       {
12382          if(f1DlRrcMsg->protocolIEs.list.array[ieIdx])
12383          {
12384             switch(f1DlRrcMsg->protocolIEs.list.array[ieIdx]->id)
12385             {
12386                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12387                   break;
12388                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12389                   break;
12390                case ProtocolIE_ID_id_SRBID:
12391                   break;
12392                case ProtocolIE_ID_id_RRCContainer:
12393                   {
12394                      rrcContainer =&f1DlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
12395                      free(rrcContainer->buf);
12396                   }
12397                case ProtocolIE_ID_id_ExecuteDuplication:
12398                   break;
12399                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
12400                   break;
12401                   break;
12402             }
12403             free(f1DlRrcMsg->protocolIEs.list.array[ieIdx]);
12404          }
12405       }
12406       free(f1DlRrcMsg->protocolIEs.list.array);
12407    }
12408 }
12409 /******************************************************************
12410  *
12411  * @brief Processes DL RRC Message Transfer  sent by CU
12412  *
12413  * @details
12414  *
12415  *    Function : procF1DlRrcMsgTrans
12416  *
12417  *    Functionality: Processes DL RRC Message Transfer sent by CU
12418  *
12419  * @params[in] F1AP_PDU_t ASN decoded F1AP message
12420  * @return ROK     - success
12421  *         RFAILED - failure
12422  *
12423  * ****************************************************************/
12424 uint8_t procF1DlRrcMsgTrans(F1AP_PDU_t *f1apMsg)
12425 {
12426    uint8_t  idx, ret;
12427    DLRRCMessageTransfer_t *f1DlRrcMsg = NULLP;
12428    F1DlRrcMsg dlMsg;
12429    memset(&dlMsg, 0, sizeof(F1DlRrcMsg));
12430
12431    DU_LOG("\nINFO   -->  DU_APP : DL RRC message transfer Recevied");
12432    f1DlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
12433
12434    ret = ROK;
12435
12436    for(idx=0; idx<f1DlRrcMsg->protocolIEs.list.count; idx++)
12437    {
12438       switch(f1DlRrcMsg->protocolIEs.list.array[idx]->id)
12439       {
12440          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12441             {
12442                dlMsg.gnbCuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
12443                break;
12444             }
12445          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12446             {
12447                dlMsg.gnbDuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
12448                break;
12449             }
12450          case ProtocolIE_ID_id_SRBID:
12451             {
12452                dlMsg.srbId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
12453                break;
12454             }
12455          case ProtocolIE_ID_id_ExecuteDuplication:
12456             dlMsg.execDup = true;
12457             break;
12458
12459          case ProtocolIE_ID_id_RRCContainer:
12460             {
12461                if(f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0)
12462                {
12463                   dlMsg.rrcMsgSize = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
12464                   DU_ALLOC_SHRABL_BUF(dlMsg.rrcMsgPdu, dlMsg.rrcMsgSize);
12465                   if(dlMsg.rrcMsgPdu)
12466                   {
12467                      memcpy(dlMsg.rrcMsgPdu, f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
12468                         dlMsg.rrcMsgSize);
12469                   }
12470                   else
12471                   {
12472                      DU_LOG("\nERROR  -->  DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
12473                      return RFAILED;
12474                   }
12475                }
12476                else
12477                {
12478                   DU_LOG("\nERROR  -->  DU_APP : RRC Container Size is invalid:%ld",\
12479                   f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
12480                   return RFAILED;
12481                }
12482                break;
12483             }
12484          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
12485             {
12486                dlMsg.deliveryStatRpt = true;
12487                break;
12488             }
12489          default:
12490             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
12491                   f1DlRrcMsg->protocolIEs.list.array[idx]->id);
12492       }
12493    }
12494
12495    ret = duProcDlRrcMsg(&dlMsg);
12496
12497    freeAperDecodef1DlRrcMsg(f1DlRrcMsg);
12498    return ret;
12499 }
12500 /*******************************************************************
12501  *
12502 * @brief Builds the DRB to be Setup Mod list
12503 *
12504 * @details
12505 *
12506 *    Function :
12507 *
12508 *    Functionality: Constructs the DRB to be Setup Mod list
12509 *
12510 * @params[in] DRBs_SetupMod_List_t *drbSet
12511 *
12512 * @return ROK     - success
12513 *         RFAILED - failure
12514 *
12515 * ****************************************************************/
12516
12517 uint8_t BuildDrbSetupModList(DRBs_SetupMod_List_t *drbSet , DuUeCfg *ueCfg)
12518 {
12519    uint8_t arrIdx =0;
12520    uint8_t drbCnt =0;
12521    struct DRBs_SetupMod_ItemIEs *drbItemIe;
12522
12523    drbCnt = 1;
12524    drbSet->list.count = drbCnt;
12525    drbSet->list.size = drbCnt * sizeof(DRBs_SetupMod_ItemIEs_t *);
12526    DU_ALLOC(drbSet->list.array, drbSet->list.size);
12527    if(drbSet->list.array == NULLP)
12528    {
12529       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
12530       return  RFAILED;
12531    }
12532    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
12533    {
12534       DU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
12535       if(drbSet->list.array[arrIdx] == NULLP)
12536       {
12537               DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
12538               return  RFAILED;
12539       }
12540
12541       drbItemIe = (struct DRBs_SetupMod_ItemIEs *)drbSet->list.array[arrIdx];
12542       drbItemIe->id = ProtocolIE_ID_id_DRBs_SetupMod_Item;
12543       drbItemIe->criticality = Criticality_reject;
12544       drbItemIe->value.present = DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item;
12545       drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
12546       if(fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List,\
12547       &ueCfg->upTnlInfo[arrIdx])!= ROK)
12548       {
12549          DU_LOG("\nERROR  -->  F1AP : Failed to fill DlTnl SetupList in BuildDrbToBeSetupModList");
12550          return RFAILED;
12551       }
12552
12553    }
12554
12555    return ROK;
12556 }
12557 /*******************************************************************
12558 * @brief Free the memory allocated for DRB setup List
12559 *
12560 * @details
12561 *
12562 *    Function : FreeDrbSetupModList
12563 *
12564 *    Functionality:
12565 *       Free the memory allocated for DRB setup list
12566 *
12567 * @params[in] DRBs_Setup_List_t *
12568 * @return void
12569 *
12570 * ****************************************************************/
12571 void FreeDrbSetupModList(DRBs_SetupMod_List_t *drbSetupList)
12572 {
12573    uint8_t arrIdx = 0;
12574    DRBs_SetupMod_ItemIEs_t *drbItemIe = NULLP;
12575
12576    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
12577    {
12578       drbItemIe = ((DRBs_SetupMod_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
12579       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
12580       DU_FREE(drbSetupList->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
12581    }
12582    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
12583 }
12584 /*******************************************************************
12585 * @brief Free the memory allocated for UE Context Mod Response
12586 *
12587 * @details
12588 *
12589 *    Function : FreeUeContextModResp
12590 *
12591 *    Functionality:
12592 *       Free the memory allocated for UE Context Mod Response
12593 *
12594 * @params[in] F1AP_PDU_t *f1apMsg
12595 * @return void
12596 *
12597 * ****************************************************************/
12598
12599 void FreeUeContextModResp(F1AP_PDU_t *f1apMsg)
12600 {
12601    uint8_t ieIdx;
12602    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
12603    if(f1apMsg)
12604    {
12605       if(f1apMsg->choice.successfulOutcome)
12606       {
12607          ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
12608          if(ueContextModifyRes->protocolIEs.list.array)
12609          {
12610             for(ieIdx=0 ; ieIdx<ueContextModifyRes->protocolIEs.list.count; ieIdx++)
12611             {
12612                if(ueContextModifyRes->protocolIEs.list.array[ieIdx])
12613                {
12614                   switch(ueContextModifyRes->protocolIEs.list.array[ieIdx]->id)
12615                   {
12616                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12617                         break;
12618                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12619                         break;
12620                      case ProtocolIE_ID_id_DRBs_SetupMod_List:
12621                         {
12622                             FreeDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
12623                             value.choice.DRBs_SetupMod_List));
12624                             break;
12625                         }
12626                   }
12627                   DU_FREE(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
12628                }
12629
12630             }
12631             DU_FREE(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
12632          }
12633          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12634       }
12635       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12636    }
12637 }
12638
12639 /*****************************************************************i
12640 *
12641 * @brief Creating the ue context modifcation response and sending
12642 *
12643 * @details
12644 *
12645 *    Function : BuildAndSendUeContextModRsp
12646 *
12647 *    Functionality:
12648 *         - Creating the ue context modifcation response
12649 *
12650 * @params[in] uint8_t cellId,uint8_t ueIdx
12651 * @return ROK     - success
12652 *         RFAILED - failure
12653 *
12654 * ****************************************************************/
12655 uint8_t BuildAndSendUeContextModRsp(uint8_t cellId,uint8_t ueIdx)
12656 {
12657    uint8_t   ieIdx = 0;
12658    uint8_t   cellIdx =0;
12659    uint8_t   elementCnt = 0;
12660    uint8_t   ret = RFAILED;
12661    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
12662    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
12663    F1AP_PDU_t *f1apMsg = NULLP;
12664    asn_enc_rval_t         encRetVal;
12665    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
12666    DuUeCb                   *ueCb = NULLP;
12667
12668    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification response\n");
12669
12670    while(1)
12671    {
12672       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12673       if(f1apMsg == NULLP)
12674       {
12675          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
12676          break;
12677       }
12678
12679       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
12680
12681       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12682       if(f1apMsg->choice.successfulOutcome == NULLP)
12683       {
12684          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
12685          break;
12686       }
12687       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextModification;
12688       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
12689       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_UEContextModificationResponse;
12690
12691       ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
12692
12693       elementCnt = 3;
12694       ueContextModifyRes->protocolIEs.list.count = elementCnt;
12695       ueContextModifyRes->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationResponse_t*);
12696
12697       /* Initialize the UE context modification members */
12698       DU_ALLOC(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
12699       if(ueContextModifyRes->protocolIEs.list.array == NULLP)
12700       {
12701          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
12702          break;
12703       }
12704
12705       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
12706       {
12707          DU_ALLOC(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
12708          if(ueContextModifyRes->protocolIEs.list.array[ieIdx] == NULLP)
12709          {
12710             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
12711             break;
12712          }
12713       }
12714
12715       /* Fetching Ue Cb Info*/
12716       GET_CELL_IDX(cellId, cellIdx);
12717       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
12718       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
12719       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
12720
12721       ieIdx=0;
12722       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
12723       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12724       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
12725       UEContextModificationResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
12726       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
12727
12728       ieIdx++;
12729       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
12730       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12731       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present=\
12732       UEContextModificationResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
12733       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
12734
12735       ieIdx++;
12736       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_SetupMod_List;
12737       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12738       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
12739       UEContextModificationResponseIEs__value_PR_DRBs_SetupMod_List;
12740       if(ueCb->f1UeDb)
12741       {
12742          ret = BuildDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
12743                   value.choice.DRBs_SetupMod_List) , &ueCb->f1UeDb->duUeCfg);
12744          if(ret != ROK)
12745          {
12746             DU_LOG( "\nERROR  -->  F1AP : Failed to build drb setupmod List ");
12747             break;
12748          }
12749          freeF1UeDb(ueCb->f1UeDb);
12750          ueCb->f1UeDb = NULLP;
12751       }
12752       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12753
12754       /* Encode the F1SetupRequest type as APER */
12755       memset(encBuf, 0, ENC_BUF_MAX_LEN);
12756       encBufSize = 0;
12757       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,encBuf);
12758
12759       /* Encode results */
12760       if(encRetVal.encoded == ENCODE_FAIL)
12761       {
12762          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
12763                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12764          ret = RFAILED;
12765          break;
12766       }
12767       else
12768       {
12769          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Modification Response\n");
12770          for(int i=0; i< encBufSize; i++)
12771          {
12772             printf("%x",encBuf[i]);
12773          }
12774       }
12775
12776       /* Sending  msg  */
12777       if(sendF1APMsg() != ROK)
12778       {
12779          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Res Failed");
12780          ret = RFAILED;
12781          break;
12782       }
12783       break;
12784    }
12785    FreeUeContextModResp(f1apMsg);
12786    return ret;
12787 }
12788 /*******************************************************************
12789  *
12790  * @brief Deallocating the memory allocated by the aper decoder
12791  *          for QOSInfo
12792  *
12793  * @details
12794  *
12795  *    Function : freeAperDecodeQosInfo
12796  *
12797  *    Functionality:  Deallocating the memory allocated for QOSInfo
12798  *
12799  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
12800  *
12801  * @return void
12802  *
12803  * ****************************************************************/
12804
12805 void freeAperDecodeQosInfo(QoSFlowLevelQoSParameters_t *drbQos)
12806 {
12807    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
12808    {
12809       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
12810       {
12811          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
12812          {
12813             free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
12814          }
12815          free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
12816       }
12817       free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI);
12818    }
12819 }
12820 /*******************************************************************
12821  *
12822  * @brief Deallocating the memory allocated by the aper decoder
12823  *          for UlTnlInfoforDrb
12824  *
12825  * @details
12826  *
12827  *    Function : freeAperDecodeUlTnlInfoforDrbSetupMod
12828  *
12829  *    Functionality:  Deallocating memory allocated for UlTnlInfoforDrb
12830  *
12831  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
12832  *
12833  * @return void
12834  *
12835  * ****************************************************************/
12836 void freeAperDecodeUlTnlInfoforDrbSetupMod(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
12837 {
12838    uint8_t arrIdx =0;
12839
12840    if(ulInfo->list.array)
12841    {
12842       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
12843       {
12844          if(ulInfo->list.array[arrIdx])
12845          {
12846             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
12847             {
12848                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
12849                {
12850                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
12851                   {
12852                      free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12853                            gTP_TEID.buf);
12854                   }
12855                   free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12856                         transportLayerAddress.buf);
12857                }
12858                free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel);
12859             }
12860             free(ulInfo->list.array[arrIdx]);
12861          }
12862       }
12863       free(ulInfo->list.array);
12864    }
12865 }
12866 /*******************************************************************
12867  *
12868  * @brief Deallocating the memory allocated by the aper decoder
12869  *          for DrbSetupModItem
12870  *
12871  * @details
12872  *
12873  *    Function : freeAperDecodeDrbSetupModItem
12874  *
12875  *    Functionality:  Deallocating memory allocated for DrbSetupModItem
12876  *
12877  * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
12878  *
12879  * @return void
12880  *
12881  * ****************************************************************/
12882
12883 void freeAperDecodeDrbSetupModItem(DRBs_ToBeSetupMod_Item_t *drbItem)
12884 {
12885    uint8_t arrIdx =0;
12886    SNSSAI_t *snssai =NULLP;
12887    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
12888
12889    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
12890    switch(drbItem->qoSInformation.present)
12891    {
12892       case QoSInformation_PR_NOTHING:
12893          break;
12894       case QoSInformation_PR_eUTRANQoS:
12895          {
12896             if(drbItem->qoSInformation.choice.eUTRANQoS)
12897             {
12898                free(drbItem->qoSInformation.choice.eUTRANQoS);
12899             }
12900             break;
12901          }
12902       case QoSInformation_PR_choice_extension:
12903          {
12904             if(drbItem->qoSInformation.choice.choice_extension)
12905             {
12906                freeAperDecodeQosInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.\
12907                      DRB_Information.dRB_QoS);
12908                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
12909                if(snssai->sST.buf)
12910                {
12911                   free(snssai->sST.buf);
12912                }
12913                if(snssai->sD)
12914                {
12915                   if(snssai->sD->buf)
12916                   {
12917                      free(snssai->sD->buf);
12918                   }
12919                   free(snssai->sD);
12920                }
12921
12922                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.\
12923                          DRB_Information.flows_Mapped_To_DRB_List;
12924                if(flowMap->list.array)
12925                {
12926                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
12927                   {
12928                      if(flowMap->list.array[arrIdx] )
12929                      {
12930                         freeAperDecodeQosInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
12931                         free(flowMap->list.array[arrIdx]);
12932                      }
12933                   }
12934                   free(flowMap->list.array);
12935                }
12936
12937                free(drbItem->qoSInformation.choice.choice_extension);
12938             }
12939             break;
12940          }
12941
12942    }
12943    freeAperDecodeUlTnlInfoforDrbSetupMod(&drbItem->uLUPTNLInformation_ToBeSetup_List);
12944    if(drbItem->uLConfiguration)
12945    {
12946       free(drbItem->uLConfiguration);
12947    }
12948 }
12949
12950 /*******************************************************************
12951  *
12952  * @brief Deallocating the memory allocated by the aper decoder
12953  *          for DrbToBeSetupModList
12954  *
12955  * @details
12956  *
12957  *    Function : freeAperDecodeDrbToBeSetupModList
12958  *
12959  *    Functionality:  Deallocating memory allocated for DrbToBeSetupModList
12960  *
12961  * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
12962  *
12963  * @return void
12964  *
12965  * ****************************************************************/
12966
12967 void freeAperDecodeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
12968 {
12969    uint8_t arrIdx =0;
12970    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
12971
12972    if(drbSet->list.array)
12973    {
12974       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
12975       {
12976          if(drbSet->list.array[arrIdx] != NULLP)
12977          {
12978             if(arrIdx == 0)
12979             {
12980                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
12981                freeAperDecodeDrbSetupModItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
12982             }
12983             free(drbSet->list.array[arrIdx]);
12984          }
12985       }
12986       free(drbSet->list.array);
12987    }
12988
12989 }
12990 /*******************************************************************
12991  *
12992  * @brief Deallocating the memory allocated by the aper decoder
12993  *          for UeContextModificationReqMsg
12994  *
12995  * @details
12996  *
12997  *    Function : freeAperDecodeUeContextModificationReqMsg
12998  *
12999  *    Functionality:  Deallocating memory allocated for
13000  *                  UeContextModificationReqMsg
13001  *
13002  * @params[in] UEContextModificationRequest_t *UeContextModifyReq
13003  *
13004  * @return void
13005  *
13006  * ****************************************************************/
13007 void freeAperDecodeUeContextModificationReqMsg(UEContextModificationRequest_t *UeContextModifyReq )
13008 {
13009    uint8_t arrIdx, ieId;
13010
13011    if(UeContextModifyReq->protocolIEs.list.array)
13012    {
13013       for( arrIdx = 0 ; arrIdx<UeContextModifyReq->protocolIEs.list.count ; arrIdx++)
13014       {
13015          if(UeContextModifyReq->protocolIEs.list.array[arrIdx])
13016          {
13017             ieId = UeContextModifyReq->protocolIEs.list.array[arrIdx]->id;
13018             switch(ieId)
13019             {
13020                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13021                   break;
13022                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13023                   break;
13024                case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
13025                   {
13026                      freeAperDecodeDrbToBeSetupModList(&UeContextModifyReq->protocolIEs.list.array[arrIdx]->\
13027                            value.choice.DRBs_ToBeSetupMod_List);
13028                      break;
13029                   }
13030             }
13031             free(UeContextModifyReq->protocolIEs.list.array[arrIdx]);
13032          }
13033       }
13034       free(UeContextModifyReq->protocolIEs.list.array);
13035    }
13036 }
13037 /*******************************************************************
13038  *
13039  * @brief processing the F1 UeContextModificationReq
13040  *
13041  * @details
13042  *
13043  *    Function : procF1UeContextModificationReq
13044  *
13045  *    Functionality:  processing the F1 UeContextModificationReq
13046  *
13047  * @params[in] F1AP_PDU_t *f1apMsg
13048  *
13049  * @return
13050  * ****************************************************************/
13051 uint8_t procF1UeContextModificationReq(F1AP_PDU_t *f1apMsg)
13052 {
13053    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
13054    uint8_t  ret = ROK, ieIdx = 0, cellIdx=0, ueIdx=0;
13055    DuUeCb   *duUeCb = NULLP;
13056    DRBs_ToBeSetupMod_List_t *drbSetupModCfg;
13057    DRBs_ToBeModified_List_t *drbModifiedCfg;
13058    uint32_t gnbCuUeF1apId, gnbDuUeF1apId;
13059
13060    ueContextModifyReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
13061    for(ieIdx=0; (ieIdx < ueContextModifyReq->protocolIEs.list.count && ret == ROK); ieIdx++)
13062    {
13063       switch(ueContextModifyReq->protocolIEs.list.array[ieIdx]->id)
13064       {
13065          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13066             {
13067                gnbCuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
13068                break;
13069             }
13070          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13071             {
13072                gnbDuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
13073                break;
13074             }
13075          case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
13076          case ProtocolIE_ID_id_DRBs_ToBeModified_List:
13077             {
13078                for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
13079                {
13080                   for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
13081                   {
13082                      if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
13083                            (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
13084                      {
13085
13086                         duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
13087                         if(duUeCb->f1UeDb == NULLP)
13088                         {
13089                            DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
13090                         }
13091                         if(duUeCb->f1UeDb)
13092                         {
13093                            duUeCb->f1UeDb->actionType = UE_CTXT_MOD;
13094                            if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present ==\
13095                                  UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List)
13096                            {
13097                               drbSetupModCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
13098                               choice.DRBs_ToBeSetupMod_List;
13099
13100                               if(extractDrbListToSetupMod(NULL, drbSetupModCfg, NULL, drbSetupModCfg->list.count,\
13101                               &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, NULL))
13102                               {
13103                                  DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbSetupModList");
13104                                  ret = RFAILED;
13105                               }
13106                            }
13107
13108                            if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present == \
13109                                   UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List)
13110
13111                            {
13112                               drbModifiedCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
13113                               choice.DRBs_ToBeModified_List;
13114                               if(extractDrbListToSetupMod(NULL, NULL, drbModifiedCfg, drbSetupModCfg->list.count,\
13115                                  &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, &duUeCb->rlcUeCfg))
13116                               {
13117                                  DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbModifiedList");
13118                                  ret = RFAILED;
13119                               }
13120                            }
13121                         }
13122                         break;
13123                      }
13124                   }
13125                   if(ueIdx >= duCb.actvCellLst[cellIdx]->numActvUes)
13126                   {
13127                      DU_LOG("\nERROR  -->  DU APP : wrong values of gnbCuUeF1apId and gnbDuUeF1apId ");
13128                      ret = RFAILED;
13129                   }
13130                }
13131                break;
13132             }
13133       }
13134    }
13135    if(ret != RFAILED)
13136    {
13137       ret = duProcUeContextModReq(duUeCb);
13138    }
13139    freeAperDecodeUeContextModificationReqMsg(ueContextModifyReq);
13140    return ret;
13141 }
13142 /*****************************************************************i
13143 *
13144 * @brief Free memory allocated for UE Context Release Request
13145 *
13146 * @details
13147 *
13148 *    Function : FreeUeContextReleaseReq
13149 *
13150 *    Functionality:
13151 *         - Free memory allocated for UE Context Release Request
13152 *
13153 * @params[in] F1AP_PDU_t *f1apMsg
13154 * @return void
13155 *
13156 * *************************************************************/
13157 void FreeUeContextReleaseReq(F1AP_PDU_t *f1apMsg)
13158 {
13159    uint8_t ieIdx;
13160    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
13161
13162    if(f1apMsg)
13163    {
13164       if(f1apMsg->choice.initiatingMessage)
13165       {
13166          ueReleaseReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
13167          if(ueReleaseReq->protocolIEs.list.array)
13168          {
13169             for(ieIdx=0 ; ieIdx<ueReleaseReq->protocolIEs.list.count; ieIdx++)
13170             {
13171                DU_FREE(ueReleaseReq->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseRequest_t));
13172             }
13173             DU_FREE(ueReleaseReq->protocolIEs.list.array, ueReleaseReq->protocolIEs.list.size);
13174          }
13175          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
13176       }
13177       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
13178    }
13179
13180 }
13181 /*****************************************************************i
13182 *
13183 * @brief Build and Send UE Context Release Request
13184 *
13185 * @details
13186 *
13187 *    Function : BuildAndSendUeContextReleaseReq
13188 *
13189 *    Functionality:
13190 *         - Build and Send UE Context Release Request
13191 *
13192 * @params[in]
13193 * @return ROK     - success
13194 *         RFAILED - failure
13195 *
13196 * *************************************************************/
13197 uint8_t BuildAndSendUeContextReleaseReq(uint16_t cellId, uint8_t ueIdx)
13198 {
13199    bool memAllocFail = false;
13200    uint8_t ieIdx =0;
13201    uint8_t ret = RFAILED;
13202    uint16_t cellIdx =0;
13203    uint16_t crnti = 0;
13204    uint8_t  elementCnt = 0;
13205    uint32_t  gnbCuUeF1apId =0;   /* gNB-CU UE F1AP Id */
13206    uint32_t  gnbDuUeF1apId =0;   /* gNB-DU UE F1AP Id */
13207    asn_enc_rval_t encRetVal;
13208    F1AP_PDU_t *f1apMsg = NULLP;
13209    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
13210
13211    DU_LOG("\nINFO  --> Building the UE Context Release Request");
13212    do
13213    {
13214       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
13215       if(f1apMsg == NULLP)
13216       {
13217          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for f1apMsg");
13218          break;
13219       }
13220
13221       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
13222       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
13223       if(f1apMsg->choice.initiatingMessage == NULLP)
13224       {
13225          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for\
13226          initiatingMessage");
13227          break;
13228       }
13229       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextReleaseRequest;
13230       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
13231       f1apMsg->choice.initiatingMessage->value.present = \
13232       InitiatingMessage__value_PR_UEContextReleaseRequest;
13233
13234       ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
13235
13236       elementCnt = 2;
13237
13238       ueReleaseReq->protocolIEs.list.count = elementCnt;
13239       ueReleaseReq->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseRequest_t *);
13240
13241       /* Initialize the F1Setup members */
13242       DU_ALLOC(ueReleaseReq->protocolIEs.list.array,ueReleaseReq->protocolIEs.list.size);
13243       if(ueReleaseReq->protocolIEs.list.array == NULLP)
13244       {
13245          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE array");
13246          break;
13247       }
13248       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
13249       {
13250          DU_ALLOC(ueReleaseReq->protocolIEs.list.array[ieIdx],\
13251                sizeof(UEContextReleaseRequest_t));
13252          if(ueReleaseReq->protocolIEs.list.array[ieIdx] == NULLP)
13253          {
13254             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE elements");
13255             memAllocFail = true;
13256             break;
13257          }
13258       }
13259       if(memAllocFail == true)
13260          break;
13261
13262       /* Fetching Ue Cb Info*/
13263       GET_CELL_IDX(cellId, cellIdx);
13264       if(duCb.actvCellLst[cellIdx] == NULLP)
13265       {
13266          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): CellId[%d] does not exist", cellId);
13267          break;
13268       }
13269       else
13270       {
13271          GET_CRNTI(crnti, ueIdx);
13272          if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].crnti != crnti)
13273          {
13274             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): crnti[%d] does not exist", crnti);
13275             break;
13276          }
13277          gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
13278          gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
13279       }
13280
13281       ieIdx=0;
13282       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
13283       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13284       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present = \
13285       UEContextReleaseRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
13286       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
13287
13288       ieIdx++;
13289       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
13290       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13291       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present =\
13292       UEContextReleaseRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
13293       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
13294
13295       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13296
13297       /* Encode the F1SetupRequest type as APER */
13298       memset(encBuf, 0, ENC_BUF_MAX_LEN);
13299       encBufSize = 0;
13300       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
13301       /* Encode results */
13302       if(encRetVal.encoded == ENCODE_FAIL)
13303       {
13304          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseRequest structure (at %s)\n",\
13305                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13306          break;
13307       }
13308       else
13309       {
13310          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseRequest\n");
13311          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
13312          {
13313             printf("%x",encBuf[ieIdx]);
13314          }
13315       }
13316
13317       /* Sending msg */
13318       if(sendF1APMsg() != ROK)
13319       {
13320          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Request failed");
13321          break;
13322       }
13323       ret = ROK;
13324       break;
13325    }while(true);
13326
13327    FreeUeContextReleaseReq(f1apMsg);
13328    return ret;
13329 }
13330 /*****************************************************************i
13331  *
13332  * @brief Free memory allocated for UE Context Release Complete
13333  *
13334  * @details
13335  *
13336  *    Function : FreeUeContextReleaseComplete
13337  *
13338  *    Functionality:
13339  *         - Free memory allocated for UE Context Release Complete
13340  *
13341  * @params[in] F1AP_PDU_t *f1apMsg
13342  * @return void
13343  *
13344  * *************************************************************/
13345 void FreeUeContextReleaseComplete(F1AP_PDU_t *f1apMsg)
13346 {
13347    uint8_t ieIdx;
13348    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
13349
13350    if(f1apMsg)
13351    {
13352       if(f1apMsg->choice.successfulOutcome)
13353       {
13354          ueReleaseComplete =&f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
13355          if(ueReleaseComplete->protocolIEs.list.array)
13356          {
13357             for(ieIdx=0 ; ieIdx<ueReleaseComplete->protocolIEs.list.count; ieIdx++)
13358             {
13359                DU_FREE(ueReleaseComplete->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseComplete_t));
13360             }
13361             DU_FREE(ueReleaseComplete->protocolIEs.list.array, ueReleaseComplete->protocolIEs.list.size);
13362          }
13363          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
13364       }
13365       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
13366    }
13367
13368 }
13369 /*****************************************************************i
13370  *
13371  * @brief Build and Send UE Context Release Complete
13372  *
13373  * @details
13374  *
13375  *    Function : BuildAndSendUeContextReleaseComplete
13376  *
13377  *    Functionality:
13378  *         - Build and Send UE Context Release Complete
13379  *
13380  * @params[in]  cellId,  gnbCuUeF1apId, gnbDuUeF1apId
13381  * @return ROK     - success
13382  *         RFAILED - failure
13383  *
13384  * *************************************************************/
13385 uint8_t BuildAndSendUeContextReleaseComplete(uint16_t cellId, uint32_t gnbCuUeF1apId, uint32_t gnbDuUeF1apId)
13386 {
13387    bool memAllocFail = false;
13388    uint8_t ieIdx =0, ret = RFAILED, elementCnt = 0;
13389    asn_enc_rval_t encRetVal;
13390    F1AP_PDU_t *f1apMsg = NULLP;
13391    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
13392
13393    DU_LOG("\nINFO  --> Building the UE Context Release Complete");
13394    do
13395    {
13396       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
13397       if(f1apMsg == NULLP)
13398       {
13399          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for f1apMsg");
13400          break;
13401       }
13402
13403       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
13404       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
13405       if(f1apMsg->choice.successfulOutcome == NULLP)
13406       {
13407          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for\
13408                successfulOutcome");
13409          break;
13410       }
13411       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextRelease;
13412       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
13413       f1apMsg->choice.successfulOutcome->value.present = \
13414       SuccessfulOutcome__value_PR_UEContextReleaseComplete;
13415
13416       ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
13417
13418       elementCnt = 2;
13419       ueReleaseComplete->protocolIEs.list.count = elementCnt;
13420       ueReleaseComplete->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseComplete_t *);
13421
13422       /* Initialize the UE Release Complete members */
13423       DU_ALLOC(ueReleaseComplete->protocolIEs.list.array,ueReleaseComplete->protocolIEs.list.size);
13424       if(ueReleaseComplete->protocolIEs.list.array == NULLP)
13425       {
13426          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE array");
13427          break;
13428       }
13429       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
13430       {
13431          DU_ALLOC(ueReleaseComplete->protocolIEs.list.array[ieIdx],\
13432                sizeof(UEContextReleaseComplete_t));
13433          if(ueReleaseComplete->protocolIEs.list.array[ieIdx] == NULLP)
13434          {
13435             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE\
13436             elements");
13437             memAllocFail = true;
13438             break;
13439          }
13440       }
13441       if(memAllocFail == true)
13442          break;
13443
13444
13445       ieIdx=0;
13446       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
13447       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13448       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present = \
13449       UEContextReleaseCompleteIEs__value_PR_GNB_CU_UE_F1AP_ID;
13450       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
13451
13452       ieIdx++;
13453       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
13454       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13455       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present =\
13456       UEContextReleaseCompleteIEs__value_PR_GNB_DU_UE_F1AP_ID;
13457       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
13458
13459       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13460
13461       /* Encode the F1SetupComplete type as APER */
13462       memset(encBuf, 0, ENC_BUF_MAX_LEN);
13463       encBufSize = 0;
13464       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
13465       /* Encode results */
13466       if(encRetVal.encoded == ENCODE_FAIL)
13467       {
13468          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseComplete structure (at %s)\n",\
13469                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13470          break;
13471       }
13472       else
13473       {
13474          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseComplete\n");
13475          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
13476          {
13477             printf("%x",encBuf[ieIdx]);
13478          }
13479       }
13480
13481       /* Sending msg */
13482       if(sendF1APMsg() != ROK)
13483       {
13484          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Complete failed");
13485          break;
13486       }
13487       ret = ROK;
13488       break;
13489    }while(true);
13490
13491    if(ret == ROK && (duCb.actvCellLst[cellId-1]->numActvUes == 0))
13492    {
13493       duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
13494       ret = duSendCellDeletReq(cellId);
13495       if(ret != ROK)
13496       {
13497          DU_LOG("\nERROR  -->  F1AP: BuildAndSendUeContextReleaseComplete(): Failed to process cell\
13498                Delete req for CellId");
13499       }
13500    }
13501    FreeUeContextReleaseComplete(f1apMsg);
13502    return ret;
13503
13504 }
13505
13506 /*******************************************************************
13507 *
13508 * @brief added free part for the memory allocated by aper_decoder
13509 *
13510 * @details
13511 *
13512 *    Function : freeAperDecodeUeContextReleaseCommand
13513 *
13514 *    Functionality: added free part for the memory allocated by aper_decoder
13515 *
13516 * @params[in] F1AP_PDU_t *f1apMsg
13517 * @return void
13518 *
13519 * ****************************************************************/
13520 void freeAperDecodeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
13521 {
13522    uint8_t ieIdx=0;
13523    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
13524
13525    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
13526
13527    if(ueContextReleaseCommand->protocolIEs.list.array)
13528    {
13529       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
13530       {
13531          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
13532          {
13533             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
13534             {
13535                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13536                   break;
13537                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13538                   break;
13539                case ProtocolIE_ID_id_Cause:
13540                   break;
13541                case ProtocolIE_ID_id_RRCContainer:
13542                {
13543                   if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
13544                   {
13545                      free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
13546                   }
13547                   break;
13548                }
13549                default :
13550                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
13551                        ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
13552                   break;
13553             }
13554          }
13555          free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]);
13556       }
13557       free(ueContextReleaseCommand->protocolIEs.list.array);
13558    }
13559 }
13560 /*******************************************************************
13561 *
13562 * @brief processing of UE Context Release Command
13563 *
13564 * @details
13565 *
13566 *    Function : procF1UeContextReleaseCommand
13567 *
13568 *    Functionality: processing of UE Context Release Command
13569 *
13570 * @params[in] F1AP_PDU_t *f1apMsg
13571 * @return void
13572 *
13573 * ****************************************************************/
13574 uint8_t procF1UeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
13575 {
13576    uint8_t  ieIdx=0, ret=ROK, ueIdx=0;
13577    uint16_t cellIdx =0;
13578    bool ueIdxFound;
13579    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0;
13580    DuUeCb   *duUeCb = NULLP;
13581    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
13582
13583    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
13584
13585    if(ueContextReleaseCommand->protocolIEs.list.array)
13586    {
13587       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
13588       {
13589          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
13590          {
13591             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
13592             {
13593                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13594                   {
13595                      gnbCuUeF1apId= ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13596                                     value.choice.GNB_CU_UE_F1AP_ID;
13597                      break;
13598                   }
13599
13600                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13601                   {
13602                      gnbDuUeF1apId = ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13603                                      value.choice.GNB_DU_UE_F1AP_ID;
13604                      break;
13605                   }
13606
13607                case ProtocolIE_ID_id_Cause:
13608                   {
13609                      break;
13610                   }
13611
13612                case ProtocolIE_ID_id_RRCContainer:
13613                   {
13614                      for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
13615                      {
13616                         for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
13617                         {
13618                            if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
13619                                  (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
13620                            {
13621                               duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
13622                               DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
13623                               if(duUeCb->f1UeDb)
13624                               {
13625                                  memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
13626                                  duUeCb->f1UeDb->actionType = UE_CTXT_RELEASE;
13627                                  duUeCb->f1UeDb->cellIdx = cellIdx;
13628                                  /* Filling Dl RRC Msg Info */
13629                                  DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
13630                                  if(!duUeCb->f1UeDb->dlRrcMsg)
13631                                  {
13632                                     DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
13633                                     Memory allocation failed ");
13634                                     ret = RFAILED;
13635                                  }
13636                                  else
13637                                  {
13638                                     duUeCb->f1UeDb->dlRrcMsgPres = true;
13639                                     memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
13640                                     ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
13641                                           &ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13642                                           value.choice.RRCContainer);
13643                                  }
13644
13645                               }
13646                               else
13647                               {
13648                                  DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
13649                                  Memory allocation failed ");
13650                                  ret = RFAILED;
13651
13652                               }
13653
13654                               ueIdxFound = true;
13655                               break;
13656                            }
13657                         }
13658                         if(ueIdxFound == true)
13659                         {
13660                            break;
13661                         }
13662                      }
13663                      if(!ueIdxFound)
13664                      {
13665                         DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextReleaseCommand()");
13666                         ret = RFAILED;
13667                      }
13668
13669
13670                      break;
13671                   }
13672                default :
13673                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
13674                         ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
13675                   break;
13676             }
13677          }
13678       }
13679    }
13680    if(ret != RFAILED)
13681    {
13682       duProcUeContextReleaseCommand(duUeCb);
13683    }
13684    freeAperDecodeUeContextReleaseCommand(f1apMsg);
13685    return ret;
13686 }
13687 /**************************************************************
13688  *
13689  * @brief Handles received F1AP message and sends back response
13690  *
13691  * @details
13692  *
13693  *    Function : F1APMsgHdlr
13694  *
13695  *    Functionality:
13696  *         - Decodes received F1AP control message
13697  *         - Prepares response message, encodes and sends to SCTP
13698  *
13699  * @params[in]
13700  * @return ROK     - success
13701  *         RFAILED - failure
13702  *
13703  * ****************************************************************/
13704 void F1APMsgHdlr(Buffer *mBuf)
13705 {
13706    int i =0;
13707    char *recvBuf =NULLP;
13708    MsgLen copyCnt =0;
13709    MsgLen recvBufLen =0;
13710    F1AP_PDU_t *f1apMsg =NULLP;
13711    asn_dec_rval_t rval; /* Decoder return value */
13712    F1AP_PDU_t f1apasnmsg ;
13713    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
13714    ODU_PRINT_MSG(mBuf, 0,0);
13715
13716    /* Copy mBuf into char array to decode it */
13717    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
13718    DU_ALLOC(recvBuf, (Size)recvBufLen);
13719
13720    if(recvBuf == NULLP)
13721    {
13722       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
13723       return;
13724    }
13725    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
13726    {
13727       DU_LOG("\nERROR   -->  F1AP : Failed while copying %d", copyCnt);
13728       return;
13729    }
13730
13731    printf("\nDEBUG   -->  F1AP : Received flat buffer to be decoded : ");
13732    for(i=0; i< recvBufLen; i++)
13733    {
13734       printf("%x",recvBuf[i]);
13735    }
13736
13737    /* Decoding flat buffer into F1AP messsage */
13738    f1apMsg = &f1apasnmsg;
13739    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
13740
13741    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
13742    DU_FREE(recvBuf, (Size)recvBufLen);
13743
13744    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
13745    {
13746       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
13747       return;
13748    }
13749    printf("\n");
13750    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13751
13752    switch(f1apMsg->present)
13753    {
13754       case F1AP_PDU_PR_successfulOutcome:
13755          {
13756             switch(f1apMsg->choice.successfulOutcome->value.present)
13757             {
13758                case SuccessfulOutcome__value_PR_ResetAcknowledge:
13759                   {
13760                      DU_LOG("\nINFO   -->  F1AP : F1ResetAcknowledge is received successfully ");
13761                      break;
13762                   }
13763                case SuccessfulOutcome__value_PR_F1SetupResponse:
13764                   {
13765 #ifndef ODU_TEST_STUB
13766                      procF1SetupRsp(f1apMsg);
13767 #endif
13768                      break;
13769                   }
13770
13771                case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
13772                   {
13773                      procF1GNBDUCfgUpdAck(f1apMsg);
13774                      break;
13775                   }
13776
13777                default:
13778                   {
13779                      DU_LOG("\nERROR  -->  F1AP : Invalid type of SuccessfulOutcome__value_PR_ResetAcknowledge [%d]",\
13780                            f1apMsg->choice.successfulOutcome->value.present);
13781                      return;
13782                   }
13783             }/* End of switch(successfulOutcome) */
13784             free(f1apMsg->choice.successfulOutcome);
13785             break;
13786          }
13787       case F1AP_PDU_PR_initiatingMessage:
13788          {
13789             switch(f1apMsg->choice.initiatingMessage->value.present)
13790             {
13791                case InitiatingMessage__value_PR_Reset:
13792                   {
13793                      procF1ResetReq(f1apMsg);
13794                      break;
13795                   }
13796                case InitiatingMessage__value_PR_DLRRCMessageTransfer:
13797                   {
13798                      procF1DlRrcMsgTrans(f1apMsg);
13799                      break;
13800                   }
13801                case InitiatingMessage__value_PR_UEContextSetupRequest:
13802                   {
13803                      procF1UeContextSetupReq(f1apMsg);
13804                      break;
13805                   }
13806                case InitiatingMessage__value_PR_UEContextModificationRequest:
13807                   {
13808                      procF1UeContextModificationReq(f1apMsg);
13809                      break;
13810                   }
13811                case InitiatingMessage__value_PR_UEContextReleaseCommand:
13812                   {
13813                       procF1UeContextReleaseCommand(f1apMsg);
13814                       break;
13815                   }
13816                default:
13817                   {
13818                      DU_LOG("\nERROR  -->  F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
13819                            f1apMsg->choice.initiatingMessage->value.present);
13820                      return;
13821                   }
13822             }/* End of switch(initiatingMessage) */
13823             free(f1apMsg->choice.initiatingMessage);
13824             break;
13825          }
13826
13827       default:
13828          {
13829             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
13830             return;
13831          }
13832          free(f1apMsg);
13833
13834    }/* End of switch(f1apMsg->present) */
13835
13836 } /* End of F1APMsgHdlr */
13837
13838 /**********************************************************************
13839   End of file
13840  **********************************************************************/