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 "CmInterface.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]   = duCfgParam.sib1Params.cellIdentity;
 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] = duCfgParam.sib1Params.cellIdentity;
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] = duCfgParam.sib1Params.cellIdentity;
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] = duCfgParam.sib1Params.cellIdentity;
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    uint8_t rsrcIdx, rsrcSetIdx;
4359    PUCCH_ResourceSet_t *rsrcSet = NULLP;
4360    PUCCH_Resource_t *rsrc = NULLP;
4361
4362    //RESOURCE SET
4363    elementCnt = 1;
4364    DU_ALLOC(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
4365    if(pucchCfg->resourceSetToAddModList == NULL)
4366    {
4367       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4368       return RFAILED;
4369    }
4370
4371    pucchCfg->resourceSetToAddModList->list.count = elementCnt;
4372    pucchCfg->resourceSetToAddModList->list.size = elementCnt * sizeof(PUCCH_ResourceSet_t *);
4373    DU_ALLOC(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
4374    if(pucchCfg->resourceSetToAddModList->list.array == NULLP)
4375    {
4376       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4377       return RFAILED;
4378    }
4379    for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
4380    {
4381       DU_ALLOC(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
4382       if(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx] == NULLP)
4383       {
4384          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4385          return RFAILED;
4386       }
4387    }
4388    rsrcSetIdx = 0;
4389    rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
4390    rsrcSet->pucch_ResourceSetId = 1;
4391    elementCnt = 1;
4392    rsrcSet->resourceList.list.count = elementCnt;
4393    rsrcSet->resourceList.list.size = elementCnt * sizeof(PUCCH_ResourceId_t *);
4394    DU_ALLOC(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
4395    if(rsrcSet->resourceList.list.array == NULLP)
4396    {
4397       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4398       return RFAILED;
4399    }
4400    for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
4401    {
4402       DU_ALLOC(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
4403       if(rsrcSet->resourceList.list.array[rsrcIdx] == NULLP)
4404       {
4405          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4406          return RFAILED;
4407       }
4408    }
4409    rsrcIdx = 0;
4410    *(rsrcSet->resourceList.list.array[rsrcIdx]) = 1;
4411
4412    //RESOURCE
4413    elementCnt = 1;
4414    DU_ALLOC(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
4415    if(pucchCfg->resourceToAddModList == NULLP)
4416    {
4417       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4418       return RFAILED;
4419    }
4420    pucchCfg->resourceToAddModList->list.count = elementCnt;
4421    pucchCfg->resourceToAddModList->list.size = elementCnt * sizeof(PUCCH_Resource_t *);
4422    DU_ALLOC(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
4423    if(pucchCfg->resourceToAddModList->list.array == NULLP)
4424    {
4425       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4426       return RFAILED;
4427    }
4428    for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
4429    {
4430       DU_ALLOC(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
4431       if(pucchCfg->resourceToAddModList->list.array[rsrcIdx] == NULLP)
4432       {
4433          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4434          return RFAILED;
4435       }
4436    }
4437    rsrcIdx = 0;
4438    rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
4439    rsrc->pucch_ResourceId = 1;
4440    rsrc->startingPRB = 0;
4441    rsrc->format.present = PUCCH_Resource__format_PR_format1;
4442    DU_ALLOC(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
4443    if(rsrc->format.choice.format1 == NULLP)
4444    {
4445       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4446       return RFAILED;
4447    }
4448    rsrc->format.choice.format1->initialCyclicShift = 0;
4449    rsrc->format.choice.format1->nrofSymbols = 4;
4450    rsrc->format.choice.format1->startingSymbolIndex = 0;
4451    rsrc->format.choice.format1->timeDomainOCC = 0;
4452
4453    //PUCCH Format 1
4454    DU_ALLOC(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
4455    if(pucchCfg->format1 == NULLP)
4456    {
4457       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4458       return RFAILED;
4459    }
4460    pucchCfg->format1->present = PUCCH_Config__format1_PR_setup;
4461    DU_ALLOC(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
4462    if(pucchCfg->format1->choice.setup == NULLP)
4463    {
4464       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4465       return RFAILED;
4466    }
4467    DU_ALLOC(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
4468    if(pucchCfg->format1->choice.setup->nrofSlots == NULLP)
4469    {
4470       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4471       return RFAILED;
4472    }
4473    *(pucchCfg->format1->choice.setup->nrofSlots) = PUCCH_FormatConfig__nrofSlots_n4;
4474
4475    //DL DATA TO UL ACK
4476    DU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
4477    if(pucchCfg->dl_DataToUL_ACK == NULLP)
4478    {
4479       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4480       return RFAILED;
4481    }
4482
4483    elementCnt = 2;
4484    pucchCfg->dl_DataToUL_ACK->list.count = elementCnt;
4485    pucchCfg->dl_DataToUL_ACK->list.size = elementCnt * sizeof(long *);
4486    DU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
4487    if(pucchCfg->dl_DataToUL_ACK->list.array == NULLP)
4488    {
4489       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4490       return RFAILED;
4491    }
4492
4493    for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
4494    {
4495       DU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
4496       if(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx] == NULLP)
4497       {
4498           DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4499           return RFAILED;
4500       }
4501    }
4502
4503    arrIdx = 0;
4504    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx++]) = 1;
4505    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx]) = 2;
4506    return ROK;
4507 }
4508
4509 /*******************************************************************
4510  *
4511  * @brief Fills SRS resource to add/modify list
4512  *
4513  * @details
4514  *
4515  *    Function : BuildSrsRsrcAddModList
4516  *
4517  *    Functionality: Fills SRS resource to add/modify list
4518  *
4519  * @params[in]
4520  * @return ROK     - success
4521  *         RFAILED - failure
4522  *
4523  * ****************************************************************/
4524 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
4525 {
4526    uint8_t   elementCnt;
4527    uint8_t   rsrcIdx;
4528
4529    elementCnt = 1;
4530    resourceList->list.count = elementCnt;
4531    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
4532    resourceList->list.array = NULLP;
4533    DU_ALLOC(resourceList->list.array, resourceList->list.size);
4534    if(!resourceList->list.array)
4535    {
4536       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4537       return RFAILED;
4538    }
4539
4540    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4541    {
4542       DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4543       if(!resourceList->list.array[rsrcIdx])
4544       {
4545          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4546          return RFAILED;
4547       }
4548    }
4549
4550    rsrcIdx = 0;
4551    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
4552    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
4553    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
4554
4555    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
4556    DU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
4557          sizeof(struct SRS_Resource__transmissionComb__n2));
4558    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
4559    {
4560       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4561       return RFAILED;
4562    }
4563    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
4564       = SRS_COMB_OFFSET_N2;
4565    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
4566       = SRS_CYCLIC_SHIFT_N2;
4567
4568    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
4569                                                                       PUSCH_START_SYMBOL;
4570    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
4571                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
4572    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
4573                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
4574
4575    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
4576    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
4577    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
4578    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
4579    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
4580    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
4581                                                                SRS_Resource__groupOrSequenceHopping_neither;
4582
4583    /* Setting resource type to aperiodic for intergration purposes */
4584    resourceList->list.array[rsrcIdx]->resourceType.present = \
4585                                                              SRS_Resource__resourceType_PR_aperiodic;
4586    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
4587    DU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
4588          sizeof(struct SRS_Resource__resourceType__aperiodic));
4589    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
4590    {
4591       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4592       return RFAILED;
4593    }
4594    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
4595
4596    return ROK;
4597 }
4598
4599 /*******************************************************************
4600  *
4601  * @brief Build SRS resource set Add/mod list
4602  *
4603  * @details
4604  *
4605  *    Function : BuildSrsRsrcSetAddModList
4606  *
4607  *    Functionality: Build SRS resource set Add/mod list
4608  *
4609  * @params[in]
4610  * @return ROK     - success
4611  *         RFAILED - failure
4612  *
4613  * ****************************************************************/
4614    uint8_t BuildSrsRsrcSetAddModList
4615 (
4616  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
4617  )
4618 {
4619    uint8_t  elementCnt;
4620    uint8_t  rSetIdx;
4621    uint8_t  rsrcIdx;
4622    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
4623
4624    elementCnt = 1;
4625    rsrcSetList->list.count = elementCnt;
4626    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
4627    rsrcSetList->list.array = NULLP;
4628    DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
4629    if(!rsrcSetList->list.array)
4630    {
4631       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4632       return RFAILED;
4633    }
4634
4635    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4636    {
4637       DU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4638       if(!rsrcSetList->list.array[rSetIdx])
4639       {
4640          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4641          return RFAILED;
4642       }
4643    }
4644
4645    rSetIdx = 0;
4646    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
4647
4648    /* Fill Resource Id list in resource set */
4649    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
4650    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4651          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4652    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4653    {
4654       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4655       return RFAILED;
4656    }
4657
4658    elementCnt = 1;
4659    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4660    rsrcIdList->list.count = elementCnt;
4661    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
4662    rsrcIdList->list.array = NULLP;
4663    DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
4664    if(!rsrcIdList->list.array)
4665    {
4666       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4667       return RFAILED;
4668    }
4669
4670    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4671    {
4672       DU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4673       if(!rsrcIdList->list.array[rsrcIdx])
4674       {
4675          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4676          return RFAILED;
4677       }
4678    }
4679
4680    rsrcIdx = 0;
4681    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
4682
4683    /* Fill resource type */
4684    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
4685                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
4686
4687    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
4688    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4689          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4690    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
4691    {
4692       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4693       return RFAILED;
4694    }
4695    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
4696       = APERIODIC_SRS_RESRC_TRIGGER;
4697
4698    /* TODO : Fill values for below IEs as expected by Viavi */
4699    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
4700    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
4701
4702
4703    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
4704    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
4705    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
4706    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
4707    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
4708
4709    return ROK;
4710 }
4711
4712 /*******************************************************************
4713  *
4714  * @brief Builds BWP UL dedicated SRS Config
4715  *
4716  * @details
4717  *
4718  *    Function : BuildBWPUlDedSrsCfg
4719  *
4720  *    Functionality: Builds BWP UL dedicated SRS Config
4721  *
4722  * @params[in] SRS Config
4723  * @return ROK     - success
4724  *         RFAILED - failure
4725  *
4726  * ****************************************************************/
4727 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
4728 {
4729    srsCfg->srs_ResourceSetToReleaseList = NULLP;
4730    srsCfg->srs_ResourceSetToAddModList = NULLP;
4731    DU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
4732          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4733    if(!srsCfg->srs_ResourceSetToAddModList)
4734    {
4735       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4736       return RFAILED;
4737    }
4738    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
4739    {
4740       return RFAILED;
4741    }
4742
4743    srsCfg->srs_ResourceToReleaseList = NULLP;
4744
4745    /* Resource to Add/Modify list */
4746    srsCfg->srs_ResourceToAddModList = NULLP;
4747    DU_ALLOC(srsCfg->srs_ResourceToAddModList, \
4748          sizeof(struct SRS_Config__srs_ResourceToAddModList));
4749    if(!srsCfg->srs_ResourceToAddModList)
4750    {
4751       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4752       return RFAILED;
4753    }
4754
4755    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
4756    {
4757       return RFAILED;
4758    }
4759
4760    srsCfg->tpc_Accumulation = NULLP;
4761
4762    return ROK;
4763 }
4764
4765
4766
4767 /*******************************************************************
4768  *
4769  * @brief Builds Pusch Serving cell Config
4770  *
4771  * @details
4772  *
4773  *    Function : BuildPuschSrvCellCfg
4774  *
4775  *    Functionality: Builds Pusch Serving cell Config
4776  *
4777  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
4778  *
4779  * @return ROK     - success
4780  *         RFAILED - failure
4781  *
4782  * ****************************************************************/
4783 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
4784 {
4785    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
4786    puschCfg->choice.setup = NULLP;
4787    DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4788    if(!puschCfg->choice.setup)
4789    {
4790       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4791       return RFAILED;
4792    }
4793
4794    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4795    puschCfg->choice.setup->rateMatching = NULLP;
4796    puschCfg->choice.setup->xOverhead = NULLP;
4797    puschCfg->choice.setup->ext1 = NULLP;
4798    DU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
4799    if(!puschCfg->choice.setup->ext1)
4800    {
4801       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4802       return RFAILED;
4803    }
4804
4805    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
4806    DU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
4807    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
4808    {
4809       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4810       return RFAILED;
4811    }
4812    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
4813
4814    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
4815    DU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
4816    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
4817    {
4818       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4819       return RFAILED;
4820    }
4821    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
4822    return ROK;
4823 }
4824
4825 /*******************************************************************
4826  *
4827  * @brief Builds inital UL BWP
4828  *
4829  * @details
4830  *
4831  *    Function : BuildInitialUlBWP
4832  *
4833  *    Functionality: Builds initial UL BWP
4834  *
4835  * @params[in] BWP_UplinkDedicated_t *ulBwp
4836  * @return ROK     - success
4837  *         RFAILED - failure
4838  *
4839  * ****************************************************************/
4840 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4841 {
4842    ulBwp->pucch_Config = NULLP;
4843    DU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
4844    if(!ulBwp->pucch_Config)
4845    {
4846       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4847       return RFAILED;
4848    }
4849
4850    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
4851    ulBwp->pucch_Config->choice.setup = NULLP;
4852    DU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
4853    if(!ulBwp->pucch_Config->choice.setup)
4854    {
4855       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4856       return RFAILED;
4857    }
4858
4859    if(BuildBWPUlDedPucchCfg(ulBwp->pucch_Config->choice.setup) != ROK)
4860    {
4861       return RFAILED;
4862    }
4863
4864    /* Fill BWP UL dedicated PUSCH config */
4865    ulBwp->pusch_Config = NULLP;
4866    DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4867    if(!ulBwp->pusch_Config)
4868    {
4869       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4870       return RFAILED;
4871    }
4872
4873    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
4874    ulBwp->pusch_Config->choice.setup = NULLP;
4875    DU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4876    if(!ulBwp->pusch_Config->choice.setup)
4877    {
4878       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4879       return RFAILED;
4880    }
4881
4882    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
4883    {
4884       return RFAILED;
4885    }
4886
4887    ulBwp->configuredGrantConfig = NULLP;
4888
4889    /* Fill BPW UL dedicated SRS config */
4890    ulBwp->srs_Config = NULLP;
4891    DU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4892    if(!ulBwp->srs_Config)
4893    {
4894       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4895       return RFAILED;
4896    }
4897
4898    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
4899    ulBwp->srs_Config->choice.setup = NULLP;
4900    DU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4901    if(!ulBwp->srs_Config->choice.setup)
4902    {
4903       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4904       return RFAILED;
4905    }
4906
4907    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
4908    {
4909       return RFAILED;
4910    }
4911
4912    ulBwp->beamFailureRecoveryConfig = NULLP;
4913
4914    return ROK;
4915 }
4916
4917 /*******************************************************************
4918  *
4919  * @brief Builds UL config
4920  * @details
4921  *
4922  *    Function : BuildUlCfg
4923  *
4924  *    Functionality: Builds UL config in spCellCfgDed
4925  *
4926  * @params[in] UplinkConfig_t *ulCfg
4927  *
4928  * @return ROK     - success
4929  *         RFAILED - failure
4930  *
4931  * ****************************************************************/
4932 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
4933 {
4934    ulCfg->initialUplinkBWP = NULLP;
4935    DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4936    if(!ulCfg->initialUplinkBWP)
4937    {
4938       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4939       return RFAILED;
4940    }
4941
4942    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
4943    {
4944       return RFAILED;
4945    }
4946
4947    ulCfg->uplinkBWP_ToReleaseList = NULLP;
4948    ulCfg->uplinkBWP_ToAddModList = NULLP;
4949    ulCfg->firstActiveUplinkBWP_Id = NULLP;
4950    DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4951    if(!ulCfg->firstActiveUplinkBWP_Id)
4952    {
4953       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4954       return RFAILED;
4955    }
4956    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
4957
4958    ulCfg->pusch_ServingCellConfig = NULLP;
4959    DU_ALLOC(ulCfg->pusch_ServingCellConfig, \
4960          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4961    if(!ulCfg->pusch_ServingCellConfig)
4962    {
4963       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4964       return RFAILED;
4965    }
4966
4967    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
4968    {
4969       return RFAILED;
4970    }
4971
4972    ulCfg->carrierSwitching = NULLP;
4973    ulCfg->ext1 = NULLP;
4974    return ROK;
4975 }
4976
4977 /*******************************************************************
4978  *
4979  * @brief Builds PDSCH serving cell config
4980  * @details
4981  *
4982  *    Function : BuildPdschSrvCellCfg
4983  *
4984  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
4985  *
4986  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
4987  *
4988  * @return ROK     - success
4989  *         RFAILED - failure
4990  *
4991  * ****************************************************************/
4992 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
4993 {
4994    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
4995    pdschCfg->choice.setup = NULLP;
4996    DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
4997    if(!pdschCfg->choice.setup)
4998    {
4999       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5000       return RFAILED;
5001    }
5002
5003    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
5004    pdschCfg->choice.setup->xOverhead = NULLP;
5005    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
5006    DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
5007    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
5008    {
5009       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
5010       return RFAILED;
5011    }
5012    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
5013    pdschCfg->choice.setup->pucch_Cell = NULLP;
5014    pdschCfg->choice.setup->ext1 = NULLP;
5015
5016    return ROK;
5017 }
5018
5019 /*******************************************************************
5020  *
5021  * @brief Builds CSI Meas config
5022  * @details
5023  *
5024  *    Function : BuildCsiMeasCfg
5025  *
5026  *    Functionality: Builds CSI Meas config in spCellCfgDed
5027  *
5028  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
5029  *
5030  * @return ROK     - success
5031  *         RFAILED - failure
5032  *
5033  * ****************************************************************/
5034 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
5035 {
5036
5037    return ROK;
5038 }
5039
5040 /*******************************************************************
5041  *
5042  * @brief Builds Spcell config dedicated
5043  * @details
5044  *
5045  *    Function : BuildSpCellCfgDed
5046  *
5047  *    Functionality: Builds sp cell config dedicated in spCellCfg
5048  *
5049  * @params[in] ServingCellConfig_t srvCellCfg
5050  *
5051  * @return ROK     - success
5052  *         RFAILED - failure
5053  *
5054  * ****************************************************************/
5055 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
5056 {
5057    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
5058    DU_ALLOC(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
5059    if(!srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
5060    {
5061       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5062       return RFAILED;
5063    }
5064
5065    srvCellCfg->initialDownlinkBWP = NULLP;
5066    DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
5067    if(!srvCellCfg->initialDownlinkBWP)
5068    {
5069       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5070       return RFAILED;
5071    }
5072
5073    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
5074    {
5075       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
5076       return RFAILED;
5077    }
5078    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
5079    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
5080
5081    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
5082    DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
5083    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
5084    {
5085       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5086       return RFAILED;
5087    }
5088    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
5089
5090    srvCellCfg->bwp_InactivityTimer = NULLP;
5091
5092    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
5093    DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
5094    if(!srvCellCfg->defaultDownlinkBWP_Id)
5095    {
5096       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5097       return RFAILED;
5098    }
5099    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
5100
5101    srvCellCfg->uplinkConfig = NULLP;
5102    DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
5103    if(!srvCellCfg->uplinkConfig)
5104    {
5105       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5106       return RFAILED;
5107    }
5108
5109    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
5110    {
5111       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
5112       return RFAILED;
5113    }
5114    srvCellCfg->supplementaryUplink = NULLP;
5115    srvCellCfg->pdcch_ServingCellConfig = NULLP;
5116
5117    srvCellCfg->pdsch_ServingCellConfig = NULLP;
5118    DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
5119    if(!srvCellCfg->pdsch_ServingCellConfig)
5120    {
5121       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5122       return RFAILED;
5123    }
5124
5125    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
5126    {
5127       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
5128       return RFAILED;
5129    }
5130
5131    srvCellCfg->csi_MeasConfig = NULLP;
5132 #if 0
5133    DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
5134       if(!srvCellCfg->csi_MeasConfig)
5135       {
5136          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
5137          return RFAILED;
5138       }
5139
5140    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
5141    {
5142       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
5143       return RFAILED;
5144    }
5145 #endif
5146    srvCellCfg->sCellDeactivationTimer = NULLP;
5147    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
5148    srvCellCfg->tag_Id = TAG_ID;
5149    srvCellCfg->dummy = NULLP;
5150    srvCellCfg->pathlossReferenceLinking = NULLP;
5151    srvCellCfg->servingCellMO = NULLP;
5152    srvCellCfg->ext1 = NULLP;
5153
5154    return ROK;
5155 }
5156 /*******************************************************************
5157  *
5158  * @brief Builds Spcell config
5159  *
5160  * @details
5161  *
5162  *    Function : BuildSpCellCfg
5163  *
5164  *    Functionality: Builds sp cell config in DuToCuRrcContainer
5165  *
5166  * @params[in] SpCellConfig_t spCellCfg
5167  *
5168  * @return ROK     - success
5169  *         RFAILED - failure
5170  *
5171  * ****************************************************************/
5172 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
5173 {
5174
5175    spCellCfg->servCellIndex = NULLP;
5176    DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
5177    if(!spCellCfg->servCellIndex)
5178    {
5179       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5180       return RFAILED;
5181    }
5182    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
5183
5184    spCellCfg->reconfigurationWithSync = NULLP;
5185    spCellCfg->rlf_TimersAndConstants = NULLP;
5186    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
5187    DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5188    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
5189    {
5190       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5191       return RFAILED;
5192    }
5193    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
5194
5195    spCellCfg->spCellConfigDedicated = NULLP;
5196    DU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5197    if(!spCellCfg->spCellConfigDedicated)
5198    {
5199       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5200       return RFAILED;
5201    }
5202    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
5203    {
5204       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
5205       return RFAILED;
5206    }
5207    return ROK;
5208 }
5209 /*******************************************************************
5210  *
5211  * @brief Builds Phy cell group config
5212  *
5213  * @details
5214  *
5215  *    Function : BuildPhyCellGrpCfg
5216  *
5217  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
5218  *
5219  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
5220  *
5221  * @return ROK     - success
5222  *         RFAILED - failure
5223  *
5224  * ****************************************************************/
5225 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
5226 {
5227    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
5228    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
5229
5230    phyCellGrpCfg->p_NR_FR1 = NULLP;
5231    DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5232    if(!phyCellGrpCfg->p_NR_FR1)
5233    {
5234       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
5235       return RFAILED;
5236    }
5237    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
5238    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
5239    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
5240    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
5241    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
5242    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
5243    phyCellGrpCfg->cs_RNTI = NULLP;
5244    phyCellGrpCfg->ext1 = NULLP;
5245    phyCellGrpCfg->ext2 = NULLP;
5246
5247    return ROK;
5248 }
5249 /*******************************************************************
5250  *
5251  * @brief Builds Mac cell group config
5252  *
5253  * @details
5254  *
5255  *    Function : BuildMacCellGrpCfg
5256  *
5257  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
5258  *
5259  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
5260  *
5261  * @return ROK     - success
5262  *         RFAILED - failure
5263  *
5264  * ****************************************************************/
5265 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
5266 {
5267    macCellGrpCfg->drx_Config = NULLP;
5268    macCellGrpCfg->schedulingRequestConfig = NULLP;
5269    DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5270    if(!macCellGrpCfg->schedulingRequestConfig)
5271    {
5272       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5273       return RFAILED;
5274    }
5275
5276    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
5277    {
5278       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
5279       return RFAILED;
5280    }
5281
5282    macCellGrpCfg->bsr_Config = NULLP;
5283    DU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5284    if(!macCellGrpCfg->bsr_Config)
5285    {
5286       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5287       return RFAILED;
5288    }
5289
5290    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
5291    {
5292       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
5293       return RFAILED;
5294    }
5295
5296    macCellGrpCfg->tag_Config = NULLP;
5297    DU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
5298    if(!macCellGrpCfg->tag_Config)
5299    {
5300       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5301       return RFAILED;
5302    }
5303
5304    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
5305    {
5306       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
5307       return RFAILED;
5308    }
5309
5310    macCellGrpCfg->phr_Config = NULLP;
5311    DU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
5312    if(!macCellGrpCfg->phr_Config)
5313    {
5314       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5315       return RFAILED;
5316    }
5317
5318    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
5319    {
5320       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
5321       return RFAILED;
5322    }
5323
5324    macCellGrpCfg->skipUplinkTxDynamic = false;
5325    macCellGrpCfg->ext1 = NULLP;
5326
5327    return ROK;
5328 }
5329 /*******************************************************************
5330  *
5331  * @brief Frees memeory allocated for SearchSpcToAddModList
5332  *
5333  * @details
5334  *
5335  *    Function : FreeSearchSpcToAddModList
5336  *
5337  *    Functionality: Deallocating memory of SearchSpcToAddModList
5338  *
5339  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
5340  *
5341  * @return void
5342  *
5343  4221 * ****************************************************************/
5344 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
5345 {
5346    uint8_t idx1=0;
5347    uint8_t idx2=0;
5348    struct  SearchSpace *searchSpc=NULLP;
5349
5350    if(searchSpcList->list.array)
5351    {
5352       if(searchSpcList->list.array[idx2])
5353       {
5354          searchSpc = searchSpcList->list.array[idx2];
5355          if(searchSpc->controlResourceSetId)
5356          {
5357             if(searchSpc->monitoringSlotPeriodicityAndOffset)
5358             {
5359                if(searchSpc->monitoringSymbolsWithinSlot)
5360                {
5361                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
5362                   {
5363                      if(searchSpc->nrofCandidates)
5364                      {
5365                         if(searchSpc->searchSpaceType)
5366                         {
5367                            DU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
5368                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
5369                            DU_FREE(searchSpc->searchSpaceType, sizeof(struct
5370                                     SearchSpace__searchSpaceType));
5371                         }
5372                         DU_FREE(searchSpc->nrofCandidates,
5373                               sizeof(struct SearchSpace__nrofCandidates));
5374                      }
5375                      DU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
5376                            searchSpc->monitoringSymbolsWithinSlot->size);
5377                   }
5378                   DU_FREE(searchSpc->monitoringSymbolsWithinSlot,
5379                         sizeof(BIT_STRING_t));
5380                }
5381                DU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
5382                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
5383             }
5384             DU_FREE(searchSpc->controlResourceSetId,
5385                   sizeof(ControlResourceSetId_t));
5386          }
5387       }
5388       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
5389       {
5390          DU_FREE(searchSpcList->list.array[idx1],
5391                sizeof(struct SearchSpace));
5392       }
5393       DU_FREE(searchSpcList->list.array,searchSpcList->list.size);
5394    }
5395 }
5396 /*******************************************************************
5397  *
5398  * @brief Frees memory allocated for PdschTimeDomAllocList
5399  *
5400  * @details
5401  *
5402  *    Function : FreePdschTimeDomAllocList
5403  *
5404  *    Functionality: Deallocating memory of PdschTimeDomAllocList
5405  *
5406  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
5407  *
5408  * @return void
5409  *
5410  * ****************************************************************/
5411 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
5412 {
5413    uint8_t idx1=0;
5414
5415    if(timeDomAllocList->choice.setup)
5416    {
5417       if(timeDomAllocList->choice.setup->list.array)
5418       {
5419          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
5420          {
5421             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1]->k0, sizeof(long));
5422             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
5423                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
5424          }
5425          DU_FREE(timeDomAllocList->choice.setup->list.array, \
5426                timeDomAllocList->choice.setup->list.size);
5427       }
5428       DU_FREE(timeDomAllocList->choice.setup,\
5429             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
5430    }
5431 }
5432 /*******************************************************************
5433  *
5434  * @brief Frees memory allocated for PuschTimeDomAllocList
5435  *
5436  *@details
5437  *
5438  *    Function : FreePuschTimeDomAllocList
5439  *
5440  *    Functionality: Deallocating memory of PuschTimeDomAllocList
5441  *
5442  * @params[in] PUSCH_Config_t *puschCfg
5443  *
5444  * @return void
5445  *
5446  * ****************************************************************/
5447 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
5448 {
5449    uint8_t rsrcListIdx=0;
5450    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
5451
5452    if(puschCfg->pusch_TimeDomainAllocationList)
5453    {
5454       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
5455       if(timeDomAllocList_t->choice.setup)
5456       {
5457          if(timeDomAllocList_t->choice.setup->list.array)
5458          {
5459             for(rsrcListIdx = 0; rsrcListIdx<timeDomAllocList_t->choice.setup->list.count; rsrcListIdx++)
5460             {
5461                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx]->k2, sizeof(long));
5462                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx],\
5463                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
5464             }
5465             DU_FREE(timeDomAllocList_t->choice.setup->list.array, \
5466                   timeDomAllocList_t->choice.setup->list.size);
5467          }
5468          DU_FREE(timeDomAllocList_t->choice.setup, \
5469                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
5470       }
5471       DU_FREE(puschCfg->transformPrecoder, sizeof(long));
5472       DU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
5473             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
5474    }
5475
5476 }
5477
5478 /*******************************************************************
5479  *
5480  * @brief Frees memory allocated for Dedicated PUCCH config
5481  *
5482  * @details
5483  *
5484  *    Function : FreeBWPUlDedPucchCfg
5485  *
5486  *    Functionality: Deallocating memory of Dedicated PUCCH cfg
5487  *
5488  * @params[in] BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg
5489  *
5490  * @return void
5491  *
5492  * ****************************************************************/
5493 void FreeBWPUlDedPucchCfg(struct BWP_UplinkDedicated__pucch_Config *ulBwpPucchCfg)
5494 {
5495    uint8_t k1Idx, rsrcIdx, rsrcSetIdx;
5496    PUCCH_Config_t *pucchCfg = NULLP;
5497    PUCCH_ResourceSet_t *rsrcSet = NULLP;
5498    PUCCH_Resource_t *rsrc = NULLP;
5499
5500    if(ulBwpPucchCfg)
5501    {
5502       if(ulBwpPucchCfg->choice.setup)
5503       {
5504          pucchCfg = ulBwpPucchCfg->choice.setup;
5505
5506          //Free resource set list
5507          if(pucchCfg->resourceSetToAddModList)
5508          {
5509             if(pucchCfg->resourceSetToAddModList->list.array)
5510             {
5511                for(rsrcSetIdx=0; rsrcSetIdx < pucchCfg->resourceSetToAddModList->list.count; rsrcSetIdx++)
5512                {
5513                   rsrcSet = pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx];
5514                   if(rsrcSet->resourceList.list.array)
5515                   {
5516                      for(rsrcIdx=0; rsrcIdx < rsrcSet->resourceList.list.count; rsrcIdx++)
5517                      {
5518                         DU_FREE(rsrcSet->resourceList.list.array[rsrcIdx], sizeof(PUCCH_ResourceId_t));
5519                      }
5520                      DU_FREE(rsrcSet->resourceList.list.array, rsrcSet->resourceList.list.size);
5521                   }
5522                   DU_FREE(pucchCfg->resourceSetToAddModList->list.array[rsrcSetIdx], sizeof(PUCCH_ResourceSet_t));
5523                }
5524                DU_FREE(pucchCfg->resourceSetToAddModList->list.array, pucchCfg->resourceSetToAddModList->list.size);
5525             }
5526             DU_FREE(pucchCfg->resourceSetToAddModList, sizeof(struct PUCCH_Config__resourceSetToAddModList));
5527          }
5528
5529          //Free resource list
5530          if(pucchCfg->resourceToAddModList)
5531          {
5532             if(pucchCfg->resourceToAddModList->list.array)
5533             {
5534                for(rsrcIdx=0; rsrcIdx < pucchCfg->resourceToAddModList->list.count; rsrcIdx++)
5535                {
5536                   rsrc = pucchCfg->resourceToAddModList->list.array[rsrcIdx];
5537                   DU_FREE(rsrc->format.choice.format1, sizeof(PUCCH_format1_t));
5538                   DU_FREE(pucchCfg->resourceToAddModList->list.array[rsrcIdx], sizeof(PUCCH_Resource_t));
5539                }
5540                DU_FREE(pucchCfg->resourceToAddModList->list.array, pucchCfg->resourceToAddModList->list.size);
5541             }
5542             DU_FREE(pucchCfg->resourceToAddModList, sizeof(struct PUCCH_Config__resourceToAddModList));
5543          }
5544
5545          //PUCCH Format 1
5546          if(pucchCfg->format1)
5547          {
5548             if(pucchCfg->format1->choice.setup)
5549             {
5550                DU_FREE(pucchCfg->format1->choice.setup->nrofSlots, sizeof(long));
5551                DU_FREE(pucchCfg->format1->choice.setup, sizeof(PUCCH_FormatConfig_t));
5552             }
5553             DU_FREE(pucchCfg->format1, sizeof(struct PUCCH_Config__format1));
5554          }
5555
5556          //DL DATA TO UL ACK
5557          if(pucchCfg->dl_DataToUL_ACK)
5558          {
5559             if(pucchCfg->dl_DataToUL_ACK->list.array)
5560             {
5561                for(k1Idx = 0; k1Idx <  pucchCfg->dl_DataToUL_ACK->list.count; k1Idx++)
5562                {
5563                   DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[k1Idx], sizeof(long));
5564                }
5565                DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
5566             }
5567             DU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
5568          }
5569
5570          DU_FREE(ulBwpPucchCfg->choice.setup, sizeof(PUCCH_Config_t));
5571       }
5572       DU_FREE(ulBwpPucchCfg, sizeof(struct BWP_UplinkDedicated__pucch_Config));
5573    }
5574 }
5575
5576 /*******************************************************************
5577  *
5578  * @brief Frees memory allocated for InitialUlBWP
5579  *
5580  * @details
5581  *
5582  *    Function : FreeInitialUlBWP
5583  *
5584  *    Functionality: Deallocating memory of InitialUlBWP
5585  *
5586  * @params[in] BWP_UplinkDedicated_t *ulBwp
5587  *
5588  * @return void
5589  *
5590  * ****************************************************************/
5591 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5592 {
5593    uint8_t  rSetIdx, rsrcIdx;
5594    SRS_Config_t   *srsCfg = NULLP;
5595    PUSCH_Config_t *puschCfg = NULLP;
5596    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
5597    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
5598    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
5599    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
5600
5601    FreeBWPUlDedPucchCfg(ulBwp->pucch_Config);
5602
5603    if(ulBwp->pusch_Config)
5604    {
5605       if(ulBwp->pusch_Config->choice.setup)
5606       {
5607          puschCfg=ulBwp->pusch_Config->choice.setup;
5608          if(puschCfg->dataScramblingIdentityPUSCH)
5609          {
5610             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
5611             {
5612                FreePuschTimeDomAllocList(puschCfg);
5613                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
5614                if(dmrsUlCfg->choice.setup)
5615                {
5616                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
5617                   {
5618                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
5619                      {
5620                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
5621                               sizeof(long));
5622                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
5623                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
5624                      }
5625                      DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
5626                            sizeof(long));
5627                   }
5628                   DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
5629                }
5630                DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
5631                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
5632             }
5633             DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
5634          }
5635          DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5636       }
5637       DU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5638
5639       /* Free SRS-Config */
5640       if(ulBwp->srs_Config)
5641       {
5642          if(ulBwp->srs_Config->choice.setup)
5643          {
5644             srsCfg = ulBwp->srs_Config->choice.setup;
5645
5646             /* Free Resource Set to add/mod list */
5647             if(srsCfg->srs_ResourceSetToAddModList)
5648             {
5649                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
5650                if(rsrcSetList->list.array)
5651                {
5652                   rSetIdx = 0;
5653
5654                   /* Free SRS resource Id list in this SRS resource set */
5655                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5656                   {
5657                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5658
5659                      if(rsrcIdList->list.array)
5660                      {
5661                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5662                         {
5663                            DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5664                         }
5665                         DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
5666                      }
5667                      DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5668                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5669                   }
5670
5671                   /* Free resource type info for this SRS resource set */
5672                   DU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5673                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5674
5675                   /* Free memory for each resource set */
5676                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5677                   {
5678                      DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5679                   }
5680                   DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
5681                }
5682                DU_FREE(srsCfg->srs_ResourceSetToAddModList, \
5683                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5684             }
5685
5686             /* Free resource to add/modd list */
5687             if(srsCfg->srs_ResourceToAddModList)
5688             {
5689                resourceList = srsCfg->srs_ResourceToAddModList;
5690                if(resourceList->list.array)
5691                {
5692                   rsrcIdx = 0;
5693                   DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
5694                         sizeof(struct SRS_Resource__transmissionComb__n2));
5695                   DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
5696                         sizeof(struct SRS_Resource__resourceType__aperiodic));
5697
5698                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5699                   {
5700                      DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5701                   }
5702                   DU_FREE(resourceList->list.array, resourceList->list.size);
5703                }
5704                DU_FREE(srsCfg->srs_ResourceToAddModList, \
5705                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
5706             }
5707
5708             DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5709          }
5710          DU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5711       }
5712    }
5713 }
5714 /*******************************************************************
5715  *
5716  * @brief Frees memory allocated for initialUplinkBWP
5717  *
5718  * @details
5719  *
5720  *    Function : FreeinitialUplinkBWP
5721  *
5722  *    Functionality: Deallocating memory of initialUplinkBWP
5723  *
5724  * @params[in] UplinkConfig_t *ulCfg
5725  *
5726  * @return void
5727  *
5728  *
5729  * ****************************************************************/
5730 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
5731 {
5732    BWP_UplinkDedicated_t *ulBwp=NULLP;
5733    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
5734
5735    if(ulCfg->initialUplinkBWP)
5736    {
5737       ulBwp=ulCfg->initialUplinkBWP;
5738       if(ulCfg->firstActiveUplinkBWP_Id)
5739       {
5740          if(ulCfg->pusch_ServingCellConfig)
5741          {
5742             puschCfg=ulCfg->pusch_ServingCellConfig;
5743             if(puschCfg->choice.setup)
5744             {
5745                if(puschCfg->choice.setup->ext1)
5746                {
5747                   DU_FREE(puschCfg->choice.setup->ext1->\
5748                         processingType2Enabled,sizeof(BOOLEAN_t));
5749                   DU_FREE(puschCfg->choice.setup->ext1->\
5750                         maxMIMO_Layers,sizeof(long));
5751                   DU_FREE(puschCfg->choice.setup->ext1, \
5752                         sizeof(struct PUSCH_ServingCellConfig__ext1));
5753                }
5754                DU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5755             }
5756             DU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5757          }
5758          DU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5759       }
5760       FreeInitialUlBWP(ulBwp);
5761       DU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5762    }
5763 }
5764 /*******************************************************************
5765  *
5766  * @brief Frees emmory allocated for BWPDlDedPdschCfg
5767  *
5768  * @details
5769  *
5770  *    Function : FreeBWPDlDedPdschCfg
5771  *
5772  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
5773  *
5774  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5775  *
5776  * @return void
5777  *
5778  *
5779  * ****************************************************************/
5780 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
5781 {
5782    struct PDSCH_Config *pdschCfg=NULLP;
5783    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
5784    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
5785    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
5786
5787    if(dlBwp->pdsch_Config->choice.setup)
5788    {
5789       pdschCfg=dlBwp->pdsch_Config->choice.setup;
5790       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
5791       {
5792          if(pdschCfg->pdsch_TimeDomainAllocationList)
5793          {
5794             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
5795             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
5796             {
5797                prbBndlType=&pdschCfg->prb_BundlingType;
5798                DU_FREE(prbBndlType->choice.staticBundling,\
5799                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
5800                DU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
5801             }
5802             FreePdschTimeDomAllocList(timeDomAllocList);
5803             DU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
5804                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
5805          }
5806          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
5807          if(dmrsDlCfg->choice.setup)
5808          {
5809             DU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
5810                   sizeof(long));
5811             DU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
5812          }
5813          DU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
5814                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
5815       }
5816       DU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
5817    }
5818 }
5819 /*******************************************************************
5820  *
5821  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
5822  *
5823  * @details
5824  *
5825  *    Function : FreeBWPDlDedPdcchCfg
5826  *
5827  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
5828  *
5829  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5830  *
5831  * @return void
5832  *
5833  *
5834  * ****************************************************************/
5835 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
5836 {
5837    uint8_t idx1=0;
5838    uint8_t idx2=0;
5839    struct PDCCH_Config *pdcchCfg=NULLP;
5840    struct ControlResourceSet *controlRSet=NULLP;
5841    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
5842
5843    if(dlBwp->pdcch_Config->choice.setup)
5844    {
5845       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
5846       if(pdcchCfg->controlResourceSetToAddModList)
5847       {
5848          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
5849          if(controlRSetList->list.array)
5850          {
5851             controlRSet = controlRSetList->list.array[idx2];
5852             if(controlRSet)
5853             {
5854                if(controlRSet->frequencyDomainResources.buf)
5855                {
5856                   if(controlRSet->pdcch_DMRS_ScramblingID)
5857                   {
5858                      if(pdcchCfg->searchSpacesToAddModList)
5859                      {
5860                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
5861                         DU_FREE(pdcchCfg->searchSpacesToAddModList, \
5862                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
5863                      }
5864                      DU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
5865                   }
5866                   DU_FREE(controlRSet->frequencyDomainResources.buf, \
5867                         controlRSet->frequencyDomainResources.size);
5868                }
5869             }
5870             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
5871             {
5872                DU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
5873             }
5874             DU_FREE(controlRSetList->list.array, controlRSetList->list.size);
5875          }
5876          DU_FREE(pdcchCfg->controlResourceSetToAddModList, \
5877                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
5878       }
5879       DU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
5880    }
5881 }
5882
5883 /*******************************************************************
5884  *
5885  * @brief Frees emmory allocated for DUToCURRCContainer
5886  *
5887  * @details
5888  *
5889  *    Function : FreeMemDuToCuRrcCont
5890  *
5891  *    Functionality: Deallocating memory of DuToCuRrcContainer
5892  *
5893  * @params[in] DuToCuRRCContainer, DuToCuRRCContainer
5894  *
5895  * @return ROK     - success
5896  *         RFAILED - failure
5897  *
5898  * ****************************************************************/
5899 uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg)
5900 {
5901    uint8_t idx=0;
5902    SpCellConfig_t *spCellCfg=NULLP;
5903    ServingCellConfig_t *srvCellCfg=NULLP;
5904    BWP_DownlinkDedicated_t *dlBwp=NULLP;
5905    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
5906    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
5907    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
5908    struct RLC_Config *rlcConfig=NULLP;
5909    struct LogicalChannelConfig *macLcConfig=NULLP;
5910    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
5911    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
5912    struct TAG_Config *tagConfig=NULLP;
5913    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
5914    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
5915    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
5916
5917    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
5918    if(rlcBearerList)
5919    {
5920       if(rlcBearerList->list.array)
5921       {
5922          for(idx=0; idx<rlcBearerList->list.count; idx++)
5923          {
5924             if(rlcBearerList->list.array[idx])
5925             {
5926                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
5927                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
5928                if(rlcConfig)
5929                {
5930                   if(rlcConfig->choice.am)
5931                   {
5932                      DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5933                      DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5934                      DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
5935                   }
5936                   DU_FREE(rlcConfig, sizeof(struct RLC_Config));
5937                }
5938                DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
5939                if(macLcConfig)
5940                {
5941                   if(macLcConfig->ul_SpecificParameters)
5942                   {
5943                      DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
5944                      DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
5945                      DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
5946                   }
5947                   DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
5948                }
5949                DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
5950             }
5951          }
5952          DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
5953       }
5954       DU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5955    }
5956
5957    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
5958    if(macCellGrpCfg)
5959    {
5960       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
5961       if(schedulingRequestConfig)
5962       {
5963          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
5964          if(schReqList)
5965          {
5966             if(schReqList->list.array)
5967             {
5968                for(idx=0;idx<schReqList->list.count; idx++)
5969                {
5970                   if(schReqList->list.array[idx])
5971                   {
5972                      DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
5973                      DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
5974                   }
5975                }
5976                DU_FREE(schReqList->list.array, schReqList->list.size);
5977             }
5978             DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
5979                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
5980             DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5981       }
5982       if(macCellGrpCfg->bsr_Config)
5983       {
5984          DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5985       }
5986       tagConfig = macCellGrpCfg->tag_Config;
5987       if(tagConfig)
5988       {
5989          tagList = tagConfig->tag_ToAddModList;
5990          if(tagList)
5991          {
5992             if(tagList->list.array)
5993             {
5994                for(idx=0; idx<tagList->list.count; idx++)
5995                {
5996                   DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
5997                }
5998                DU_FREE(tagList->list.array, tagList->list.size);
5999             }
6000             DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
6001          }
6002          DU_FREE(tagConfig, sizeof(struct TAG_Config));
6003       }
6004
6005       phrConfig = macCellGrpCfg->phr_Config;
6006       if(phrConfig)
6007       {
6008          DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
6009          DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
6010       }
6011
6012       DU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
6013    }
6014
6015    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
6016    if(phyCellGrpCfg)
6017    {
6018       DU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
6019       DU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
6020    }
6021
6022    spCellCfg = cellGrpCfg->spCellConfig;
6023    if(spCellCfg)
6024    {
6025       if(spCellCfg->servCellIndex)
6026       {
6027          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
6028          {
6029             if(spCellCfg->spCellConfigDedicated)
6030             {
6031                srvCellCfg = spCellCfg->spCellConfigDedicated;
6032                if(srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
6033                {
6034                   if(srvCellCfg->initialDownlinkBWP)
6035                   {
6036                      dlBwp = srvCellCfg->initialDownlinkBWP;
6037                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
6038                      {
6039                         if(srvCellCfg->defaultDownlinkBWP_Id)
6040                         {
6041                            if(srvCellCfg->uplinkConfig)
6042                            {
6043                               if(srvCellCfg->pdsch_ServingCellConfig)
6044                               {
6045                                  pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
6046                                  if(pdschCfg->choice.setup)
6047                                  {
6048                                     DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
6049                                     DU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
6050                                  }
6051                                  DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
6052                                           ServingCellConfig__pdsch_ServingCellConfig));
6053                               }
6054                               FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
6055                               DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
6056                            }
6057                            DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
6058                         }
6059                         DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
6060                      }
6061                      if(dlBwp->pdcch_Config)
6062                      {
6063                         if(dlBwp->pdsch_Config)
6064                         {
6065                            FreeBWPDlDedPdschCfg(dlBwp);
6066                            DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
6067                         }
6068                         FreeBWPDlDedPdcchCfg(dlBwp);
6069                         DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
6070                      }
6071                      DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
6072                   }
6073                   DU_FREE(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
6074                }
6075                DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
6076             }
6077             DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
6078          }
6079          DU_FREE(spCellCfg->servCellIndex, sizeof(long));
6080       }
6081       DU_FREE(spCellCfg,sizeof(SpCellConfig_t));
6082    }
6083    return ROK;
6084 }
6085 /*******************************************************************
6086  *
6087  * @brief Builds DU To CU RRC Container
6088  *
6089  * @details
6090  *
6091  *    Function : BuildDuToCuRrcContainer
6092  *
6093  *    Functionality: Builds DuToCuRrcContainer
6094  *
6095  * @params[in] idx, index in F1AP msg
6096  *             DuToCuRRCContainer, DuToCuRRCContainer
6097  *
6098  * @return ROK     - success
6099  *         RFAILED - failure
6100  *
6101  * ****************************************************************/
6102 uint8_t BuildDuToCuRrcContainer(DUtoCURRCContainer_t *duToCuRrcContainer)
6103 {
6104    uint8_t  ret = ROK;
6105    CellGroupConfigRrc_t  cellGrpCfg;
6106    asn_enc_rval_t        encRetVal;
6107    memset(&cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
6108    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
6109
6110    while(true)
6111    {
6112       cellGrpCfg.cellGroupId = CELL_GRP_ID;
6113
6114       cellGrpCfg.rlc_BearerToAddModList = NULLP;
6115       DU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
6116       if(!cellGrpCfg.rlc_BearerToAddModList)
6117       {
6118          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6119          ret = RFAILED;
6120          break;
6121       }
6122       if(BuildRlcBearerToAddModList(cellGrpCfg.rlc_BearerToAddModList) != ROK)
6123       {
6124          DU_LOG("\nERROR  -->  F1AP : BuildRlcBearerToAddModList failed");
6125          ret = RFAILED;
6126          break;
6127       }
6128
6129       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
6130       cellGrpCfg.mac_CellGroupConfig = NULLP;
6131       DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
6132       if(!cellGrpCfg.mac_CellGroupConfig)
6133       {
6134          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6135          ret = RFAILED;
6136          break;
6137       }
6138       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
6139       {
6140          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
6141          ret = RFAILED;
6142          break;
6143       }
6144
6145       cellGrpCfg.physicalCellGroupConfig = NULLP;
6146       DU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
6147       if(!cellGrpCfg.physicalCellGroupConfig)
6148       {
6149          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6150          ret = RFAILED;
6151          break;
6152       }
6153       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
6154       {
6155          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
6156          ret = RFAILED;
6157          break;
6158       }
6159
6160       cellGrpCfg.spCellConfig = NULLP;
6161       DU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
6162       if(!cellGrpCfg.spCellConfig)
6163       {
6164          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
6165          ret = RFAILED;
6166          break;
6167       }
6168       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
6169       {
6170          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
6171          ret = RFAILED;
6172          break;
6173       }
6174
6175       cellGrpCfg.sCellToAddModList = NULLP;
6176       cellGrpCfg.sCellToReleaseList = NULLP;
6177       cellGrpCfg.ext1 = NULLP;
6178
6179       /* encode cellGrpCfg into duToCuRrcContainer */
6180       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
6181       memset(encBuf, 0, ENC_BUF_MAX_LEN);
6182       encBufSize = 0;
6183       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
6184       /* Encode results */
6185       if(encRetVal.encoded == ENCODE_FAIL)
6186       {
6187          DU_LOG( "\nERROR  --> F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
6188                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
6189          ret = RFAILED;
6190          break;
6191       }
6192       else
6193       {
6194          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
6195          for(int i=0; i< encBufSize; i++)
6196          {
6197             printf("%x",encBuf[i]);
6198          }
6199       }
6200
6201       duToCuRrcContainer->size = encBufSize;
6202       DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
6203       if(!duToCuRrcContainer->buf)
6204       {
6205          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
6206          ret = RFAILED;
6207          break;
6208       }
6209       if(ret == ROK)
6210       {
6211          memcpy(duToCuRrcContainer->buf, encBuf, duToCuRrcContainer->size);
6212       }
6213       break;
6214    }
6215    FreeMemDuToCuRrcCont(&cellGrpCfg);
6216    return ret;
6217 }
6218
6219 /*******************************************************************
6220  *
6221  * @brief Free memory allocated in InitialULRRCMessage
6222  *
6223  * @details
6224  *
6225  *    Function : freeInitUlRrcMsgTransfer
6226  *
6227  *    Functionality: Free memory allocated in InitialULRRCMessage
6228  *
6229  * @params[in]F1AP_PDU_t  *f1apMsg)
6230  *
6231  * @return ROK     - success
6232  *         RFAILED - failure
6233  *
6234  * ****************************************************************/
6235
6236 uint8_t freeInitUlRrcMsgTransfer(F1AP_PDU_t  *f1apMsg)
6237 {
6238    uint8_t ieIdx, arrIdx;
6239    InitialULRRCMessageTransfer_t *initULRRCMsg=NULLP;
6240
6241    if(f1apMsg)
6242    {
6243       if(f1apMsg->choice.initiatingMessage)
6244       {
6245          initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.\
6246             choice.InitialULRRCMessageTransfer;
6247          if(initULRRCMsg->protocolIEs.list.array)
6248          {
6249             for(ieIdx = 0; ieIdx < initULRRCMsg->protocolIEs.list.count; ieIdx++)
6250             {
6251                switch(initULRRCMsg->protocolIEs.list.array[ieIdx]->id)
6252                {
6253                   case ProtocolIE_ID_id_NRCGI:
6254                   {
6255                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf)
6256                      {
6257                         if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf)
6258                         {
6259                            DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf,\
6260                            initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.size);
6261                         }
6262                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf,\
6263                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.size);
6264                      }
6265                      break;
6266                   }
6267                   case ProtocolIE_ID_id_RRCContainer:
6268                   {
6269                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
6270                      {
6271                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,\
6272                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
6273                      }
6274                      break;
6275                   }
6276                   case ProtocolIE_ID_id_DUtoCURRCContainer:
6277                   {
6278                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf)
6279                      {
6280                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf,
6281                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.size);
6282                      }
6283                      break;
6284                   }
6285                   default:
6286                      break;
6287                }
6288              }
6289              for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
6290              {
6291                 if(initULRRCMsg->protocolIEs.list.array[arrIdx])
6292                 {
6293                    DU_FREE(initULRRCMsg->protocolIEs.list.array[arrIdx],\
6294                       sizeof(InitialULRRCMessageTransferIEs_t));
6295                 }
6296              }
6297              DU_FREE(initULRRCMsg->protocolIEs.list.array, initULRRCMsg->protocolIEs.list.size);
6298           }
6299          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
6300       }
6301       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
6302    }
6303    else
6304    {
6305       DU_LOG("\nERROR  -->  DU_APP : Recevied F1ap Pdu is null at freeInitUlRrcMsgTransfer()");
6306       return RFAILED;
6307    }
6308    return ROK;
6309 }
6310
6311 /*******************************************************************
6312  *
6313  * @brief Builds and sends the InitialULRRCMessage
6314  *
6315  * @details
6316  *
6317  *    Function : BuildAndSendInitialRrcMsgTransfer
6318  *
6319  *    Functionality: Constructs the Initial UL RRC Message Transfer and sends
6320  *                   it to the CU through SCTP.
6321  *
6322  * @params[in]
6323  *
6324  * @return ROK     - success
6325  *         RFAILED - failure
6326  *
6327  * ****************************************************************/
6328 uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti,
6329       uint16_t rrcContSize, uint8_t *rrcContainer)
6330 {
6331    uint8_t   ret;
6332    uint8_t   elementCnt;
6333    uint8_t   ieIdx;
6334    asn_enc_rval_t  encRetVal;
6335    F1AP_PDU_t  *f1apMsg = NULLP;
6336    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
6337    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
6338
6339    while(true)
6340    {
6341       DU_LOG("\n INFO   -->  F1AP : Building RRC Setup Request\n");
6342       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
6343       if(f1apMsg == NULLP)
6344       {
6345          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
6346          break;
6347       }
6348       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
6349       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
6350       if(f1apMsg->choice.initiatingMessage == NULLP)
6351       {
6352          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
6353          break;
6354       }
6355       f1apMsg->choice.initiatingMessage->procedureCode =\
6356                                                         ProcedureCode_id_InitialULRRCMessageTransfer;
6357       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
6358       f1apMsg->choice.initiatingMessage->value.present = \
6359                                                          InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
6360       initULRRCMsg =\
6361                     &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
6362       elementCnt = 5;
6363       initULRRCMsg->protocolIEs.list.count = elementCnt;
6364       initULRRCMsg->protocolIEs.list.size = \
6365                                             elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *);
6366       /* Initialize the F1Setup members */
6367       DU_ALLOC(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
6368       if(initULRRCMsg->protocolIEs.list.array == NULLP)
6369       {
6370          DU_LOG(" ERROR  -->  F1AP : Memory allocation for\
6371                RRCSetupRequestMessageTransferIEs failed");
6372          break;
6373       }
6374       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
6375       {
6376          DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx],\
6377                sizeof(InitialULRRCMessageTransferIEs_t));
6378          if(initULRRCMsg->protocolIEs.list.array[ieIdx] == NULLP)
6379          {
6380             break;
6381          }
6382       }
6383       ieIdx = 0;
6384       /*GNB DU UE F1AP ID*/
6385       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6386                                                         ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
6387       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  = Criticality_reject;
6388       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
6389                                                                   InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
6390       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
6391
6392
6393       /*NRCGI*/
6394       ieIdx++;
6395       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6396                                                         ProtocolIE_ID_id_NRCGI;
6397       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  =Criticality_reject;
6398       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
6399                                                                   InitialULRRCMessageTransferIEs__value_PR_NRCGI;
6400
6401       ret =\
6402            BuildNrcgi(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
6403       if(ret!=ROK)
6404       {
6405          break;
6406       }
6407
6408       /*CRNTI*/
6409       ieIdx++;
6410       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6411                                                         ProtocolIE_ID_id_C_RNTI;
6412       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6413       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6414                                                                  InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
6415       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.C_RNTI = crnti;
6416
6417       /*RRCContainer*/
6418       ieIdx++;
6419       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6420                                                         ProtocolIE_ID_id_RRCContainer;
6421       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6422       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6423                                                                  InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
6424
6425       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = rrcContSize;
6426       DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
6427             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size)
6428       if(!initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
6429       {
6430          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
6431          break;
6432
6433       }
6434       memcpy(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, rrcContainer,
6435             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
6436
6437
6438       /*DUtoCURRCContainer*/
6439       ieIdx++;
6440       initULRRCMsg->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCContainer;
6441       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6442       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6443                                                                  InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
6444
6445       ret = BuildDuToCuRrcContainer(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer);
6446       if(ret != ROK)
6447       {
6448          break;
6449       }
6450
6451       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
6452
6453       /* Encode the F1SetupRequest type as APER */
6454       memset(encBuf, 0, ENC_BUF_MAX_LEN);
6455       encBufSize = 0;
6456       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
6457       /* Encode results */
6458       if(encRetVal.encoded == ENCODE_FAIL)
6459       {
6460          DU_LOG( "\nERROR  --> F1AP : Could not encode Initial UL RRC Message Transfer\
6461                structure (at %s)\n",encRetVal.failed_type ? \
6462                encRetVal.failed_type->name : "unknown");
6463          ret = RFAILED;
6464          break;
6465       }
6466       else
6467       {
6468
6469          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for Initial UL RRC\
6470                Message transfer\n");
6471          for(int i=0; i< encBufSize; i++)
6472          {
6473             printf("%x",encBuf[i]);
6474          }
6475       }
6476       /* Sending  msg  */
6477       if(sendF1APMsg() != ROK)
6478       {
6479          DU_LOG("\nERROR  -->  F1AP : Sending Initial UL RRC Message Transfer Failed");
6480          ret = RFAILED;
6481          break;
6482       }
6483       break;
6484    }
6485    freeInitUlRrcMsgTransfer(f1apMsg);
6486    return ret;
6487 }/* End of BuildAndSendInitialRrcMsgTransfer*/
6488
6489 /*****  UE SETUP REQUEST *****/
6490
6491 /*******************************************************************
6492  *
6493  * @brief Free Qos And Snssai Drb Info
6494  *
6495  * @details
6496  *
6497  *    Function : freeDrbQosAndSnssaiInfo
6498  *
6499  *    Functionality: Free Qos And Snssai Drb Info
6500  *
6501  * @params[in] LcCfg *lcCfg,
6502  * @return void
6503  *
6504  * ****************************************************************/
6505 void freeDrbQosAndSnssaiInfo(LcCfg *lcCfg)
6506 {
6507    if(lcCfg->snssai)
6508    {
6509       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6510    }
6511    if(lcCfg->drbQos)
6512    {
6513       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
6514    }
6515 }
6516
6517 /******************************************************************
6518 *
6519 * @brief Function to delete the RLC Lc cfg from UE APP DB
6520 *
6521 * @details
6522 *
6523 *  Function : freeRlcLcCfg
6524 *
6525 *  Functionality: Function to delete the RLC Lc cfg from UE APP DB
6526 *
6527 *
6528  *****************************************************************/
6529
6530 void freeRlcLcCfg(RlcBearerCfg *lcCfg)
6531 {
6532    switch(lcCfg->rlcMode)
6533    {
6534       case RLC_AM :
6535          {
6536             if(lcCfg->u.amCfg)
6537             {
6538                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.amCfg, sizeof(AmBearerCfg));
6539             }
6540             break;
6541          }
6542       case RLC_UM_BI_DIRECTIONAL :
6543          {
6544             if(lcCfg->u.umBiDirCfg)
6545             {
6546                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
6547             }
6548             break;
6549          }
6550       case RLC_UM_UNI_DIRECTIONAL_UL :
6551          {
6552             if(lcCfg->u.umUniDirUlCfg)
6553             {
6554                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
6555             }
6556             break;
6557
6558          }
6559       case RLC_UM_UNI_DIRECTIONAL_DL :
6560          {
6561             if(lcCfg->u.umUniDirDlCfg)
6562             {
6563                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
6564             }
6565             break;
6566          }
6567       default:
6568          DU_LOG("\nERROR  -->  DU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
6569          break;
6570    }
6571    DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6572 }
6573
6574 /*******************************************************************
6575  *
6576  * @brief Function to free MacLcCfg
6577  *
6578  * @details
6579  *
6580  *    Function : freeMacLcCfg
6581  *
6582  *    Functionality: Function to free MacLcCfg
6583  *
6584  * @params[in] LcCfg *lcCfg,
6585  * @return void
6586  *
6587  * ****************************************************************/
6588
6589 void  freeMacLcCfg(LcCfg *lcCfg)
6590 {
6591     /* Deleting DRBQOS */
6592    if(lcCfg->drbQos)
6593    {
6594       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
6595    }
6596    /* Deleting SNSSAI */
6597    if(lcCfg->snssai)
6598    {
6599       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6600    }
6601 }
6602 /*******************************************************************
6603  *
6604  * @brief Free UE NR Capability received in UE Context setup request
6605  *
6606  * @details
6607  *
6608  *    Function : freeAperDecodeUeNrCapability
6609  *
6610  *    Functionality:
6611  *       Free UE NR Capability received in UE Context setup request
6612  *
6613  * @params[in]
6614  * @return ROK     - success
6615  *         RFAILED - failure
6616  *
6617  * ****************************************************************/
6618 void freeAperDecodeUeNrCapability(void *ueNrCapability)
6619 {
6620    uint8_t arrIdx =0;
6621    FeatureSets_t *featureSets =NULLP;
6622    UE_NR_Capability_t *ueNrCap = (UE_NR_Capability_t *)ueNrCapability;
6623
6624    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
6625    {
6626       for(arrIdx = 0; arrIdx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; arrIdx++)
6627       {
6628          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx])
6629             free(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx]);
6630       }
6631       free(ueNrCap->rf_Parameters.supportedBandListNR.list.array);
6632    }
6633
6634    if(ueNrCap->featureSets)
6635    {
6636       featureSets = ueNrCap->featureSets;
6637       if(featureSets->featureSetsDownlinkPerCC)
6638       {
6639          if(featureSets->featureSetsDownlinkPerCC->list.array)
6640          {
6641             for(arrIdx = 0; arrIdx < featureSets->featureSetsDownlinkPerCC->list.count; arrIdx++)
6642             {
6643                if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx])
6644                {
6645                   if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL)
6646                      free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL);
6647                   free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]);
6648                }
6649             }
6650             free(featureSets->featureSetsDownlinkPerCC->list.array);
6651          }
6652          free(featureSets->featureSetsDownlinkPerCC);
6653       }
6654       if(featureSets->featureSetsUplinkPerCC)
6655       {
6656          if(featureSets->featureSetsUplinkPerCC->list.array)
6657          {
6658             for(arrIdx = 0; arrIdx < featureSets->featureSetsUplinkPerCC->list.count; arrIdx++)
6659             {
6660                if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx])
6661                {
6662                   if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL)
6663                      free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL);
6664                   free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]);
6665                }
6666             }
6667             free(featureSets->featureSetsUplinkPerCC->list.array);
6668          }
6669          free(featureSets->featureSetsUplinkPerCC);
6670       }
6671       free(ueNrCap->featureSets);
6672    }
6673 }
6674
6675 /*******************************************************************
6676 *
6677 * @brief Function to free PdcchSearchSpcToAddModList
6678          where memory allocated by aper_decoder
6679 *
6680 * @details
6681 *
6682 *    Function : freeAperDecodePdcchSearchSpcToAddModList
6683 *
6684 *    Functionality: Function to free PdcchSearchSpcToAddModList
6685 *
6686 * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
6687 * @return void
6688 *
6689 * ****************************************************************/
6690
6691 void freeAperDecodePdcchSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
6692 {
6693    uint8_t searchSpcArrIdx=0;
6694    uint8_t searchSpcArrIdx1=0;
6695    struct  SearchSpace *searchSpc=NULLP;
6696
6697
6698    if(searchSpcList->list.array)
6699    {
6700       if(searchSpcList->list.array[searchSpcArrIdx1])
6701       {
6702          searchSpc = searchSpcList->list.array[searchSpcArrIdx1];
6703          if(searchSpc->controlResourceSetId)
6704          {
6705             if(searchSpc->monitoringSlotPeriodicityAndOffset)
6706             {
6707                if(searchSpc->monitoringSymbolsWithinSlot)
6708                {
6709                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
6710                   {
6711                      if(searchSpc->nrofCandidates)
6712                      {
6713                         if(searchSpc->searchSpaceType)
6714                         {
6715                            free(searchSpc->searchSpaceType->choice.ue_Specific);
6716                            free(searchSpc->searchSpaceType);
6717                         }
6718                         free(searchSpc->nrofCandidates);
6719                      }
6720                      free(searchSpc->monitoringSymbolsWithinSlot->buf);
6721                   }
6722                   free(searchSpc->monitoringSymbolsWithinSlot);
6723                }
6724                free(searchSpc->monitoringSlotPeriodicityAndOffset);
6725             }
6726             free(searchSpc->controlResourceSetId);
6727          }
6728       }
6729       for(searchSpcArrIdx = 0; searchSpcArrIdx < searchSpcList->list.count; searchSpcArrIdx++)
6730       {
6731          free(searchSpcList->list.array[searchSpcArrIdx]);
6732       }
6733       free(searchSpcList->list.array);
6734    }
6735 }
6736 /*******************************************************************
6737 *
6738 * @brief Function for free part for the memory allocated by aper_decoder
6739 *
6740 * @details
6741 *
6742 *    Function : freeAperDecodeBWPDlDedPdcchConfig
6743 *
6744 *    Functionality: Function to free BWPDlDedPdcchConfig
6745 *
6746 * @params[in]
6747 * @return void
6748 *
6749 * ****************************************************************/
6750
6751
6752 void freeAperDecodeBWPDlDedPdcchConfig(BWP_DownlinkDedicated_t *dlBwp)
6753 {
6754    uint8_t arrIdx1=0;
6755    uint8_t arrIdx2=0;
6756    struct PDCCH_Config *pdcchCfg=NULLP;
6757    struct ControlResourceSet *controlRSet=NULLP;
6758    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
6759
6760    if(dlBwp->pdcch_Config->choice.setup)
6761    {
6762       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
6763       if(pdcchCfg->controlResourceSetToAddModList)
6764       {
6765          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
6766          if(controlRSetList->list.array)
6767          {
6768             controlRSet = controlRSetList->list.array[arrIdx2];
6769             if(controlRSet)
6770             {
6771                if(controlRSet->frequencyDomainResources.buf)
6772                {
6773                   if(controlRSet->pdcch_DMRS_ScramblingID)
6774                   {
6775                      if(pdcchCfg->searchSpacesToAddModList)
6776                      {
6777                         freeAperDecodePdcchSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
6778                         free(pdcchCfg->searchSpacesToAddModList);
6779                      }
6780                      free(controlRSet->pdcch_DMRS_ScramblingID);
6781                   }
6782                   free(controlRSet->frequencyDomainResources.buf);
6783                }
6784             }
6785             for(arrIdx1 = 0; arrIdx1 <controlRSetList->list.count; arrIdx1++)
6786             {
6787                free(controlRSetList->list.array[arrIdx1]);
6788             }
6789             free(controlRSetList->list.array);
6790          }
6791          free(pdcchCfg->controlResourceSetToAddModList);
6792       }
6793       free(dlBwp->pdcch_Config->choice.setup);
6794    }
6795 }
6796 /*******************************************************************
6797 *
6798 * @brief Function to free PdschTimeDomAllocationList
6799 *     where the memory allocated by aper_decoder
6800 *
6801 * @details
6802 *
6803 *    Function : freeAperDecodePdschTimeDomAllocationList
6804 *
6805 *    Functionality: Function to free PdschTimeDomAllocationList
6806 *
6807 * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
6808 * @return void
6809 *
6810 * ****************************************************************/
6811
6812
6813 void freeAperDecodePdschTimeDomAllocationList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
6814 {
6815    uint8_t arrIdx=0;
6816
6817    if(timeDomAllocList->choice.setup)
6818    {
6819       if(timeDomAllocList->choice.setup->list.array)
6820       {
6821          for(arrIdx = 0; arrIdx <timeDomAllocList->choice.setup->list.count ; arrIdx++)
6822          {
6823             free(timeDomAllocList->choice.setup->list.array[arrIdx]);
6824          }
6825          free(timeDomAllocList->choice.setup->list.array);
6826       }
6827       free(timeDomAllocList->choice.setup);
6828    }
6829 }
6830
6831 /*******************************************************************
6832 *
6833 * @brief Function to free BWPDlDedPdschConfig
6834 *        where the memory allocated by aper_decoder
6835 *
6836 * @details
6837 *
6838 *    Function : freeAperDecodeBWPDlDedPdschConfig
6839 *
6840 *    Functionality: Function to free BWPDlDedPdschConfig
6841 *
6842 * @params[in] BWP_DownlinkDedicated_t *dlBwp
6843 * @return void
6844 *
6845 * ****************************************************************/
6846
6847
6848 void freeAperDecodeBWPDlDedPdschConfig(BWP_DownlinkDedicated_t *dlBwp)
6849 {
6850    struct PDSCH_Config *pdschCfg=NULLP;
6851    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
6852    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
6853    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
6854
6855    if(dlBwp->pdsch_Config->choice.setup)
6856    {
6857       pdschCfg=dlBwp->pdsch_Config->choice.setup;
6858       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
6859       {
6860          if(pdschCfg->pdsch_TimeDomainAllocationList)
6861          {
6862             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
6863             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
6864             {
6865                prbBndlType=&pdschCfg->prb_BundlingType;
6866                free(prbBndlType->choice.staticBundling);
6867                free(pdschCfg->maxNrofCodeWordsScheduledByDCI);
6868             }
6869             freeAperDecodePdschTimeDomAllocationList(timeDomAllocList);
6870             free(pdschCfg->pdsch_TimeDomainAllocationList);
6871          }
6872          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
6873          if(dmrsDlCfg->choice.setup)
6874          {
6875             free(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition);
6876             free(dmrsDlCfg->choice.setup);
6877          }
6878          free(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA);
6879       }
6880       free(dlBwp->pdsch_Config->choice.setup);
6881    }
6882 }
6883 /*******************************************************************
6884 *
6885 * @brief Function to free PuschTimeDomAllocListCfg
6886                  where the memory allocated by aper_decoder
6887 *
6888 * @details
6889 *
6890 *    Function : freeAperDecodePuschTimeDomAllocListCfg
6891 *
6892 *    Functionality: Function to free PuschTimeDomAllocListCfg
6893 *
6894 * @params[in] PUSCH_Config_t *puschCfg
6895 * @return void
6896 *
6897 * ****************************************************************/
6898
6899
6900 void freeAperDecodePuschTimeDomAllocListCfg(PUSCH_Config_t *puschCfg)
6901 {
6902    uint8_t arrIdx=0;
6903    uint8_t arrIdx1=0;
6904    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
6905
6906    if(puschCfg->pusch_TimeDomainAllocationList)
6907    {
6908       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
6909       if(timeDomAllocList_t->choice.setup)
6910       {
6911          if(timeDomAllocList_t->choice.setup->list.array)
6912          {
6913             free(timeDomAllocList_t->choice.setup->list.array[arrIdx1]->k2);
6914             for(arrIdx = 0; arrIdx<timeDomAllocList_t->choice.setup->list.count; arrIdx++)
6915             {
6916                free(timeDomAllocList_t->choice.setup->list.array[arrIdx]);
6917             }
6918             free(timeDomAllocList_t->choice.setup->list.array);
6919          }
6920          free(timeDomAllocList_t->choice.setup);
6921       }
6922       free(puschCfg->transformPrecoder);
6923       free(puschCfg->pusch_TimeDomainAllocationList);
6924    }
6925 }
6926 /*******************************************************************
6927 *
6928 * @brief Function to free InitialUlBWPConfig where memory allocated by aper_decoder
6929 *
6930 * @details
6931 *
6932 *    Function : freeAperDecodeInitialUlBWPConfig
6933 *
6934 *    Functionality: Function to free InitialUlBWPConfig
6935 *
6936 * @params[in]  BWP_UplinkDedicated_t *ulBwp
6937 * @return void
6938 *
6939 * ****************************************************************/
6940
6941
6942 void freeAperDecodeInitialUlBWPConfig(BWP_UplinkDedicated_t *ulBwp)
6943 {
6944    uint8_t  rSetIdx =0;
6945    uint8_t  rsrcIdx =0;
6946    SRS_Config_t   *srsCfg = NULLP;
6947    PUSCH_Config_t *puschCfg = NULLP;
6948    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
6949    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
6950    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
6951    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
6952
6953    if(ulBwp->pusch_Config)
6954    {
6955       if(ulBwp->pusch_Config->choice.setup)
6956       {
6957          puschCfg=ulBwp->pusch_Config->choice.setup;
6958          if(puschCfg->dataScramblingIdentityPUSCH)
6959          {
6960             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
6961             {
6962                freeAperDecodePuschTimeDomAllocListCfg(puschCfg);
6963                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
6964                if(dmrsUlCfg->choice.setup)
6965                {
6966                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
6967                   {
6968                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
6969                      {
6970                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0);
6971                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled);
6972                      }
6973                      free(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition);
6974                   }
6975                   free(dmrsUlCfg->choice.setup);
6976                }
6977                free(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA);
6978             }
6979             free(puschCfg->dataScramblingIdentityPUSCH);
6980          }
6981          free(ulBwp->pusch_Config->choice.setup);
6982       }
6983       free(ulBwp->pusch_Config);
6984
6985       /* Free SRS-Config */
6986       if(ulBwp->srs_Config)
6987       {
6988          if(ulBwp->srs_Config->choice.setup)
6989          {
6990             srsCfg = ulBwp->srs_Config->choice.setup;
6991
6992             /* Free Resource Set to add/mod list */
6993             if(srsCfg->srs_ResourceSetToAddModList)
6994             {
6995                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
6996                if(rsrcSetList->list.array)
6997                {
6998                   rSetIdx = 0;
6999
7000                   /* Free SRS resource Id list in this SRS resource set */
7001                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
7002                   {
7003                      rsrcIdList =
7004                         rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
7005
7006                      if(rsrcIdList->list.array)
7007                      {
7008                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count;
7009                               rsrcIdx++)
7010                         {
7011                            free(rsrcIdList->list.array[rsrcIdx]);
7012                         }
7013                         free(rsrcIdList->list.array);
7014                      }
7015                      free(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList);
7016                   }
7017
7018                   /* Free resource type info for this SRS resource set */
7019
7020                   free(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic);
7021
7022                   /* Free memory for each resource set */
7023                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
7024                   {
7025                      free(rsrcSetList->list.array[rSetIdx]);
7026                   }
7027                   free(rsrcSetList->list.array);
7028                }
7029                free(srsCfg->srs_ResourceSetToAddModList);
7030             }
7031
7032             /* Free resource to add/modd list */
7033             if(srsCfg->srs_ResourceToAddModList)
7034             {
7035                resourceList = srsCfg->srs_ResourceToAddModList;
7036                if(resourceList->list.array)
7037                {
7038                   rsrcIdx = 0;
7039
7040                   free(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2);
7041                   free(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic);
7042
7043                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
7044                   {
7045                      free(resourceList->list.array[rsrcIdx]);
7046                   }
7047                   free(resourceList->list.array);
7048                }
7049                free(srsCfg->srs_ResourceToAddModList);
7050             }
7051
7052             free(ulBwp->srs_Config->choice.setup);
7053          }
7054          free(ulBwp->srs_Config);
7055       }
7056    }
7057 }
7058 /*******************************************************************
7059 *
7060 * @brief Function to free initialUplinkBWPConfig where memory allocated by aper_decoder
7061 *
7062 * @details
7063 *
7064 *    Function : freeAperDecodeinitialUplinkBWPConfig
7065 *
7066 *    Functionality: Function to free initialUplinkBWPConfig
7067 *
7068 * @params[in] UplinkConfig_t *ulCfg
7069 * @return void
7070 *
7071 * ****************************************************************/
7072
7073
7074 void freeAperDecodeinitialUplinkBWPConfig(UplinkConfig_t *ulCfg)
7075 {
7076    BWP_UplinkDedicated_t *ulBwp=NULLP;
7077    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
7078
7079    if(ulCfg->initialUplinkBWP)
7080    {
7081       ulBwp=ulCfg->initialUplinkBWP;
7082       if(ulCfg->firstActiveUplinkBWP_Id)
7083       {
7084          if(ulCfg->pusch_ServingCellConfig)
7085          {
7086             puschCfg=ulCfg->pusch_ServingCellConfig;
7087             if(puschCfg->choice.setup)
7088             {
7089                if(puschCfg->choice.setup->ext1)
7090                {
7091                   free(puschCfg->choice.setup->ext1->processingType2Enabled);
7092                   free(puschCfg->choice.setup->ext1->maxMIMO_Layers);
7093                   free(puschCfg->choice.setup->ext1);
7094                }
7095                free(puschCfg->choice.setup);
7096             }
7097             free(ulCfg->pusch_ServingCellConfig);
7098          }
7099          free(ulCfg->firstActiveUplinkBWP_Id);
7100       }
7101       freeAperDecodeInitialUlBWPConfig(ulBwp);
7102       free(ulCfg->initialUplinkBWP);
7103    }
7104 }
7105
7106 /*******************************************************************
7107  *
7108  * @brief Function to free DuUeCfg
7109  *
7110  * @details
7111  *
7112  *    Function : freeDuUeCfg
7113  *
7114  *    Functionality: Function to free DuUeCfg
7115  *
7116  * @params[in] DuUeCfg *ueCfg
7117  * @return void
7118  *
7119  * ****************************************************************/
7120 void freeDuUeCfg(DuUeCfg *ueCfg)
7121 {
7122    uint8_t lcIdx = 0;
7123    uint8_t arrIdx = 0;
7124    SpCellConfig_t *spCellCfg = NULLP;
7125    ServingCellConfig_t *srvCellCfg = NULLP;
7126    BWP_DownlinkDedicated_t *dlBwp = NULLP;
7127    MAC_CellGroupConfig_t *macCellGrpCfg = NULLP;
7128    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
7129    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList = NULLP;
7130    struct RLC_Config *rlcConfig = NULLP;
7131    struct LogicalChannelConfig *macLcConfig = NULLP;
7132    struct SchedulingRequestConfig *schedulingRequestConfig = NULLP;
7133    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList = NULLP;
7134    struct TAG_Config *tagConfig = NULLP;
7135    struct TAG_Config__tag_ToAddModList *tagList = NULLP;
7136    struct MAC_CellGroupConfig__phr_Config *phrConfig = NULLP;
7137    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg = NULLP;
7138    CellGroupConfigRrc_t *cellGrpCfg = ueCfg->cellGrpCfg;
7139
7140    if(ueCfg->ueNrCapability)
7141    {
7142       freeAperDecodeUeNrCapability(ueCfg->ueNrCapability);
7143       DU_FREE(ueCfg->ueNrCapability, sizeof(UE_NR_Capability_t));
7144       ueCfg->ueNrCapability = NULLP;
7145    }
7146
7147    if(ueCfg->cellGrpCfg)
7148    {
7149
7150       rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
7151       if(rlcBearerList)
7152       {
7153          if(rlcBearerList->list.array)
7154          {
7155             for(arrIdx=0; arrIdx<rlcBearerList->list.count; arrIdx++)
7156             {
7157                if(rlcBearerList->list.array[arrIdx])
7158                {
7159                   rlcConfig   = rlcBearerList->list.array[arrIdx]->rlc_Config;
7160                   macLcConfig = rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig;
7161
7162                   if(rlcBearerList->list.array[arrIdx]->servedRadioBearer)
7163                   {
7164                      free(rlcBearerList->list.array[arrIdx]->servedRadioBearer);
7165                   }
7166                   if(rlcConfig)
7167                   {
7168                      if(rlcConfig->choice.am)
7169                      {
7170                         free(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength);
7171                         free(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength);
7172                         free(rlcConfig->choice.am);
7173                      }
7174                      free(rlcBearerList->list.array[arrIdx]->rlc_Config);
7175                   }
7176                   if(macLcConfig)
7177                   {
7178                      if(macLcConfig->ul_SpecificParameters)
7179                      {
7180                         free(macLcConfig->ul_SpecificParameters->schedulingRequestID);
7181                         free(macLcConfig->ul_SpecificParameters->logicalChannelGroup);
7182                         free(macLcConfig->ul_SpecificParameters);
7183                      }
7184                      free(rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig);
7185                   }
7186                   free(rlcBearerList->list.array[arrIdx]);
7187                }
7188             }
7189             free(rlcBearerList->list.array);
7190          }
7191          free(cellGrpCfg->rlc_BearerToAddModList);
7192       }
7193
7194       macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
7195       if(macCellGrpCfg)
7196       {
7197          schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
7198          if(schedulingRequestConfig)
7199          {
7200             schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
7201             if(schReqList)
7202             {
7203                if(schReqList->list.array)
7204                {
7205                   for(arrIdx=0;arrIdx<schReqList->list.count; arrIdx++)
7206                   {
7207                      if(schReqList->list.array[arrIdx])
7208                      {
7209                         free(schReqList->list.array[arrIdx]->sr_ProhibitTimer);
7210                         free(schReqList->list.array[arrIdx]);
7211                      }
7212                   }
7213                   free(schReqList->list.array);
7214                }
7215                free(schedulingRequestConfig->schedulingRequestToAddModList);
7216             }
7217             free(macCellGrpCfg->schedulingRequestConfig);
7218          }
7219          if(macCellGrpCfg->bsr_Config)
7220          {
7221             free(macCellGrpCfg->bsr_Config);
7222          }
7223          tagConfig = macCellGrpCfg->tag_Config;
7224          if(tagConfig)
7225          {
7226             tagList = tagConfig->tag_ToAddModList;
7227             if(tagList)
7228             {
7229                if(tagList->list.array)
7230                {
7231                   for(arrIdx=0; arrIdx<tagList->list.count; arrIdx++)
7232                   {
7233                      free(tagList->list.array[arrIdx]);
7234                   }
7235                   free(tagList->list.array);
7236                }
7237                free(tagConfig->tag_ToAddModList);
7238             }
7239             free(tagConfig);
7240          }
7241
7242          phrConfig = macCellGrpCfg->phr_Config;
7243          if(phrConfig)
7244          {
7245             free(phrConfig->choice.setup);
7246             free(phrConfig);
7247          }
7248
7249          free(macCellGrpCfg);
7250       }
7251
7252       phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
7253       if(phyCellGrpCfg)
7254       {
7255          free(phyCellGrpCfg->p_NR_FR1);
7256          free(phyCellGrpCfg);
7257       }
7258
7259       spCellCfg = cellGrpCfg->spCellConfig;
7260       if(spCellCfg)
7261       {
7262          if(spCellCfg->servCellIndex)
7263          {
7264             if(spCellCfg->rlmInSyncOutOfSyncThreshold)
7265             {
7266                if(spCellCfg->spCellConfigDedicated)
7267                {
7268                   srvCellCfg = spCellCfg->spCellConfigDedicated;
7269                   if(srvCellCfg->initialDownlinkBWP)
7270                   {
7271                      dlBwp = srvCellCfg->initialDownlinkBWP;
7272                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
7273                      {
7274                         if(srvCellCfg->defaultDownlinkBWP_Id)
7275                         {
7276                            if(srvCellCfg->uplinkConfig)
7277                            {
7278
7279                               if(srvCellCfg->pdsch_ServingCellConfig)
7280                               {
7281                                  pdschCfg=
7282                                     srvCellCfg->pdsch_ServingCellConfig;
7283                                  if(pdschCfg->choice.setup)
7284                                  {
7285
7286                                     free(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH);
7287                                     free(pdschCfg->choice.setup);
7288                                  }
7289
7290                                  free(srvCellCfg->pdsch_ServingCellConfig);
7291                               }
7292
7293                               freeAperDecodeinitialUplinkBWPConfig(srvCellCfg->uplinkConfig);
7294                               free(srvCellCfg->uplinkConfig);
7295                            }
7296                            free(srvCellCfg->defaultDownlinkBWP_Id);
7297                         }
7298
7299                         free(srvCellCfg->firstActiveDownlinkBWP_Id);
7300                      }
7301                      if(dlBwp->pdcch_Config)
7302                      {
7303                         if(dlBwp->pdsch_Config)
7304                         {
7305                            freeAperDecodeBWPDlDedPdschConfig(dlBwp);
7306                            free(dlBwp->pdsch_Config);
7307                         }
7308                         freeAperDecodeBWPDlDedPdcchConfig(dlBwp);
7309                         free(dlBwp->pdcch_Config);
7310                      }
7311                      free(srvCellCfg->initialDownlinkBWP);
7312                   }
7313
7314                   free(spCellCfg->spCellConfigDedicated);
7315                }
7316                free(spCellCfg->rlmInSyncOutOfSyncThreshold);
7317             }
7318             free(spCellCfg->servCellIndex);
7319          }
7320          free(spCellCfg);
7321       }
7322       DU_FREE(ueCfg->cellGrpCfg, sizeof(CellGroupConfigRrc_t));
7323       ueCfg->cellGrpCfg = NULLP;
7324    }
7325    if(ueCfg->ambrCfg)
7326    {
7327       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->ambrCfg, sizeof(AmbrCfg));
7328    }
7329    for(lcIdx = 0; lcIdx < ueCfg->numRlcLcs; lcIdx++)
7330    {
7331       freeRlcLcCfg(&ueCfg->rlcLcCfg[lcIdx]);
7332    }
7333    for(lcIdx = 0; lcIdx < ueCfg->numMacLcs; lcIdx++)
7334    {
7335       freeMacLcCfg(&ueCfg->macLcCfg[lcIdx]);
7336    }
7337    for(lcIdx = 0; lcIdx < ueCfg->numDrb; lcIdx++)
7338    {
7339       DU_FREE(ueCfg->upTnlInfo[lcIdx].tnlCfg1, sizeof(GtpTnlCfg));
7340    }
7341 }
7342
7343 /*******************************************************************
7344  *
7345  * @brief Function to free UecontextSetupDb
7346  *
7347  * @details
7348  *
7349  *    Function : freeF1UeDb
7350  *
7351  *    Functionality: Function to free UecontextSetupDb
7352  *
7353  * @params[in] UecontextSetupDb *
7354  * @return void
7355  *
7356  * ****************************************************************/
7357
7358 void freeF1UeDb(F1UeContextSetupDb *f1UeDb)
7359 {
7360
7361    if(f1UeDb->dlRrcMsg)
7362    {
7363       if(f1UeDb->dlRrcMsg->rrcMsgPdu)
7364       {
7365         //DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,\
7366                f1UeDb->dlRrcMsg->rrcMsgPdu, f1UeDb->dlRrcMsg->rrcMsgSize);
7367       }
7368       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
7369    }
7370    freeDuUeCfg(&f1UeDb->duUeCfg);
7371    memset(f1UeDb, 0, sizeof(F1UeContextSetupDb));
7372    DU_FREE(f1UeDb, sizeof(F1UeContextSetupDb));
7373 }
7374
7375 /*******************************************************************
7376  *
7377  * @brief Function to build Am cfg Info
7378  *
7379  * @details
7380  *
7381  *    Function : extractRlcAmCfg
7382  *
7383  *    Functionality: Function to build Am cfg Info
7384  *
7385  * @params[in] AmBearerCfg *
7386  *             void *
7387  *
7388  * @return ROK/RFAILED
7389  *
7390  * ****************************************************************/
7391
7392 void extractRlcAmCfg(AmBearerCfg *amCfgToSet, struct RLC_Config__am *rlcAmCfg)
7393 {
7394    if(rlcAmCfg)
7395    {
7396       /* UL AM */
7397       if(rlcAmCfg->dl_AM_RLC.sn_FieldLength)
7398       {
7399          amCfgToSet->ulAmCfg.snLenUl = *(rlcAmCfg->dl_AM_RLC.sn_FieldLength);
7400          /*TODO: Check the timer value when sent by real CU */
7401          amCfgToSet->ulAmCfg.reAssemTmr = rlcAmCfg->dl_AM_RLC.t_Reassembly;
7402          amCfgToSet->ulAmCfg.statProhTmr = rlcAmCfg->dl_AM_RLC.t_StatusProhibit;
7403       }
7404
7405       /* DL AM */
7406       if(rlcAmCfg->ul_AM_RLC.sn_FieldLength)
7407       {
7408          amCfgToSet->dlAmCfg.snLenDl = *(rlcAmCfg->ul_AM_RLC.sn_FieldLength);
7409          amCfgToSet->dlAmCfg.pollRetxTmr = rlcAmCfg->ul_AM_RLC.t_PollRetransmit;
7410          amCfgToSet->dlAmCfg.pollPdu   = rlcAmCfg->ul_AM_RLC.pollPDU;
7411          amCfgToSet->dlAmCfg.pollByte  = rlcAmCfg->ul_AM_RLC.pollByte;
7412          amCfgToSet->dlAmCfg.maxRetxTh = rlcAmCfg->ul_AM_RLC.maxRetxThreshold;
7413       }
7414    }
7415 }
7416
7417 /*******************************************************************
7418  *
7419  * @brief Function to build Um Bi Info
7420  *
7421  * @details
7422  *
7423  *    Function : extractRlcUmBiCfg
7424  *
7425  *    Functionality: Function to build Um Bi Info
7426  *
7427  * @params[in] UmBiDirBearerCfg *
7428  *             void *
7429  *
7430  * @return ROK/RFAILED
7431  *
7432  * ****************************************************************/
7433
7434 void extractRlcUmBiCfg(UmBiDirBearerCfg *umBiCfgToSet, struct RLC_Config__um_Bi_Directional *rlcBiCfg)
7435 {
7436    if(rlcBiCfg)
7437    {
7438       /* UL UM BI DIR Cfg */
7439       if(rlcBiCfg->dl_UM_RLC.sn_FieldLength)
7440       {
7441          umBiCfgToSet->ulUmCfg.snLenUlUm  = *(rlcBiCfg->dl_UM_RLC.sn_FieldLength);
7442          umBiCfgToSet->ulUmCfg.reAssemTmr = rlcBiCfg->dl_UM_RLC.t_Reassembly;
7443       }
7444
7445       /* DL UM BI DIR Cfg */
7446       if(rlcBiCfg->ul_UM_RLC.sn_FieldLength)
7447          umBiCfgToSet->dlUmCfg.snLenDlUm  = *(rlcBiCfg->ul_UM_RLC.sn_FieldLength);
7448    }
7449 }
7450
7451 /*******************************************************************
7452  *
7453  * @brief Function to build Um Ul Info
7454  *
7455  * @details
7456  *
7457  *    Function : extractRlcUmUlCfg
7458  *
7459  *    Functionality: Function to build Um Ul Info
7460  *
7461  * @params[in] UmUniDirUlBearerCfg *
7462  *             void *
7463  *
7464  * @return ROK/RFAILED
7465  *
7466  * ****************************************************************/
7467
7468 void extractRlcUmUlCfg(UmUniDirUlBearerCfg *umUlCfgToSet, struct RLC_Config__um_Uni_Directional_DL *umUlCfg)
7469 {
7470    if(umUlCfg)
7471    {
7472       if(umUlCfg->dl_UM_RLC.sn_FieldLength)
7473       {
7474          umUlCfgToSet->ulUmCfg.snLenUlUm  = *(umUlCfg->dl_UM_RLC.sn_FieldLength);
7475          umUlCfgToSet->ulUmCfg.reAssemTmr = umUlCfg->dl_UM_RLC.t_Reassembly;
7476       }
7477    }
7478 }
7479
7480 /*******************************************************************
7481  *
7482  * @brief Function to build Um Uni Dl Info
7483  *
7484  * @details
7485  *
7486  *    Function : extractRlcUmDlCfg
7487  *
7488  *    Functionality: Function to build Um Uni Dl Info
7489  *
7490  * @params[in] UmUniDirDlBearerCfg *
7491  *             void *
7492  *
7493  * @return ROK/RFAILED
7494  *
7495  * ****************************************************************/
7496 void extractRlcUmDlCfg(UmUniDirDlBearerCfg *umDlCfgToSet, struct RLC_Config__um_Uni_Directional_UL *umDlCfg)
7497 {
7498    if(umDlCfg)
7499    {
7500       if(umDlCfg->ul_UM_RLC.sn_FieldLength)
7501          umDlCfgToSet->dlUmCfg.snLenDlUm  = *(umDlCfg->ul_UM_RLC.sn_FieldLength);
7502    }
7503 }
7504
7505 /*******************************************************************
7506  *
7507  * @brief Function to extractRlcModeCfg
7508  *
7509  * @details
7510  *
7511  *    Function : extractRlcModeCfg
7512  *
7513  *    Functionality: Function to extractRlcModeCfg
7514  *
7515  * @params[in] RLC_Config_t *
7516  *             RlcBearerCfg *
7517  *             void  *
7518  * @return ROK/RFAILED
7519  *
7520  * ****************************************************************/
7521 void extractRlcModeCfg(uint8_t rlcMode, RlcBearerCfg *rlcDbCfg, RLC_Config_t *lcCfg)
7522 {
7523    if(lcCfg)
7524    {
7525       switch(rlcMode)
7526       {
7527          case RLC_AM :
7528             {
7529                if(lcCfg->choice.am)
7530                {
7531                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.amCfg, sizeof(AmBearerCfg));
7532                   if(rlcDbCfg->u.amCfg)
7533                      extractRlcAmCfg(rlcDbCfg->u.amCfg, lcCfg->choice.am);
7534                }
7535                break;
7536             }
7537          case RLC_UM_BI_DIRECTIONAL :
7538             {
7539                if(lcCfg->choice.um_Bi_Directional)
7540                {
7541                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
7542                   if(rlcDbCfg->u.umBiDirCfg)
7543                      extractRlcUmBiCfg(rlcDbCfg->u.umBiDirCfg, lcCfg->choice.um_Bi_Directional);
7544                }
7545                break;
7546             }
7547          case RLC_UM_UNI_DIRECTIONAL_UL :
7548             {
7549                if(lcCfg->choice.um_Uni_Directional_DL)
7550                {
7551                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
7552                   if(rlcDbCfg->u.umUniDirUlCfg)
7553                      extractRlcUmUlCfg(rlcDbCfg->u.umUniDirUlCfg, lcCfg->choice.um_Uni_Directional_DL);
7554                }
7555                break;
7556             }
7557          case RLC_UM_UNI_DIRECTIONAL_DL :
7558             {
7559                if(lcCfg->choice.um_Uni_Directional_UL)
7560                {
7561                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
7562                   if(rlcDbCfg->u.umUniDirDlCfg)
7563                      extractRlcUmDlCfg(rlcDbCfg->u.umUniDirDlCfg, lcCfg->choice.um_Uni_Directional_UL);
7564                }
7565                break;
7566             }
7567          default:
7568             DU_LOG("\nERROR  -->  DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
7569             break;
7570       }
7571    }
7572 }
7573
7574 /*******************************************************************
7575  *
7576  * @brief Function to extract extractUlLcCfg
7577  *
7578  * @details
7579  *
7580  *    Function : extractUlLcCfg
7581  *
7582  *    Functionality: Function to extract extractUlLcCfg
7583  *
7584  * @params[in] UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg
7585  * @return void
7586  *
7587  * ****************************************************************/
7588
7589 void extractUlLcCfg(UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg)
7590 {
7591    if(ulLcCfg)
7592    {
7593       if(ulLcCfg->ul_SpecificParameters)
7594       {
7595          f1UlLcCfg->priority = \
7596             ulLcCfg->ul_SpecificParameters->priority;
7597       if(ulLcCfg->ul_SpecificParameters->logicalChannelGroup)
7598       {
7599          f1UlLcCfg->lcGroup = \
7600            *(ulLcCfg->ul_SpecificParameters->logicalChannelGroup);
7601       }
7602       if(ulLcCfg->ul_SpecificParameters->schedulingRequestID)
7603       {
7604          f1UlLcCfg->schReqId = \
7605            *(ulLcCfg->ul_SpecificParameters->schedulingRequestID);
7606       }
7607       f1UlLcCfg->pbr = \
7608          ulLcCfg->ul_SpecificParameters->prioritisedBitRate;
7609       f1UlLcCfg->bsd = \
7610          ulLcCfg->ul_SpecificParameters->bucketSizeDuration;
7611       }
7612    }
7613 }
7614
7615 /*******************************************************************
7616 *
7617 * @brief Function to extract Snssai Cfg Info from CU
7618 *
7619 * @details
7620 *
7621 *    Function : extractDrbSnssaiCfg
7622 *
7623 *    Functionality: Function to extract Drb Snssai Cfg Info from CU
7624 *
7625 * @params[in] DRB_Information_t *drbInfo, Snssai  *snssai
7626 * @return ROK/RFAILED
7627 *
7628 * ****************************************************************/
7629
7630 uint8_t extractDrbSnssaiCfg(SNSSAI_t *RecvSnssai, Snssai **snssaiToBeShared)
7631 {
7632    if(!(*snssaiToBeShared))
7633    {
7634       DU_ALLOC_SHRABL_BUF((*snssaiToBeShared), sizeof(Snssai));
7635       if(snssaiToBeShared == NULLP)
7636       {
7637          DU_LOG("\nERROR  -->  DUAPP : extractDrbSnssaiCfg(): Memory failed at allocating for SNSSAI ");
7638          return RFAILED;
7639       }
7640    }
7641    if(RecvSnssai)
7642    {
7643       memcpy(&(*snssaiToBeShared)->sst, RecvSnssai->sST.buf, RecvSnssai->sST.size);
7644       if(RecvSnssai->sD)
7645       {
7646          memcpy((*snssaiToBeShared)->sd, RecvSnssai->sD->buf,  RecvSnssai->sD->size);
7647       }
7648       else
7649       {
7650          DU_LOG("\nERROR  -->  DUAPP : extractDrbSnssaiCfg(): Received Null pointer of Snssai->SD");
7651          return RFAILED;
7652       }
7653    }
7654    return ROK;
7655 }
7656
7657 /*******************************************************************
7658  *
7659  * @brief Function to procRlcLcCfg
7660  *
7661  * @details
7662  *
7663  *    Function : procRlcLcCfg
7664  *
7665  *    Functionality: Function to procRlcLcCfg
7666  *
7667  * @params[in] rbId, lcId, rbType, rlcMod
7668  *             RLC_Config_t *, RlcBearerCfg * ,
7669  * @return void
7670  *
7671  * ****************************************************************/
7672
7673 void procRlcLcCfg(uint8_t rbId, uint8_t lcId, uint8_t rbType, uint8_t rlcMode,\
7674    uint8_t configType, RLC_Config_t *f1RlcCfg, RlcBearerCfg *lcCfg, QoSInformation_t *qoSInformation)
7675 {
7676    DRB_Information_t *drbInfo;
7677
7678    lcCfg->rbId   = rbId;
7679    lcCfg->configType = configType;
7680
7681    if(rbType == RB_TYPE_SRB)
7682    {
7683       lcCfg->rbType = RB_TYPE_SRB;
7684       lcCfg->lcId   = rbId;
7685       lcCfg->lcType = LCH_DCCH;
7686       lcCfg->rlcMode = RLC_AM;
7687    }
7688    else if(rbType == RB_TYPE_DRB)
7689    {
7690       lcCfg->rbType = RB_TYPE_DRB;
7691       lcCfg->lcId   = lcId;
7692       lcCfg->lcType = LCH_DTCH;
7693       lcCfg->rlcMode = rlcMode;
7694    }
7695    if(f1RlcCfg) /* rlc mode config recived */
7696    {
7697       extractRlcModeCfg(lcCfg->rlcMode, lcCfg, f1RlcCfg);
7698    }
7699    if(qoSInformation != NULLP)
7700    {
7701       if(qoSInformation->present == QoSInformation_PR_choice_extension)
7702       {
7703          if(qoSInformation->choice.choice_extension->value.present ==\
7704                QoSInformation_ExtIEs__value_PR_DRB_Information)
7705          {
7706             drbInfo = &qoSInformation->choice.choice_extension->value.choice.DRB_Information;
7707             if(extractDrbSnssaiCfg(&drbInfo->sNSSAI, &lcCfg->snssai) != ROK)
7708             {
7709                DU_LOG("\nERROR  -->  DUAPP: Unable to extract Snssai information at procRlcLcCfg()");
7710                return RFAILED;
7711             }
7712          }
7713       }
7714    }
7715 }
7716
7717 /*******************************************************************
7718  *
7719  * @brief Fills DrbQos Info received by CU
7720  *
7721  * @details
7722  *
7723  *    Function : extractQosInfo
7724  *
7725  *    Functionality: Fills DrbQos Info received  by CU
7726  *
7727  * @params[in] DrbQosInfo *qosToAdd,
7728  *             QoSFlowLevelQoSParameters_t *qosFlowCfg
7729  * @return void
7730  *
7731  * ****************************************************************/
7732
7733 void extractQosInfo(DrbQosInfo *qosToAdd, QoSFlowLevelQoSParameters_t *qosFlowCfg)
7734 {
7735    uint8_t qosCntIdx = 0;
7736    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
7737
7738    qosToAdd->fiveQiType = qosFlowCfg->qoS_Characteristics.present;
7739    qosToAdd->u.nonDyn5Qi.fiveQi     =\
7740                                      qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
7741    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow)
7742    {
7743       qosToAdd->u.nonDyn5Qi.avgWindow = \
7744                                         *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
7745    }
7746    qosToAdd->u.nonDyn5Qi.maxDataBurstVol = \
7747                                            *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
7748    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel)
7749    {
7750       qosToAdd->u.nonDyn5Qi.priorLevel = \
7751                                          *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel);
7752    }
7753    qosToAdd->ngRanRetPri.priorityLevel = \
7754                                          qosFlowCfg->nGRANallocationRetentionPriority.priorityLevel;
7755    qosToAdd->ngRanRetPri.preEmptionCap = \
7756                                          qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionCapability;
7757    qosToAdd->ngRanRetPri.preEmptionVul = \
7758                                          qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionVulnerability;
7759    if(qosFlowCfg->gBR_QoS_Flow_Information)
7760    {
7761       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateDl, \
7762             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.buf, \
7763             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.size);
7764       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateUl, \
7765             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.buf, \
7766             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.size);
7767       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateDl,\
7768             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.buf, \
7769             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.size);
7770       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateUl,\
7771             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.buf, \
7772             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.size);
7773    }
7774    /*Extracting PDU_SESSION_ID*/
7775    qosIeExt = (ProtocolExtensionContainer_4624P74_t *)qosFlowCfg->iE_Extensions;
7776    if(qosIeExt)
7777    {
7778       for(qosCntIdx = 0; qosCntIdx < qosIeExt->list.count; qosCntIdx++)
7779       {
7780          if(qosIeExt->list.array[qosCntIdx]->extensionValue.present == \
7781                QoSFlowLevelQoSParameters_ExtIEs__extensionValue_PR_PDUSessionID)
7782          {
7783             qosToAdd->pduSessionId = qosIeExt->list.array[qosCntIdx]->extensionValue.choice.PDUSessionID;
7784             DU_LOG("\nDEBUG -->  DU_F1AP : extractQosInfo: PDU SessionID:%d",qosToAdd->pduSessionId);
7785          }
7786       }
7787    }
7788    qosToAdd->ulPduSessAggMaxBitRate = 0;
7789 }
7790
7791 /*******************************************************************
7792  *
7793  * @brief Function to extract GTP Tunnel Info from CU
7794  *
7795  * @details
7796  *
7797  *    Function : extractUpTnlInfo
7798  *
7799  *    Functionality: Function to extract GTP Tunnel Info from CU
7800  *
7801  * @params[in] F1AP message
7802  * @return ROK/RFAILED
7803  *
7804  * ****************************************************************/
7805
7806 uint8_t extractUpTnlInfo(uint8_t drbId, uint8_t configType,\
7807    ULUPTNLInformation_ToBeSetup_List_t *tnlInfo, UpTnlCfg *upTnlInfo)
7808 {
7809    uint8_t tnlIdx;
7810    uint32_t ipv4_du = 0;
7811    GTPTunnel_t *gtpTunnel = NULLP;
7812
7813    upTnlInfo->drbId = drbId;
7814    upTnlInfo->configType = configType;
7815 #ifdef O1_ENABLE
7816    cmInetAddr((S8*)g_cfg.DU_IPV4_Addr, &ipv4_du);
7817 #else
7818    cmInetAddr((char *)DU_IP_V4_ADDR, &ipv4_du);
7819 #endif
7820
7821    for(tnlIdx=0; tnlIdx < tnlInfo->list.count; tnlIdx++)
7822    {
7823       if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
7824       {
7825          if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel)
7826          {
7827             gtpTunnel = tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel;
7828             DU_ALLOC(upTnlInfo->tnlCfg1, sizeof(GtpTnlCfg));
7829             if(upTnlInfo->tnlCfg1 == NULLP)
7830             {
7831                DU_LOG("\nERROR  -->  F1AP : extractUpTnlInfo: Failed to allocate mmeory for tunnel cfg 1");
7832                return RFAILED;
7833             }
7834             bitStringToInt(&gtpTunnel->transportLayerAddress, &upTnlInfo->tnlCfg1->ulTnlAddress);
7835             upTnlInfo->tnlCfg1->dlTnlAddress = ipv4_du;
7836             if(gtpTunnel->gTP_TEID.size > 0)
7837             {
7838                teIdStringToInt(gtpTunnel->gTP_TEID.buf, &upTnlInfo->tnlCfg1->teId);
7839             }
7840          }
7841          break;
7842       }
7843    }
7844    return ROK;
7845 }
7846
7847 /*******************************************************************
7848 *
7849 * @brief Function to extract Drb Qos Cfg Info from CU
7850 *
7851 * @details
7852 *
7853 *    Function : extractDrbQosCfg
7854 *
7855 *    Functionality: Function to extract Drb Qos Cfg Info from CU
7856 *
7857 * @params[in] DRB_Information_t *drbInfo, LcCfg *macLcToAdd
7858 * @return ROK/RFAILED
7859 *
7860 * ****************************************************************/
7861
7862 uint8_t extractDrbQosCfg(DRB_Information_t *drbInfo, LcCfg *macLcToAdd )
7863 {
7864    if(!macLcToAdd->drbQos)
7865    {
7866       DU_ALLOC_SHRABL_BUF(macLcToAdd->drbQos, sizeof(DrbQosInfo));
7867       if(macLcToAdd->drbQos == NULLP)
7868       {
7869          DU_LOG("\nERROR  -->  DUAPP:Memory failed at allocating DrbQos at extractDrbQosCfg()");
7870          return RFAILED;
7871       }
7872
7873    }
7874    if(drbInfo->dRB_QoS.qoS_Characteristics.present == QoS_Characteristics_PR_non_Dynamic_5QI)
7875    {
7876       extractQosInfo(macLcToAdd->drbQos, &drbInfo->dRB_QoS);
7877       macLcToAdd->dlLcCfg.lcp = macLcToAdd->drbQos->ngRanRetPri.priorityLevel;
7878    }
7879    if(extractDrbSnssaiCfg(&drbInfo->sNSSAI, &macLcToAdd->snssai) != ROK)
7880    {
7881       DU_LOG("\nERROR  -->  DUAPP: Unable to extract Snssai information  at extractDrbQosCfg()");
7882       return RFAILED;
7883    }
7884    return ROK;
7885 }
7886 /*******************************************************************
7887  *
7888  * @brief Function to extract DRB info received from CU
7889  *
7890  * @details
7891  *
7892  *    Function : extractDrbCfg
7893  *
7894  *    Functionality: Function to extract DRB info received from CU
7895  *
7896  * @params[in] F1AP message
7897  * @return void
7898  *
7899  * ****************************************************************/
7900 uint8_t extractDrbCfg(DRBs_ToBeSetup_Item_t *drbItem, DRBs_ToBeSetupMod_Item_t *drbSetupModItem,\
7901 DRBs_ToBeModified_Item_t *drbModItem,  LcCfg *macLcToAdd, UpTnlCfg *upTnlInfo)
7902 {
7903    DRB_Information_t *drbInfo = NULLP;
7904
7905    if(drbItem != NULLP)
7906    {
7907       if(extractUpTnlInfo(drbItem->dRBID, CONFIG_ADD, &drbItem->uLUPTNLInformation_ToBeSetup_List, upTnlInfo) != ROK)
7908       {
7909          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7910          return RFAILED;
7911       }
7912       if(drbItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7913       {
7914          if(drbItem->qoSInformation.choice.choice_extension->value.present == QoSInformation_ExtIEs__value_PR_DRB_Information)
7915          {
7916             drbInfo = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7917             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7918             {
7919                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7920                return RFAILED;
7921             }
7922          }
7923       }
7924    }
7925    else if(drbSetupModItem != NULLP)
7926    {
7927       if(extractUpTnlInfo(drbSetupModItem->dRBID, CONFIG_ADD, &drbSetupModItem->uLUPTNLInformation_ToBeSetup_List,\
7928       upTnlInfo) != ROK)
7929       {
7930          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7931          return RFAILED;
7932       }
7933       if(drbSetupModItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7934       {
7935          if(drbSetupModItem->qoSInformation.choice.choice_extension->value.present ==\
7936          QoSInformation_ExtIEs__value_PR_DRB_Information)
7937          {
7938             drbInfo = &drbSetupModItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7939             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7940             {
7941                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7942                return RFAILED;
7943             }
7944
7945          }
7946       }
7947    }
7948    else if(drbModItem != NULLP)
7949    {
7950       if(extractUpTnlInfo(drbModItem->dRBID, CONFIG_MOD, &drbModItem->uLUPTNLInformation_ToBeSetup_List,\
7951       upTnlInfo) != ROK)
7952       {
7953          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7954          return RFAILED;
7955       }
7956       if(drbModItem->qoSInformation != NULLP)
7957       {
7958          if(drbModItem->qoSInformation->present == QoSInformation_PR_choice_extension)
7959          {
7960             if(drbModItem->qoSInformation->choice.choice_extension->value.present ==\
7961                   QoSInformation_ExtIEs__value_PR_DRB_Information)
7962             {
7963                drbInfo = &drbModItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information;
7964                if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7965                {
7966                   DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7967                   return RFAILED;
7968                }
7969
7970             }
7971          }
7972       }
7973    }
7974    return ROK;
7975 }
7976
7977 /*******************************************************************
7978  *
7979  * @brief Function to extract RB info received from CU
7980  *
7981  * @details
7982  *
7983  *    Function : extractMacRbCfg
7984  *
7985  *    Functionality: Function to extract RB info received from CU
7986  *
7987  * @params[in] F1AP message
7988  * @return ROK/RFAILED
7989  *
7990  * ****************************************************************/
7991
7992 uint8_t extractMacRbCfg(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbCfg,\
7993 DRBs_ToBeSetupMod_Item_t *drbSetupModCfg,  DRBs_ToBeModified_Item_t *drbModCfg, LogicalChannelConfig_t *ulLcCfg, LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7994 {
7995    if(drbCfg != NULLP)
7996    {
7997       if(extractDrbCfg(drbCfg, NULL, NULL, lcCfg, upTnlInfo) != ROK)
7998       {
7999          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
8000          return RFAILED;
8001       }
8002    }
8003    else if(drbSetupModCfg != NULLP)
8004    {
8005       if(extractDrbCfg(NULL, drbSetupModCfg, NULL, lcCfg, upTnlInfo) != ROK)
8006       {
8007          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
8008          return RFAILED;
8009       }
8010    }
8011    else if(drbModCfg != NULLP)
8012    {
8013       if(extractDrbCfg(NULL, NULL, drbModCfg, lcCfg, upTnlInfo) != ROK)
8014       {
8015          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
8016          return RFAILED;
8017       }
8018    }
8019    else
8020    {
8021       lcCfg->drbQos = NULLP;
8022       lcCfg->snssai = NULLP;
8023       if(lcCfg->lcId == SRB2_LCID)
8024          lcCfg->dlLcCfg.lcp = LC_PRIORITY_3;
8025       else
8026          lcCfg->dlLcCfg.lcp = LC_PRIORITY_1;
8027    }
8028    if(ulLcCfg)
8029    {
8030       lcCfg->ulLcCfgPres = true;
8031       extractUlLcCfg(&lcCfg->ulLcCfg, ulLcCfg);
8032    }
8033    else
8034       lcCfg->ulLcCfgPres = false;
8035    return ROK;
8036 }
8037
8038 /*******************************************************************
8039  *
8040  * @brief Function processing LC config info received from CU
8041  *
8042  * @details
8043  *
8044  *    Function : procMacLcCfg
8045  *
8046  *    Functionality: Function processing LC config info received from CU
8047  *
8048  * @params[in] F1AP message
8049  * @return ROK/RFAILED
8050  *
8051  * ****************************************************************/
8052
8053 uint8_t procMacLcCfg(uint8_t lcId, uint8_t rbType, uint8_t configType, DRBs_ToBeSetup_Item_t *drbItem,\
8054 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, LogicalChannelConfig_t *ulLcCfg,\
8055 LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
8056 {
8057    uint8_t ret = ROK;
8058
8059    lcCfg->lcId = lcId;
8060    lcCfg->configType = configType;
8061    if(rbType == RB_TYPE_SRB)
8062    {
8063       ret = extractMacRbCfg(lcId, NULL, NULL, NULL, ulLcCfg, lcCfg, NULL);
8064    }
8065    else if(rbType == RB_TYPE_DRB)
8066    {
8067       if(drbItem != NULL)
8068         ret = extractMacRbCfg(lcId, drbItem, NULL, NULL, ulLcCfg, lcCfg, upTnlInfo);
8069       else if(drbSetupModItem != NULL)
8070         ret = extractMacRbCfg(lcId, NULL, drbSetupModItem, NULL, ulLcCfg, lcCfg, upTnlInfo);
8071       else if(drbModItem != NULL)
8072         ret = extractMacRbCfg(lcId, NULL, NULL, drbModItem, ulLcCfg, lcCfg, upTnlInfo);
8073    }
8074    return ret;
8075 }
8076
8077 /*******************************************************************
8078  *
8079  * @brief Function to extract Rlc cfg To Add/Mod in CellGrp Info
8080  *
8081  * @details
8082  *
8083  *    Function : extractRlcCfgToAddMod
8084  *
8085  *    Functionality: Function to extract Rlc cfg To Add/Mod in CellGrp Info
8086  *
8087  * @params[in] CellGroupConfigRrc__rlc_BearerTo pointer
8088  *             DuUeCfg Pointer
8089  * @return ROK/RFAILED
8090  *
8091  * ****************************************************************/
8092
8093 uint8_t extractRlcCfgToAddMod(struct CellGroupConfigRrc__rlc_BearerToAddModList *lcCfg, DuUeCfg *ueCfgDb)
8094 {
8095   uint8_t idx, rbId, lcId, rlcMode, rbType;
8096   RLC_Config_t *f1RlcCfg = NULLP;
8097   LogicalChannelConfig_t *macUlLcCfg = NULLP;
8098
8099   for(idx = 0; idx < lcCfg->list.count; idx++)
8100   {
8101      lcId = lcCfg->list.array[idx]->logicalChannelIdentity;
8102      if(lcCfg->list.array[idx]->servedRadioBearer)
8103      {
8104         /* RadioBearer for SRB/DRB */
8105         if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
8106         RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
8107         {
8108            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.srb_Identity;
8109            rbType = RB_TYPE_SRB;
8110         }
8111         else if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
8112         RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
8113         {
8114            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.drb_Identity;
8115            rbType = RB_TYPE_DRB;
8116         }
8117         else
8118         {
8119            DU_LOG("\nERROR  -->  No components present in Bearer config to ADD/MOD");
8120            return RFAILED;
8121         }
8122         /* MAC UL LC Config */
8123         if(lcCfg->list.array[idx]->mac_LogicalChannelConfig)
8124         {
8125            macUlLcCfg = lcCfg->list.array[idx]->mac_LogicalChannelConfig;
8126         }
8127      }
8128      else
8129      {
8130         DU_LOG("\nERROR  -->  DUAPP: Received RadioBearer config is NULL");
8131         return RFAILED;
8132      }
8133      /* RLC Mode Config */
8134      if(lcCfg->list.array[idx]->rlc_Config)
8135      {
8136         rlcMode  = lcCfg->list.array[idx]->rlc_Config->present;
8137         f1RlcCfg = lcCfg->list.array[idx]->rlc_Config;
8138      }
8139
8140      /* Filling RLC/MAC Config*/
8141      memset(&ueCfgDb->macLcCfg[idx], 0, sizeof(LcCfg));
8142      memset(&ueCfgDb->rlcLcCfg[idx], 0, sizeof(RlcBearerCfg));
8143      procRlcLcCfg(rbId, lcId, rbType, rlcMode, CONFIG_UNKNOWN, f1RlcCfg, &(ueCfgDb->rlcLcCfg[idx]), NULLP);
8144      if(procMacLcCfg(lcId, rbType, CONFIG_UNKNOWN, NULL, NULL, NULL, macUlLcCfg, &ueCfgDb->macLcCfg[idx], NULL) != ROK)
8145      {
8146         DU_LOG("\nERROR  -->  DU APP : Failed while filling MAC LC config at extractRlcCfgToAddMod()");
8147         return RFAILED;
8148      }
8149      (ueCfgDb->numRlcLcs)++;
8150      (ueCfgDb->numMacLcs)++;
8151          DU_LOG("\nDEBUG  -> DUAPP: extractRlcCfgToAddMod:RBType:%d, DrbID: %d,lcId:%d, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
8152                             rbType, rbId, lcId, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
8153   }
8154   //TODO: To send the failure cause in UeContextSetupRsp
8155   return ROK;
8156 }
8157
8158 /*******************************************************************
8159  *
8160  * @brief DeAlloc pdsch serv cell config info
8161  *
8162  * @details
8163  *
8164  *    Function : freeMacPdschServCellInfo
8165  *
8166  *    Functionality: DeAlloc pdsch serv cell config info
8167  *
8168  * @params[in] PdschServCellCfg pointer
8169  * @return void
8170  *
8171  * ****************************************************************/
8172
8173 void freeMacPdschServCellInfo(PdschServCellCfg *pdsch)
8174 {
8175    if(pdsch->xOverhead)
8176    {
8177       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->xOverhead, sizeof(PdschXOverhead));
8178    }
8179    if(pdsch->codeBlkGrpFlushInd)
8180    {
8181       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->codeBlkGrpFlushInd, sizeof(bool));
8182    }
8183    if(pdsch->maxCodeBlkGrpPerTb)
8184    {
8185       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
8186    }
8187    if(pdsch->maxMimoLayers)
8188    {
8189       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxMimoLayers, sizeof(uint8_t));
8190    }
8191 }
8192
8193 /*******************************************************************
8194  *
8195  * @brief Free Serving cell Info
8196  *
8197  * @details
8198  *
8199  *    Function : freeMacServingCellInfo
8200  *
8201  *    Functionality: Free Serving cell Info
8202  *
8203  * @params[in] ServCellCfgInfo *srvCellCfg
8204  * @return void
8205  *
8206  * ****************************************************************/
8207 void freeMacServingCellInfo(ServCellCfgInfo *srvCellCfg)
8208 {
8209    uint8_t timeDomRsrcIdx;
8210
8211    if(srvCellCfg->initDlBwp.pdschPresent)
8212    {
8213       for(timeDomRsrcIdx = 0; timeDomRsrcIdx < srvCellCfg->initDlBwp.pdschCfg.numTimeDomRsrcAlloc; timeDomRsrcIdx++)
8214       {
8215          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, \
8216             srvCellCfg->initDlBwp.pdschCfg.timeDomRsrcAllociList[timeDomRsrcIdx].k0, sizeof(uint8_t));
8217       }
8218    }
8219
8220    freeMacPdschServCellInfo(&srvCellCfg->pdschServCellCfg);
8221    if(srvCellCfg->bwpInactivityTmr)
8222    {
8223       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
8224    }
8225
8226    if(srvCellCfg->initUlBwp.pucchPresent)
8227    {
8228       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->initUlBwp.pucchCfg.dlDataToUlAck, sizeof(PucchDlDataToUlAck));
8229    }
8230 }
8231
8232 /*******************************************************************
8233  *
8234  * @brief Free cell Grp Cfg Info
8235  *
8236  * @details
8237  *
8238  *    Function : freeUeReCfgCellGrpInfo
8239  *
8240  *    Functionality: Free cell Grp Cfg Info
8241  *
8242  * @params[in] MacUeCfg*  duUeCfg
8243  * @return void
8244  *
8245  * ****************************************************************/
8246
8247 void freeUeReCfgCellGrpInfo(MacUeCfg *macUeCfg)
8248 {
8249    freeMacServingCellInfo(&macUeCfg->spCellCfg.servCellCfg);
8250 }
8251
8252 /*******************************************************************
8253  *
8254  * @brief Fills Reconfig SchReqReConfig
8255  *
8256  * @details
8257  *
8258  *    Function : extractSchReqReConfig
8259  *
8260  *    Functionality: Fills Reconfig SchReqReConfig
8261  *
8262  * @params[in] SchedulingRequestConfig_t *cuSchedReq
8263  *             SchedReqCfg*  macSchedReq
8264  * @return void
8265  *
8266  * ****************************************************************/
8267 void extractSchReqReConfig(SchedulingRequestConfig_t *cuSchedReq, SchedReqCfg *macSchedReq)
8268 {
8269    uint8_t schReqIdx = 0;
8270    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqListToAdd = NULLP;
8271    struct SchedulingRequestConfig__schedulingRequestToReleaseList *schReqListToRel = NULLP;
8272
8273    if(cuSchedReq->schedulingRequestToAddModList)
8274    {
8275       schReqListToAdd = cuSchedReq->schedulingRequestToAddModList;
8276       if(schReqListToAdd->list.count)
8277       {
8278          macSchedReq->addModListCount = schReqListToAdd->list.count;
8279          for(schReqIdx = 0; schReqIdx < schReqListToAdd->list.count; schReqIdx++)
8280          {
8281             macSchedReq->addModList[schReqIdx].schedReqId = \
8282                schReqListToAdd->list.array[schReqIdx]->schedulingRequestId;
8283             macSchedReq->addModList[schReqIdx].srProhibitTmr = \
8284                *(schReqListToAdd->list.array[schReqIdx]->sr_ProhibitTimer);
8285             macSchedReq->addModList[schReqIdx].srTransMax    =\
8286                schReqListToAdd->list.array[schReqIdx]->sr_TransMax;
8287          }
8288       }
8289    }
8290    /* Scheduling Req To release */
8291    if(cuSchedReq->schedulingRequestToReleaseList)
8292    {
8293       schReqListToRel = cuSchedReq->schedulingRequestToReleaseList;
8294       if(schReqListToRel->list.count)
8295       {
8296          macSchedReq->relListCount = schReqListToRel->list.count;
8297          for(schReqIdx = 0; schReqIdx < schReqListToRel->list.count; schReqIdx++)
8298          {
8299             macSchedReq->relList[schReqIdx] = \
8300                *schReqListToRel->list.array[schReqIdx];
8301          }
8302       }
8303    }
8304 }
8305
8306 /*******************************************************************
8307  *
8308  * @brief Fills TagReconfig
8309  *
8310  * @details
8311  *
8312  *    Function : extractTagReconfig
8313  *
8314  *    Functionality: Fills extractTagReconfig
8315  *
8316  * @params[in] TAG_Config_t *cuTagCfg
8317  *             TagCfg *macTagCfg
8318  * @return void
8319  *
8320  * ****************************************************************/
8321
8322 void extractTagReconfig(TAG_Config_t *cuTagCfg, TagCfg *macTagCfg)
8323 {
8324   uint8_t tagIdx = 0;
8325   struct TAG_Config__tag_ToAddModList  *tagListToAddMod = NULLP;
8326   struct TAG_Config__tag_ToReleaseList *tagListToRel = NULLP;
8327
8328   /* Tag config to AddMod */
8329   if(cuTagCfg->tag_ToAddModList)
8330   {
8331      tagListToAddMod = cuTagCfg->tag_ToAddModList;
8332      if(tagListToAddMod->list.count)
8333      {
8334         macTagCfg->addModListCount = tagListToAddMod->list.count;
8335         for(tagIdx = 0; tagIdx < tagListToAddMod->list.count; tagIdx++)
8336         {
8337            macTagCfg->addModList[tagIdx].tagId =\
8338               tagListToAddMod->list.array[tagIdx]->tag_Id;
8339            macTagCfg->addModList[tagIdx].timeAlignTimer = \
8340
8341               tagListToAddMod->list.array[tagIdx]->timeAlignmentTimer;
8342         }
8343      }
8344   }
8345   /* Tag config to release */
8346   if(cuTagCfg->tag_ToReleaseList)
8347   {
8348      tagListToRel = cuTagCfg->tag_ToReleaseList;
8349      if(tagListToRel->list.count)
8350      {
8351         macTagCfg->relListCount = tagListToRel->list.count;
8352         for(tagIdx = 0; tagIdx < tagListToRel->list.count; tagIdx++)
8353         {
8354            macTagCfg->relList[tagIdx] = *tagListToRel->list.array[tagIdx];
8355         }
8356      }
8357   }
8358 }
8359
8360 /*******************************************************************
8361  *
8362  * @brief Fills PdcchCfg received by CU
8363  *
8364  * @details
8365  *
8366  *    Function : extractPdcchCfg
8367  *
8368  *    Functionality: Fills PdcchCfg received  by CU
8369  *
8370  * @params[in] PDCCH_Config_t *cuPdcchCfg,
8371  *             PdcchConfig *duPdcchCfg
8372  * @return void
8373  *
8374  * ****************************************************************/
8375
8376 void extractPdcchCfg(PDCCH_Config_t *cuPdcchCfg, PdcchConfig *macPdcchCfg)
8377 {
8378    uint8_t cRsetIdx = 0;
8379    uint8_t srchSpcIdx = 0;
8380
8381    struct PDCCH_Config__controlResourceSetToAddModList *cRsetToAddModList = NULLP;
8382    struct PDCCH_Config__controlResourceSetToReleaseList *cRsetToRelList = NULLP;
8383    struct PDCCH_Config__searchSpacesToAddModList *srchSpcToAddModList = NULLP;
8384    struct PDCCH_Config__searchSpacesToReleaseList *srchSpcToRelList = NULLP;
8385
8386
8387    /* Control Resource Set To Add/Mod List */
8388    if(cuPdcchCfg->controlResourceSetToAddModList)
8389    {
8390       cRsetToAddModList = cuPdcchCfg->controlResourceSetToAddModList;
8391       if(cRsetToAddModList->list.count)
8392       {
8393          macPdcchCfg->numCRsetToAddMod = cRsetToAddModList->list.count;
8394          for(cRsetIdx = 0; cRsetIdx < cRsetToAddModList->list.count; cRsetIdx++)
8395          {
8396             macPdcchCfg->cRSetToAddModList[cRsetIdx].cRSetId = \
8397                cRsetToAddModList->list.array[cRsetIdx]->controlResourceSetId;
8398             //freqDomRsrcBitStringToInt(&cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources,\
8399                   macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc);
8400             memcpy(macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc, \
8401                cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources.buf,
8402                cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources.size);
8403
8404             macPdcchCfg->cRSetToAddModList[cRsetIdx].duration = \
8405                 cRsetToAddModList->list.array[cRsetIdx]->duration;
8406
8407             macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType = \
8408                cRsetToAddModList->list.array[cRsetIdx]->cce_REG_MappingType.present;
8409             if(macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType == CCE_REG_MAPPINGTYPE_PR_INTERLEAVED)
8410             {
8411                //TODO: handle the case for Interleaved
8412             }
8413             macPdcchCfg->cRSetToAddModList[cRsetIdx].precoderGranularity = \
8414                 cRsetToAddModList->list.array[cRsetIdx]->precoderGranularity;
8415             if(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID)
8416             {
8417                macPdcchCfg->cRSetToAddModList[cRsetIdx].dmrsScramblingId= \
8418                   *(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID);
8419             }
8420          }
8421       }
8422    }
8423    /* Control Resource Set To Release List */
8424    if(cuPdcchCfg->controlResourceSetToReleaseList)
8425    {
8426       cRsetToRelList = cuPdcchCfg->controlResourceSetToReleaseList;
8427       if(cRsetToRelList->list.count)
8428       {
8429          macPdcchCfg->numCRsetToRel = cRsetToRelList->list.count;
8430          for(cRsetIdx = 0; cRsetIdx < cRsetToRelList->list.count; cRsetIdx++)
8431          {
8432             macPdcchCfg->cRSetToRelList[cRsetIdx] = *(cRsetToRelList->list.array[cRsetIdx]);
8433          }
8434       }
8435    }
8436
8437    /* Search space To Add/Mod List */
8438    if(cuPdcchCfg->searchSpacesToAddModList)
8439    {
8440       srchSpcToAddModList = cuPdcchCfg->searchSpacesToAddModList;
8441       if(srchSpcToAddModList->list.count)
8442       {
8443          macPdcchCfg->numSearchSpcToAddMod = srchSpcToAddModList->list.count;
8444          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToAddModList->list.count; srchSpcIdx++)
8445          {
8446             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceId =\
8447                                                                           srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceId;
8448             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].cRSetId =\
8449                                                                     *(srchSpcToAddModList->list.array[srchSpcIdx]->controlResourceSetId);
8450             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset)
8451             {
8452                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset =\
8453                                                                                          srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset->present;
8454             }
8455             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot)
8456             {
8457                bitStringToInt(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot,\
8458                      macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSymbolsWithinSlot);
8459             }
8460             if(srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates)
8461             {
8462                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel1 = \
8463                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel1;
8464                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel2 = \
8465                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel2;
8466                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel4 = \
8467                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel4;
8468
8469                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel8 = \
8470                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel8;
8471
8472                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel16 = \
8473                                                                                         srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel16;
8474             }
8475             if(srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType)
8476             {
8477                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType =\
8478                                                                                srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->present;
8479                if(macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType == SEARCHSPACETYPE_PR_UE_SPECIFIC)
8480                {
8481                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].ueSpecificDciFormat =\
8482                                                                                       srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->choice.ue_Specific->dci_Formats;
8483                }
8484
8485             }
8486          }
8487       }
8488    }
8489    /* Search space To Rel List */
8490    if(cuPdcchCfg->searchSpacesToReleaseList)
8491    {
8492       srchSpcToRelList = cuPdcchCfg->searchSpacesToReleaseList;
8493       if(srchSpcToRelList->list.count)
8494       {
8495          macPdcchCfg->numSearchSpcToRel = srchSpcToRelList->list.count;
8496          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToRelList->list.count; srchSpcIdx++)
8497          {
8498             macPdcchCfg->searchSpcToRelList[srchSpcIdx] =\
8499                                                          *(srchSpcToRelList->list.array[srchSpcIdx]);
8500          }
8501       }
8502    }
8503 }
8504
8505 /*******************************************************************
8506  *
8507  * @brief Fills PdschCfg received by CU
8508  *
8509  * @details
8510  *
8511  *    Function : extractPdschCfg
8512  *
8513  *    Functionality: Fills PdschCfg received  by CU
8514  *
8515  * @params[in] PDSCH_Config_t *cuPdschCfg = Information which is send by CU,
8516  *                   which we have stored in F1UeContextSetupDb,
8517  *             PdschConfig *macPdschCfg = Used to Store the information which
8518  *                   needs to send in other layer, as well as this can be the variable
8519  *                   which stores the information in DuCb,
8520  *             PdschConfig *storedPdschCfg =  Null in case of sending the
8521  *                   information to other layer else it will have stored pdsch
8522  *                   configuration in copyOfmacUeCfg.
8523  * @return void
8524  *
8525  * ****************************************************************/
8526
8527 void extractPdschCfg(PDSCH_Config_t *cuPdschCfg, PdschConfig *macPdschCfg, PdschConfig *storedPdschCfg)
8528 {
8529    uint8_t timeDomIdx;
8530    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAlloc = NULLP;
8531
8532    if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
8533    {
8534       if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->present == \
8535             PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup)
8536       {
8537          if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup)
8538          {
8539             macPdschCfg->dmrsDlCfgForPdschMapTypeA.addPos = \
8540                *(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_AdditionalPosition);
8541          }
8542       }
8543    }
8544    macPdschCfg->resourceAllocType = cuPdschCfg->resourceAllocation;
8545    if(cuPdschCfg->pdsch_TimeDomainAllocationList)
8546    {
8547       timeDomAlloc = cuPdschCfg->pdsch_TimeDomainAllocationList;
8548       if(timeDomAlloc->present ==\
8549             PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup)
8550       {
8551          if(timeDomAlloc->choice.setup)
8552          {
8553             macPdschCfg->numTimeDomRsrcAlloc  = timeDomAlloc->choice.setup->list.count;
8554             for(timeDomIdx = 0; timeDomIdx < timeDomAlloc->choice.setup->list.count; timeDomIdx++)
8555             {
8556                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 = NULLP;
8557                if(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0)
8558                {
8559                   if(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 == NULL)
8560                   {
8561                      if(storedPdschCfg)
8562                      {
8563                         if(storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
8564                         {
8565                            macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 =\
8566                            storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0;
8567                         }
8568                         else
8569                         {
8570                            DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
8571                         }
8572                      }
8573                      else
8574                      {
8575                         DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
8576                      }
8577                      if(!macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
8578                      {
8579                         DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for k0 at extractPdschCfg()");
8580                         return RFAILED;
8581                      }
8582                   }
8583                   *(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0) = \
8584                   *(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0);
8585                }
8586                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
8587                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
8588                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
8589                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8590             }
8591          }
8592       }
8593    }
8594    macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
8595    if(cuPdschCfg->maxNrofCodeWordsScheduledByDCI)
8596       macPdschCfg->numCodeWordsSchByDci = *(cuPdschCfg->maxNrofCodeWordsScheduledByDCI);
8597    if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_staticBundling)
8598    {
8599       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
8600       if(cuPdschCfg->prb_BundlingType.choice.staticBundling)
8601       {
8602          if(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize)
8603          {
8604             macPdschCfg->bundlingInfo.StaticBundling.size = \
8605                *(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize);
8606          }
8607       }
8608    }
8609    else if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_dynamicBundling)
8610    {
8611       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
8612    }
8613
8614 }
8615
8616 /*******************************************************************
8617  *
8618  * @brief Fills PdschServingCellCfg received by CU
8619  *
8620  * @details
8621  *
8622  *    Function : extractPdschServingCellCfg
8623  *
8624  *    Functionality: Fills PdschCfg received  by CU
8625  *
8626  * @params[in] PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg,
8627  *             PdschServCellCfg *macUePdschSrvCellCfg
8628  * @return ROK/RFAILED
8629  *
8630  * ****************************************************************/
8631
8632 uint8_t extractPdschServingCellCfg(PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg, PdschServCellCfg *macUePdschSrvCellCfg)
8633 {
8634    if(cuPdschSrvCellCfg->codeBlockGroupTransmission)
8635    {
8636       if(cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup)
8637       {
8638          if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
8639          {
8640             *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
8641                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
8642          }
8643          else
8644          {
8645             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
8646             if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
8647             {
8648                *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
8649                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
8650             }
8651             else
8652             {
8653                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
8654                return RFAILED;
8655             }
8656          }
8657          if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
8658          {
8659             *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
8660                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
8661          }
8662          else
8663          {
8664             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->codeBlkGrpFlushInd , sizeof(bool));
8665             if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
8666             {
8667                *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
8668                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
8669             }
8670             else
8671             {
8672                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
8673                return RFAILED;
8674             }
8675          }
8676       }
8677    }
8678    if(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH)
8679    {
8680       macUePdschSrvCellCfg->numHarqProcForPdsch = *(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH);
8681    }
8682    if(cuPdschSrvCellCfg->ext1)
8683    {
8684       if(cuPdschSrvCellCfg->ext1->maxMIMO_Layers)
8685       {
8686         if(macUePdschSrvCellCfg->maxMimoLayers)
8687         {
8688            *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
8689         }
8690         else
8691         {
8692            DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxMimoLayers, sizeof(uint8_t));
8693            if(macUePdschSrvCellCfg->maxMimoLayers)
8694            {
8695               *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
8696            }
8697            else
8698            {
8699               DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
8700               return RFAILED;
8701            }
8702         }
8703       }
8704    }
8705    if(cuPdschSrvCellCfg->xOverhead)
8706    {
8707       if(macUePdschSrvCellCfg->xOverhead)
8708       {
8709          *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
8710       }
8711       else
8712       {
8713          DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->xOverhead, sizeof(PdschXOverhead));
8714          if(macUePdschSrvCellCfg->xOverhead)
8715          {
8716             *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
8717          }
8718          else
8719          {
8720             DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
8721             return RFAILED;
8722          }
8723       }
8724    }
8725    return ROK;
8726 }
8727
8728 /*******************************************************************
8729  *
8730  * @brief Fills PuschCfg received by CU
8731  *
8732  * @details
8733  *
8734  *    Function : extractPuschCfg
8735  *
8736  *    Functionality: Fills PuschCfg received  by CU
8737  *
8738  * @params[in] BWP_UplinkDedicated__pusch_Config *cuPuschCfg,
8739  *             PuschCfg *macPuschCfg
8740  * @return void
8741  *
8742  * ****************************************************************/
8743
8744 void extractPuschCfg(struct BWP_UplinkDedicated__pusch_Config *cuPuschCfg, PuschCfg *macPuschCfg)
8745 {
8746    uint8_t timeDomIdx = 0;
8747    DMRS_UplinkConfig_t *dmrsUlCfg = NULLP;
8748    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList = NULLP;
8749
8750    if(cuPuschCfg->present == BWP_UplinkDedicated__pusch_Config_PR_setup)
8751    {
8752       if(cuPuschCfg->choice.setup)
8753       {
8754          if(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH)
8755          {
8756              macPuschCfg->dataScramblingId = \
8757                 *(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH);
8758          }
8759          if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA)
8760          {
8761             if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->present == PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup)
8762             {
8763                if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup)
8764                {
8765                   dmrsUlCfg = (cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup);
8766                   if(dmrsUlCfg->dmrs_AdditionalPosition)
8767                   {
8768                      macPuschCfg->dmrsUlCfgForPuschMapTypeA.addPos =\
8769                         *(dmrsUlCfg->dmrs_AdditionalPosition);
8770                   }
8771                   if(dmrsUlCfg->transformPrecodingDisabled)
8772                   {
8773                      if(dmrsUlCfg->transformPrecodingDisabled->scramblingID0)
8774                      {
8775                         macPuschCfg->dmrsUlCfgForPuschMapTypeA.transPrecodDisabled.scramblingId0 = \
8776                            *(dmrsUlCfg->transformPrecodingDisabled->scramblingID0);
8777                      }
8778                   }
8779                }
8780             }
8781          }
8782          /*Res Alloc Type for UL */
8783          if(cuPuschCfg->choice.setup->resourceAllocation)
8784          {
8785             macPuschCfg->resourceAllocType = \
8786                cuPuschCfg->choice.setup->resourceAllocation;
8787          }
8788          if(cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList)
8789          {
8790             timeDomAllocList = cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList;
8791             if(timeDomAllocList->present == PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup)
8792             {
8793                if(timeDomAllocList->choice.setup)
8794                {
8795                   macPuschCfg->numTimeDomRsrcAlloc = timeDomAllocList->choice.setup->list.count;
8796                   for(timeDomIdx = 0; timeDomIdx <timeDomAllocList->choice.setup->list.count; timeDomIdx++)
8797                   {
8798                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].k2 = \
8799                         *(timeDomAllocList->choice.setup->list.array[timeDomIdx]->k2);
8800                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].mappingType = \
8801                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->mappingType;
8802                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbolAndLength = \
8803                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8804                   }
8805                }
8806             }
8807          }
8808          if(cuPuschCfg->choice.setup->transformPrecoder)
8809             macPuschCfg->transformPrecoder = *(cuPuschCfg->choice.setup->transformPrecoder);
8810       }
8811    }
8812 }
8813
8814 /*******************************************************************
8815  *
8816  * @brief Function to fill pucch Power Control
8817  *
8818  * @details
8819  *
8820  *    Function : extractPucchPowerControl
8821  *
8822  *    Functionality: Function to fill pucch Power Control
8823  *
8824  * @params[in] PucchPowerControl *pwrCtrl,
8825  *             struct PUCCH_PowerControl *cuPwrCtrlCfg
8826  * @return void
8827  *
8828  * ****************************************************************/
8829
8830 void extractPucchPowerControl(PucchPowerControl *pwrCtrl, struct PUCCH_PowerControl *cuPwrCtrlCfg)
8831 {
8832    uint8_t arrIdx;
8833
8834    if(cuPwrCtrlCfg->deltaF_PUCCH_f0)
8835       pwrCtrl->deltaF_Format0 = *cuPwrCtrlCfg->deltaF_PUCCH_f0;
8836    if(cuPwrCtrlCfg->deltaF_PUCCH_f1)
8837       pwrCtrl->deltaF_Format1 = *cuPwrCtrlCfg->deltaF_PUCCH_f1;
8838    if(cuPwrCtrlCfg->deltaF_PUCCH_f2)
8839       pwrCtrl->deltaF_Format2 = *cuPwrCtrlCfg->deltaF_PUCCH_f2;
8840    if(cuPwrCtrlCfg->deltaF_PUCCH_f3)
8841       pwrCtrl->deltaF_Format3 = *cuPwrCtrlCfg->deltaF_PUCCH_f3;
8842    if(cuPwrCtrlCfg->deltaF_PUCCH_f4)
8843       pwrCtrl->deltaF_Format4 = *cuPwrCtrlCfg->deltaF_PUCCH_f4;
8844    if(cuPwrCtrlCfg->p0_Set)
8845    {
8846       pwrCtrl->p0SetCount = cuPwrCtrlCfg->p0_Set->list.count;
8847       for(arrIdx=0; arrIdx < pwrCtrl->p0SetCount; arrIdx++)
8848       {
8849          pwrCtrl->p0Set[arrIdx].p0PucchId =\
8850             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Id;
8851          pwrCtrl->p0Set[arrIdx].p0PucchVal =\
8852             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Value;
8853       }
8854    }
8855    if(cuPwrCtrlCfg->pathlossReferenceRSs)
8856    {
8857       pwrCtrl->pathLossRefRSListCount = cuPwrCtrlCfg->pathlossReferenceRSs->list.count;
8858       for(arrIdx = 0; arrIdx < pwrCtrl->pathLossRefRSListCount; arrIdx++)
8859       {
8860          pwrCtrl->pathLossRefRSList[arrIdx].pathLossRefRSId =\
8861             cuPwrCtrlCfg->pathlossReferenceRSs->list.array[arrIdx]->pucch_PathlossReferenceRS_Id;
8862       }
8863    }
8864 }
8865
8866  /*******************************************************************
8867  *
8868  * @brief Function to extractResrcSetToAddModList sent by CU
8869  *
8870  * @details
8871  *
8872  *    Function : extractResrcSetToAddModList
8873  *
8874  *    Functionality: Fucntion to extractResrcSetToAddModList
8875  *
8876  * @params[in] PucchResrcSetCfg pointer,
8877  *             struct PUCCH_Config__resourceSetToAddModList pointer
8878  * @return void
8879  *
8880  * ****************************************************************/
8881
8882 void extractResrcSetToAddModList(PucchResrcSetCfg *macRsrcSetList, struct PUCCH_Config__resourceSetToAddModList *cuRsrcSetList)
8883 {
8884    uint8_t arrIdx, rsrcListIdx;
8885
8886    macRsrcSetList->resrcSetToAddModListCount = cuRsrcSetList->list.count;
8887    for(arrIdx = 0; arrIdx < macRsrcSetList->resrcSetToAddModListCount; arrIdx++)
8888    {
8889       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcSetId     =\
8890          cuRsrcSetList->list.array[arrIdx]->pucch_ResourceSetId;
8891       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount =\
8892          cuRsrcSetList->list.array[arrIdx]->resourceList.list.count;
8893       for(rsrcListIdx = 0; rsrcListIdx < macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount; rsrcListIdx++)
8894       {
8895          macRsrcSetList->resrcSetToAddModList[arrIdx].resrcList[rsrcListIdx] =\
8896             *cuRsrcSetList->list.array[arrIdx]->resourceList.list.array[rsrcListIdx];
8897       }
8898
8899       if(cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1)
8900       {
8901          macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize =\
8902             *cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1;
8903       }
8904       else
8905       {
8906          macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize = 0;
8907       }
8908    }
8909 }/* End of extractResrcSetToAddModList */
8910
8911 /*******************************************************************
8912  *
8913  * @brief Fills extractResrcToAddModList sent by CU
8914  *
8915  * @details
8916  *
8917  *    Function : extractResrcToAddModList
8918  *
8919  *    Functionality: Fills extractResrcToAddModList
8920  *
8921  * @params[in] PucchResrcCfg pointer,
8922  *             struct PUCCH_Config__resourceToAddModList pointer
8923  * @return ROk/RFAILED
8924  *
8925  * ****************************************************************/
8926
8927 uint8_t extractResrcToAddModList(PucchResrcCfg *macResrcList, struct PUCCH_Config__resourceToAddModList *cuResrcList)
8928 {
8929    uint8_t arrIdx;
8930
8931    macResrcList->resrcToAddModListCount = cuResrcList->list.count;
8932    for(arrIdx = 0; arrIdx < macResrcList->resrcToAddModListCount; arrIdx++)
8933    {
8934       macResrcList->resrcToAddModList[arrIdx].resrcId      =\
8935         cuResrcList->list.array[arrIdx]->pucch_ResourceId;
8936       macResrcList->resrcToAddModList[arrIdx].startPrb     =\
8937         cuResrcList->list.array[arrIdx]->startingPRB;
8938       if(cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping)
8939       {
8940          macResrcList->resrcToAddModList[arrIdx].intraFreqHop =\
8941            *cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping;
8942       }
8943       if(cuResrcList->list.array[arrIdx]->secondHopPRB)
8944       {
8945          macResrcList->resrcToAddModList[arrIdx].secondPrbHop =\
8946            *cuResrcList->list.array[arrIdx]->secondHopPRB;
8947       }
8948       /* PUCCH RSRC FORMAT */
8949       if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format0)
8950       {
8951          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_0;
8952          if(cuResrcList->list.array[arrIdx]->format.choice.format0)
8953          {
8954             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0, sizeof(PucchFormat0));
8955             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0 == NULLP)
8956             {
8957                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
8958                return RFAILED;
8959             }
8960             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->initialCyclicShift =\
8961                cuResrcList->list.array[arrIdx]->format.choice.format0->initialCyclicShift;
8962             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->numSymbols =\
8963                cuResrcList->list.array[arrIdx]->format.choice.format0->nrofSymbols;
8964             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->startSymbolIdx =\
8965                cuResrcList->list.array[arrIdx]->format.choice.format0->startingSymbolIndex;
8966          }
8967       }
8968       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format1)
8969       {
8970          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_1;
8971          if(cuResrcList->list.array[arrIdx]->format.choice.format1)
8972          {
8973             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1, sizeof(PucchFormat1));
8974             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1 == NULLP)
8975             {
8976                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
8977                return RFAILED;
8978             }
8979             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->initialCyclicShift =\
8980                 cuResrcList->list.array[arrIdx]->format.choice.format1->initialCyclicShift;
8981             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->numSymbols =\
8982                 cuResrcList->list.array[arrIdx]->format.choice.format1->nrofSymbols;
8983             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->startSymbolIdx =\
8984                 cuResrcList->list.array[arrIdx]->format.choice.format1->startingSymbolIndex;
8985             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->timeDomOCC =\
8986                 cuResrcList->list.array[arrIdx]->format.choice.format1->timeDomainOCC;
8987          }
8988       }
8989       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format2)
8990       {
8991          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_2;
8992          if(cuResrcList->list.array[arrIdx]->format.choice.format2)
8993          {
8994             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
8995             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2 == NULLP)
8996             {
8997                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
8998                return RFAILED;
8999             }
9000             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numPrbs =\
9001                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofPRBs;
9002             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numSymbols =\
9003                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofSymbols;
9004             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->startSymbolIdx =\
9005                 cuResrcList->list.array[arrIdx]->format.choice.format2->startingSymbolIndex;
9006          }
9007       }
9008       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format3)
9009       {
9010          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_3;
9011          if(cuResrcList->list.array[arrIdx]->format.choice.format3)
9012          {
9013             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
9014             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3 == NULLP)
9015             {
9016                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
9017                return RFAILED;
9018             }
9019             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numPrbs =\
9020                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofPRBs;
9021             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numSymbols =\
9022                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofSymbols;
9023             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->startSymbolIdx =\
9024                 cuResrcList->list.array[arrIdx]->format.choice.format3->startingSymbolIndex;
9025          }
9026       }
9027       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format4)
9028       {
9029          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_4;
9030          if(cuResrcList->list.array[arrIdx]->format.choice.format4)
9031          {
9032             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4, sizeof(PucchFormat4));
9033             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4 == NULLP)
9034             {
9035                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
9036                return RFAILED;
9037             }
9038             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->numSymbols =\
9039                 cuResrcList->list.array[arrIdx]->format.choice.format4->nrofSymbols;
9040             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occLen =\
9041                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Length;
9042             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occIdx =\
9043                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Index;
9044             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->startSymbolIdx =\
9045                 cuResrcList->list.array[arrIdx]->format.choice.format4->startingSymbolIndex;
9046          }
9047       }
9048    }
9049    return ROK;
9050
9051 }/* End of extractResrcToAddModList */
9052
9053 /*******************************************************************
9054  *
9055  * @brief Fills fillPucchSchedReqPeriodAndOffset sent by CU
9056  *
9057  * @details
9058  *
9059  *    Function : fillPucchSchedReqPeriodAndOffset
9060  *
9061  *    Functionality: To fillPucchSchedReqPeriodAndOffset
9062  *
9063  * @params[in] macPeriodicty,
9064  *     SchedulingRequestResourceConfig__periodicityAndOffset pointer
9065  * @return void
9066  *
9067  * ****************************************************************/
9068
9069 void fillPucchSchedReqPeriodAndOffset(uint8_t macPeriodicty, uint16_t  macOffset,\
9070    struct SchedulingRequestResourceConfig__periodicityAndOffset *cuPeriodicty)
9071 {
9072    macPeriodicty = cuPeriodicty->present;
9073    switch(macPeriodicty)
9074    {
9075       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
9076          {
9077             macOffset     = cuPeriodicty->choice.sym2;
9078             break;
9079          }
9080       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
9081          {
9082             macOffset     = cuPeriodicty->choice.sym6or7;
9083             break;
9084          }
9085       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
9086          {
9087             macOffset     = cuPeriodicty->choice.sl1;
9088             break;
9089          }
9090       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
9091          {
9092             macOffset = cuPeriodicty->choice.sl2;
9093             break;
9094          }
9095       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
9096          {
9097             macOffset = cuPeriodicty->choice.sl4;
9098             break;
9099          }
9100       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
9101          {
9102             macOffset = cuPeriodicty->choice.sl5;
9103             break;
9104          }
9105       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
9106          {
9107             macOffset = cuPeriodicty->choice.sl8;
9108             break;
9109          }
9110       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
9111          {
9112             macOffset = cuPeriodicty->choice.sl10;
9113             break;
9114          }
9115       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
9116          {
9117             macOffset = cuPeriodicty->choice.sl16;
9118             break;
9119          }
9120       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
9121          {
9122             macOffset = cuPeriodicty->choice.sl20;
9123             break;
9124          }
9125       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
9126          {
9127             macOffset = cuPeriodicty->choice.sl40;
9128             break;
9129          }
9130       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
9131          {
9132             macOffset = cuPeriodicty->choice.sl80;
9133             break;
9134          }
9135       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
9136          {
9137             macOffset = cuPeriodicty->choice.sl160;
9138             break;
9139          }
9140       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
9141          {
9142             macOffset = cuPeriodicty->choice.sl320;
9143             break;
9144          }
9145       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
9146          {
9147             macOffset = cuPeriodicty->choice.sl640;
9148             break;
9149          }
9150       default :
9151          DU_LOG("\nERROR  -->  F1AP : Invalid periodicity %d", macPeriodicty);
9152    }
9153 }
9154
9155 /*******************************************************************
9156  *
9157  * @brief Function to extractPucchFormatCfg sent by CU
9158  *
9159  * @details
9160  *
9161  *    Function : extractPucchFormatCfg
9162  *
9163  *    Functionality: Function to extractPucchFormatCfg
9164  *
9165  * @params[in] PucchFormatCfg pointer,
9166  *             PUCCH_FormatConfig_t pointer
9167  * @return void
9168  *
9169  * ****************************************************************/
9170
9171 void extractPucchFormatCfg(PucchFormatCfg *macFormatCfg, PUCCH_FormatConfig_t *cuFormatCfg)
9172  {
9173     if(cuFormatCfg->interslotFrequencyHopping)
9174        macFormatCfg->interSlotFreqHop = *cuFormatCfg->interslotFrequencyHopping;
9175     if(cuFormatCfg->additionalDMRS)
9176        macFormatCfg->addDmrs = *cuFormatCfg->additionalDMRS;
9177     if(cuFormatCfg->maxCodeRate)
9178        macFormatCfg->maxCodeRate = *cuFormatCfg->maxCodeRate;
9179     if(cuFormatCfg->nrofSlots)
9180        macFormatCfg->numSlots = *cuFormatCfg->nrofSlots;
9181     if(cuFormatCfg->pi2BPSK)
9182        macFormatCfg->pi2BPSK = *cuFormatCfg->pi2BPSK;
9183     if(cuFormatCfg->simultaneousHARQ_ACK_CSI)
9184        macFormatCfg->harqAckCSI = *cuFormatCfg->simultaneousHARQ_ACK_CSI;
9185  }/* End of extractPucchFormatCfg */
9186
9187 /*******************************************************************
9188  *
9189  * @brief Function to extractSchedReqCfgToAddMod sent by CU
9190  *
9191  * @details
9192  *
9193  *    Function : extractSchedReqCfgToAddMod
9194  *
9195  *    Functionality: Function to extractSchedReqCfgToAddMod
9196  *
9197  * @params[in] PucchSchedReqCfg pointer,
9198  *      PUCCH_Config__schedulingRequestResourceToAddModList pointer
9199  * @return void
9200  *
9201  * ****************************************************************/
9202
9203 void extractSchedReqCfgToAddMod(PucchSchedReqCfg *macSchedReqCfg, struct PUCCH_Config__schedulingRequestResourceToAddModList *cuSchedReqList)
9204 {
9205    uint8_t arrIdx;
9206
9207    macSchedReqCfg->schedAddModListCount = cuSchedReqList->list.count;
9208    for(arrIdx = 0; arrIdx <  macSchedReqCfg->schedAddModListCount; arrIdx++)
9209    {
9210       macSchedReqCfg->schedAddModList[arrIdx].resrcId =\
9211          cuSchedReqList->list.array[arrIdx]->schedulingRequestResourceId;
9212       macSchedReqCfg->schedAddModList[arrIdx].requestId =\
9213          cuSchedReqList->list.array[arrIdx]->schedulingRequestID;
9214       if(cuSchedReqList->list.array[arrIdx]->periodicityAndOffset)
9215       {
9216          fillPucchSchedReqPeriodAndOffset(macSchedReqCfg->schedAddModList[arrIdx].periodicity,\
9217             macSchedReqCfg->schedAddModList[arrIdx].offset, cuSchedReqList->list.array[arrIdx]->periodicityAndOffset);
9218       }
9219       if(cuSchedReqList->list.array[arrIdx]->resource)
9220       {
9221          macSchedReqCfg->schedAddModList[arrIdx].resrc =\
9222             *cuSchedReqList->list.array[arrIdx]->resource;
9223       }
9224    }
9225
9226 }/* End of extractSchedReqCfgToAddMod */
9227
9228  /*******************************************************************
9229  *
9230  * @brief Fills PucchCfg received by CU
9231  *
9232  * @details
9233  *
9234  *    Function : extractPucchCfg
9235  *
9236  *    Functionality: Fills PucchCfg received  by CU
9237  *
9238  * @params[in] BWP_UplinkDedicated__pucch_Config *cuPucchCfg = Information which
9239  *                is send by CU, which we have stored in F1UeContextSetupDb,
9240  *             PucchCfg *macPucchCfg = Used to Store the information which
9241  *                needs to send in other layer, as well as this can be the variable
9242  *                which stores the information in DuCb,
9243  *             PucchCfg *storedPucchCfg = Null in case of sending the
9244  *                information to other layer else it will have Pucch Cfg which
9245  *                we have stored in copyOfmacUeCfg.
9246  * @return ROK/RFAILED
9247  *
9248  * ****************************************************************/
9249
9250 uint8_t extractPucchCfg(struct BWP_UplinkDedicated__pucch_Config *cuPucchCfg, PucchCfg *macPucchCfg,\
9251 PucchCfg *storedPucchCfg)
9252 {
9253    uint8_t arrIdx;
9254
9255    if(cuPucchCfg->present == BWP_UplinkDedicated__pucch_Config_PR_setup)
9256    {
9257       if(cuPucchCfg->choice.setup)
9258       {
9259          /* Resource Set Cfg */
9260          if(cuPucchCfg->choice.setup->resourceSetToAddModList)
9261          {
9262             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrcSet, sizeof(PucchResrcSetCfg));
9263             if(macPucchCfg->resrcSet == NULLP)
9264             {
9265                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
9266                return RFAILED;
9267             }
9268             memset(macPucchCfg->resrcSet, 0, sizeof(PucchResrcSetCfg));
9269             extractResrcSetToAddModList(macPucchCfg->resrcSet, cuPucchCfg->choice.setup->resourceSetToAddModList);
9270          }
9271
9272          /* Resource Cfg */
9273          if(cuPucchCfg->choice.setup->resourceToAddModList)
9274          {
9275             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrc, sizeof(PucchResrcCfg));
9276             if(macPucchCfg->resrc == NULLP)
9277             {
9278                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
9279                return RFAILED;
9280             }
9281             memset(macPucchCfg->resrc, 0, sizeof(PucchResrcCfg));
9282             extractResrcToAddModList(macPucchCfg->resrc, cuPucchCfg->choice.setup->resourceToAddModList);
9283          }
9284
9285          /* Format 1 Cfg */
9286          if(cuPucchCfg->choice.setup->format1)
9287          {
9288             DU_ALLOC_SHRABL_BUF(macPucchCfg->format1, sizeof(PucchFormatCfg));
9289             if(macPucchCfg->format1 == NULLP)
9290             {
9291                DU_LOG("\nERROR --> F1AP : Failed to extract format 1 Cfg in  extractPucchCfg()");
9292                return RFAILED;
9293             }
9294             memset(macPucchCfg->format1, 0, sizeof(PucchFormatCfg));
9295             extractPucchFormatCfg(macPucchCfg->format1,\
9296                cuPucchCfg->choice.setup->format1->choice.setup);
9297          }
9298
9299          /* Format 2 Cfg */
9300          if(cuPucchCfg->choice.setup->format2)
9301          {
9302             DU_ALLOC_SHRABL_BUF(macPucchCfg->format2, sizeof(PucchFormatCfg));
9303             if(macPucchCfg->format2 == NULLP)
9304             {
9305                DU_LOG("\nERROR --> F1AP : Failed to extract format 2 Cfg in  extractPucchCfg()");
9306                return RFAILED;
9307             }
9308             memset(macPucchCfg->format2, 0, sizeof(PucchFormatCfg));
9309             extractPucchFormatCfg(macPucchCfg->format2,\
9310                cuPucchCfg->choice.setup->format2->choice.setup);
9311          }
9312
9313          /* Format 3 Cfg */
9314          if(cuPucchCfg->choice.setup->format3)
9315          {
9316             DU_ALLOC_SHRABL_BUF(macPucchCfg->format3, sizeof(PucchFormatCfg));
9317             if(macPucchCfg->format3 == NULLP)
9318             {
9319                DU_LOG("\nERROR --> F1AP : Failed to extract format 3 Cfg in  extractPucchCfg()");
9320                return RFAILED;
9321             }
9322             memset(macPucchCfg->format3, 0, sizeof(PucchFormatCfg));
9323             extractPucchFormatCfg(macPucchCfg->format3,\
9324                cuPucchCfg->choice.setup->format3->choice.setup);
9325          }
9326
9327          /* Format 4 Cfg */
9328          if(cuPucchCfg->choice.setup->format4)
9329          {
9330             DU_ALLOC_SHRABL_BUF(macPucchCfg->format4, sizeof(PucchFormatCfg));
9331             if(macPucchCfg->format4 == NULLP)
9332             {
9333                DU_LOG("\nERROR --> F1AP : Failed to extract format 4 Cfg in  extractPucchCfg()");
9334                return RFAILED;
9335             }
9336             memset(macPucchCfg->format4, 0, sizeof(PucchFormatCfg));
9337             extractPucchFormatCfg(macPucchCfg->format4,\
9338                cuPucchCfg->choice.setup->format4->choice.setup);
9339          }
9340
9341          /* Sched Req List */
9342          if(cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList)
9343          {
9344             DU_ALLOC_SHRABL_BUF(macPucchCfg->schedReq, sizeof(PucchSchedReqCfg));
9345             if(macPucchCfg->schedReq == NULLP)
9346             {
9347                DU_LOG("\nERROR --> F1AP : Failed to extract schedReqCfg in  extractPucchCfg()");
9348                return RFAILED;
9349             }
9350             memset(macPucchCfg->schedReq, 0, sizeof(PucchSchedReqCfg));
9351             extractSchedReqCfgToAddMod(macPucchCfg->schedReq,\
9352             cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList);
9353          }
9354
9355          /*TODO: Add support for  Spatial Info */
9356
9357          /* MultiCsiCfg */
9358          if(cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList)
9359          {
9360             DU_ALLOC_SHRABL_BUF(macPucchCfg->multiCsiCfg, sizeof(PucchMultiCsiCfg));
9361             if(macPucchCfg->multiCsiCfg == NULLP)
9362             {
9363                DU_LOG("\nERROR --> F1AP : Failed to extract multiCsiCfg in  extractPucchCfg()");
9364                return RFAILED;
9365             }
9366             memset(macPucchCfg->multiCsiCfg, 0, sizeof(PucchMultiCsiCfg));
9367             macPucchCfg->multiCsiCfg->multiCsiResrcListCount = cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.count;
9368             for(arrIdx =0; arrIdx < macPucchCfg->multiCsiCfg->multiCsiResrcListCount; arrIdx++)
9369             {
9370                macPucchCfg->multiCsiCfg->multiCsiResrcList[arrIdx] =\
9371                  *cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.array[arrIdx];
9372             }
9373          }
9374
9375          /* Dl_DataToUL_ACK */
9376          if(cuPucchCfg->choice.setup->dl_DataToUL_ACK)
9377     {
9378        if(storedPucchCfg)
9379        {
9380           if(storedPucchCfg->dlDataToUlAck)
9381           {
9382              macPucchCfg->dlDataToUlAck = storedPucchCfg->dlDataToUlAck;
9383           }
9384           else
9385           {
9386             DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
9387           }
9388        }
9389        else
9390        {
9391           DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
9392        }
9393        if(macPucchCfg->dlDataToUlAck == NULLP)
9394        {
9395           DU_LOG("\nERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
9396           return RFAILED;
9397        }
9398        memset(macPucchCfg->dlDataToUlAck, 0, sizeof(PucchDlDataToUlAck));
9399        macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount = cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.count;
9400        for(arrIdx = 0; arrIdx < macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount; arrIdx++)
9401        {
9402           macPucchCfg->dlDataToUlAck->dlDataToUlAckList[arrIdx] =\
9403           *cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.array[arrIdx];
9404        }
9405          }
9406
9407          /* Power Control */
9408          if(cuPucchCfg->choice.setup->pucch_PowerControl)
9409          {
9410             DU_ALLOC_SHRABL_BUF(macPucchCfg->powerControl, sizeof(PucchPowerControl));
9411             if(macPucchCfg->powerControl == NULLP)
9412             {
9413                DU_LOG("\nERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
9414                return RFAILED;
9415             }
9416             extractPucchPowerControl(macPucchCfg->powerControl,\
9417                cuPucchCfg->choice.setup->pucch_PowerControl);
9418          }
9419       }
9420    }
9421    return ROK;
9422 }
9423
9424 /*******************************************************************
9425  *
9426  * @brief Fills ServingCellReconfig received by CU
9427  *
9428  * @details
9429  *
9430  *    Function : extractSpCellDedicatedCfg
9431  *
9432  *    Functionality: Fills ServingCellReconfig received  by CU
9433  *
9434  * @params[in] ServingCellConfig_t *cuSrvCellCfg = Information which is send by
9435  *                  CU, which we have stored in F1UeContextSetupDb,
9436  *             ServCellCfgInfo *macSrvCellCfg = Used to Store the information
9437  *                  which  needs to send in other layer, as well as this can be the
9438  *                  variable which stores the information in DuCb,
9439  *             ServCellCfgInfo *storedSrvCellCfg = Null in case of sending the
9440  *                  information to other layer else it will have ServCellCfgInfo which
9441  *                  we have stored in copyOfmacUeCfg.
9442  * @return ROK/RFAILD
9443  *
9444  * ****************************************************************/
9445 uint8_t extractSpCellDedicatedCfg(ServingCellConfig_t *cuSrvCellCfg, ServCellCfgInfo *macSrvCellCfg,\
9446 ServCellCfgInfo *storedSrvCellCfg)
9447 {
9448    uint8_t ret = ROK;
9449    BWP_DownlinkDedicated_t *dlBwp = NULLP;
9450    BWP_UplinkDedicated_t   *ulBwp = NULLP;
9451
9452    if(cuSrvCellCfg->initialDownlinkBWP)
9453    {
9454       dlBwp = ((BWP_DownlinkDedicated_t *)(cuSrvCellCfg->initialDownlinkBWP));
9455       if(dlBwp->pdcch_Config)
9456       {
9457          if(dlBwp->pdcch_Config->choice.setup)
9458          {
9459             macSrvCellCfg->initDlBwp.pdcchPresent = true;
9460             if(storedSrvCellCfg)
9461             {
9462                if(!storedSrvCellCfg->initDlBwp.pdcchPresent)
9463                {
9464                   extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
9465                }
9466                else
9467                {
9468                   extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
9469                }
9470             }
9471             else
9472             {
9473                extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
9474             }
9475          }
9476       }
9477       if(dlBwp->pdsch_Config)
9478       {
9479          if(dlBwp->pdsch_Config->choice.setup)
9480          {
9481             macSrvCellCfg->initDlBwp.pdschPresent = true;
9482
9483             if(storedSrvCellCfg)
9484             {
9485                if(!storedSrvCellCfg->initDlBwp.pdschPresent)
9486                {
9487                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
9488                }
9489                else
9490                {
9491                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg,\
9492                         &storedSrvCellCfg->initDlBwp.pdschCfg);
9493                }
9494             }
9495             else
9496             {
9497                extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
9498             }
9499          }
9500       }
9501    }
9502    if(cuSrvCellCfg->firstActiveDownlinkBWP_Id)
9503       macSrvCellCfg->firstActvDlBwpId = *(cuSrvCellCfg->firstActiveDownlinkBWP_Id);
9504    if(cuSrvCellCfg->defaultDownlinkBWP_Id)
9505       macSrvCellCfg->defaultDlBwpId = *(cuSrvCellCfg->defaultDownlinkBWP_Id);
9506    if(cuSrvCellCfg->bwp_InactivityTimer)
9507    {
9508       if(macSrvCellCfg->bwpInactivityTmr)
9509       {
9510          memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
9511       }
9512       else
9513       {
9514          macSrvCellCfg->bwpInactivityTmr = NULLP;
9515          DU_ALLOC_SHRABL_BUF(macSrvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
9516          if(macSrvCellCfg->bwpInactivityTmr)
9517          {
9518             memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
9519          }
9520          else
9521          {
9522             DU_LOG("\nERROR  --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
9523             return RFAILED;
9524          }
9525       }
9526    }
9527    if(cuSrvCellCfg->pdsch_ServingCellConfig)
9528    {
9529       if(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup)
9530       {
9531          ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
9532          if(ret == RFAILED)
9533          {
9534             DU_LOG("\nERROR --> F1AP : Failed at extractPdschServingCellCfg()");
9535             return RFAILED;
9536          }
9537       }
9538    }
9539    if(cuSrvCellCfg->uplinkConfig)
9540    {
9541       if(cuSrvCellCfg->uplinkConfig->initialUplinkBWP)
9542       {
9543          ulBwp = ((BWP_UplinkDedicated_t *)(cuSrvCellCfg->uplinkConfig->initialUplinkBWP));
9544          if(ulBwp->pusch_Config)
9545          {
9546             macSrvCellCfg->initUlBwp.puschPresent = true;
9547             extractPuschCfg(ulBwp->pusch_Config, &macSrvCellCfg->initUlBwp.puschCfg);
9548          }
9549          if(ulBwp->pucch_Config)
9550          {
9551             macSrvCellCfg->initUlBwp.pucchPresent = true;
9552             memset(&macSrvCellCfg->initUlBwp.pucchCfg, 0, sizeof(PucchCfg));
9553             if(storedSrvCellCfg)
9554             {
9555                if(!storedSrvCellCfg->initUlBwp.pucchPresent)
9556                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
9557                else
9558                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg,\
9559                   &storedSrvCellCfg->initUlBwp.pucchCfg);
9560             }
9561             else
9562             {
9563                extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
9564             }
9565          }
9566       }
9567       if(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id)
9568          macSrvCellCfg->firstActvUlBwpId = *(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id);
9569    }
9570    return ret;
9571 }
9572 /*******************************************************************
9573  *
9574  * @brief Fills Reconfig Cell group Info received by CU
9575  *
9576  * @details
9577  *
9578  *    Function : extractUeReCfgCellInfo
9579  *
9580  *    Functionality: Fills Reconfig Cell group Info received by CU
9581  *
9582  * @params[in] CellGroupConfigRrc_t *cellGrp = CellGroupConfigRrc_t information which
9583  *                       is send by CU, which we have stored in F1UeContextSetupDb
9584  *             MacUeCfg *MacUeCfg = Used to Store the information,
9585  *                      which needs to send in other layer, as well as this can be
9586  *                      the variable which stores the information in DuCb,
9587  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
9588  *                      information to other layer else it will have copyOfmacUeCfg
9589  *                      which we have stored in F1UeContextSetupDb.
9590  *
9591  * @return ROK/RFAILED
9592  *
9593  * ****************************************************************/
9594 uint8_t extractUeReCfgCellInfo(CellGroupConfigRrc_t *cellGrp, MacUeCfg *macUeCfg, MacUeCfg *storedMacUeCfg)
9595 {
9596    uint8_t ret = ROK;
9597    MAC_CellGroupConfig_t     *macCellGroup = NULLP;
9598    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
9599    SpCellConfig_t            *spcellCfg = NULLP;
9600    ServingCellConfig_t       *servCellCfg = NULLP;
9601
9602    if(cellGrp)
9603    {
9604       /* Fill MacCell Group Reconfig  */
9605       if(cellGrp->mac_CellGroupConfig)
9606       {
9607          macUeCfg->macCellGrpCfgPres = true;
9608          macCellGroup = ((MAC_CellGroupConfig_t *)(cellGrp->mac_CellGroupConfig));
9609          if(macCellGroup->schedulingRequestConfig)
9610          {
9611             extractSchReqReConfig(macCellGroup->schedulingRequestConfig, &macUeCfg->macCellGrpCfg.schReqCfg);
9612          }
9613          if(macCellGroup->tag_Config)
9614          {
9615             extractTagReconfig(macCellGroup->tag_Config, &macUeCfg->macCellGrpCfg.tagCfg);
9616          }
9617          if(macCellGroup->bsr_Config)
9618          {
9619             macUeCfg->macCellGrpCfg.bsrTmrCfg.periodicTimer = macCellGroup->bsr_Config->periodicBSR_Timer;
9620             macUeCfg->macCellGrpCfg.bsrTmrCfg.retxTimer     = macCellGroup->bsr_Config->retxBSR_Timer;
9621             if(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer)
9622             {
9623                macUeCfg->macCellGrpCfg.bsrTmrCfg.srDelayTimer  =\
9624                *(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer);
9625             }
9626          }
9627          if(macCellGroup->phr_Config)
9628          {
9629             if(macCellGroup->phr_Config->present == MAC_CellGroupConfig__phr_Config_PR_setup)
9630             {
9631                macUeCfg->macCellGrpCfg.phrCfgSetupPres = true;
9632                if(macCellGroup->phr_Config->choice.setup)
9633                {
9634                   macUeCfg->macCellGrpCfg.phrCfg.periodicTimer     = \
9635                   macCellGroup->phr_Config->choice.setup->phr_PeriodicTimer;
9636                   macUeCfg->macCellGrpCfg.phrCfg.prohibitTimer     = \
9637                   macCellGroup->phr_Config->choice.setup->phr_ProhibitTimer;
9638                   macUeCfg->macCellGrpCfg.phrCfg.txPowerFactor     = \
9639                   macCellGroup->phr_Config->choice.setup->phr_Tx_PowerFactorChange;
9640                   macUeCfg->macCellGrpCfg.phrCfg.multiplePHR       = \
9641                   macCellGroup->phr_Config->choice.setup->multiplePHR;
9642                   macUeCfg->macCellGrpCfg.phrCfg.dummy             = \
9643                   macCellGroup->phr_Config->choice.setup->dummy;
9644                   macUeCfg->macCellGrpCfg.phrCfg.phrType2OtherCell = \
9645                   macCellGroup->phr_Config->choice.setup->phr_Type2OtherCell;
9646                   macUeCfg->macCellGrpCfg.phrCfg.phrOtherCG        = \
9647                   macCellGroup->phr_Config->choice.setup->phr_ModeOtherCG;
9648                }
9649             }
9650          }
9651       }
9652       /* Fill Physical Cell Group Reconfig */
9653       if(cellGrp->physicalCellGroupConfig)
9654       {
9655          macUeCfg->phyCellGrpCfgPres = true;
9656          phyCellGrpCfg = ((PhysicalCellGroupConfig_t *)(cellGrp->physicalCellGroupConfig));
9657          if(phyCellGrpCfg->p_NR_FR1)
9658          {
9659             if(*(phyCellGrpCfg->p_NR_FR1) != macUeCfg->phyCellGrpCfg.pNrFr1)
9660                macUeCfg->phyCellGrpCfg.pNrFr1 = *(phyCellGrpCfg->p_NR_FR1);
9661          }
9662          macUeCfg->phyCellGrpCfg.pdschHarqAckCodebook = phyCellGrpCfg->pdsch_HARQ_ACK_Codebook;
9663       }
9664       /* Fill SpCell Reconfig */
9665       if(cellGrp->spCellConfig)
9666       {
9667          macUeCfg->spCellCfgPres = true;
9668          spcellCfg = ((SpCellConfig_t *)(cellGrp->spCellConfig));
9669          if(spcellCfg->servCellIndex)
9670          {
9671             macUeCfg->spCellCfg.servCellIdx = *(spcellCfg->servCellIndex);
9672          }
9673          /* Fill Serving cell Reconfig info */
9674          if(cellGrp->spCellConfig->spCellConfigDedicated)
9675          {
9676             servCellCfg = ((ServingCellConfig_t *)(cellGrp->spCellConfig->spCellConfigDedicated));
9677             if(storedMacUeCfg)
9678             {
9679                if(!storedMacUeCfg->spCellCfgPres)
9680                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
9681                else
9682                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg,\
9683                         &storedMacUeCfg->spCellCfg.servCellCfg);
9684             }
9685             else
9686             {
9687                ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
9688             }
9689             if(ret == RFAILED)
9690             {
9691                DU_LOG("\nERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
9692             }
9693          }
9694       }
9695    }
9696    return ret;
9697 }
9698 /*******************************************************************
9699 *
9700 * @brief free the memory allocated by decoder
9701 *
9702 * @details
9703 *
9704 *    Function : freeAperDecodeNrcgi
9705 *
9706 *    Functionality: Free Nrcgi values
9707 *
9708 * @params[in] NRCGI_t *nrcgi
9709 * @return void
9710 *
9711 * ****************************************************************/
9712
9713
9714 void freeAperDecodeNrcgi(NRCGI_t *nrcgi)
9715 {
9716     if(nrcgi->pLMN_Identity.buf != NULLP)
9717     {
9718        free(nrcgi->pLMN_Identity.buf);
9719     }
9720     if(nrcgi->nRCellIdentity.buf != NULLP)
9721     {
9722        free(nrcgi->nRCellIdentity.buf);
9723     }
9724 }
9725 /*******************************************************************
9726 *
9727 * @brief free the memory allocated by decoder
9728 *
9729 * @details
9730 *
9731 *    Function : freeAperDecodeCuToDuInfo
9732 *
9733 *    Functionality:  Free Cu To Du Information
9734 *
9735 * @params[in] CUtoDURRCInformation_t *rrcMsg
9736 * @return void
9737 *
9738 * ****************************************************************/
9739
9740
9741 void freeAperDecodeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
9742 {
9743    uint8_t ieIdx =0;
9744    uint8_t arrIdx =0;
9745
9746    if(rrcMsg->uE_CapabilityRAT_ContainerList)
9747    {
9748       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
9749          free(rrcMsg->uE_CapabilityRAT_ContainerList->buf);
9750       free(rrcMsg->uE_CapabilityRAT_ContainerList);
9751    }
9752
9753    if(rrcMsg->iE_Extensions)
9754    {
9755       if(rrcMsg->iE_Extensions->list.array)
9756       {
9757          for(ieIdx= 0; ieIdx < rrcMsg->iE_Extensions->list.count; ieIdx++)
9758          {
9759             if(rrcMsg->iE_Extensions->list.array[ieIdx])
9760             {
9761                switch(rrcMsg->iE_Extensions->list.array[ieIdx]->id)
9762                {
9763                   case ProtocolIE_ID_id_CellGroupConfig:
9764                      if(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
9765                      {
9766                         free(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf);
9767                      }
9768                      break;
9769                   default:
9770                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
9771                            rrcMsg->iE_Extensions->list.array[ieIdx]->id);
9772                      break;
9773                }
9774             }
9775          }
9776          for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
9777          {
9778             free(rrcMsg->iE_Extensions->list.array[arrIdx]);
9779          }
9780          free(rrcMsg->iE_Extensions->list.array);
9781
9782       }
9783
9784       free(rrcMsg->iE_Extensions);
9785    }
9786 }
9787 /*******************************************************************
9788 *
9789 * @brief free the memory allocated by decoder
9790 *
9791 * @details
9792 *
9793 *    Function : freeAperDecodeSplCellList
9794 *
9795 *    Functionality: Free Spl Cell List
9796                     where memory allocated by aper_decoder
9797 *
9798 * @params[in]  SCell_ToBeSetup_List_t *spCellLst
9799 * @return void
9800 *
9801 * ****************************************************************/
9802
9803
9804 void freeAperDecodeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
9805 {
9806     uint8_t  cellIdx =0;
9807
9808     if(spCellLst->list.array != NULLP)
9809     {
9810        for(cellIdx=0; cellIdx<spCellLst->list.count; cellIdx++)
9811        {
9812           if(cellIdx==0&&spCellLst->list.array[cellIdx]!=NULLP)
9813           {
9814              freeAperDecodeNrcgi(&spCellLst->list.array[cellIdx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
9815           }
9816           if(spCellLst->list.array[cellIdx]!=NULLP)
9817           {
9818              free(spCellLst->list.array[cellIdx]);
9819           }
9820        }
9821        free(spCellLst->list.array);
9822     }
9823 }
9824 /*******************************************************************
9825 *
9826 * @brief free the memory allocated by decoder
9827 *
9828 * @details
9829 *
9830 *    Function : freeAperDecodeSRBSetup
9831 *
9832 *    Functionality: added free part for the memory allocated by aper_decoder
9833 *
9834 * @params[in] SRBs_ToBeSetup_List_t *srbSet
9835 * @return void
9836 *
9837 ****************************************************************/
9838
9839
9840 void freeAperDecodeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
9841 {
9842     uint8_t srbIdx =0;
9843     if(srbSet->list.array != NULLP)
9844     {
9845        for(srbIdx=0; srbIdx<srbSet->list.count; srbIdx++)
9846        {
9847           if(srbSet->list.array[srbIdx]!=NULLP)
9848           {
9849              free(srbSet->list.array[srbIdx]);
9850           }
9851        }
9852        free(srbSet->list.array);
9853     }
9854 }
9855
9856 /*******************************************************************
9857 *
9858 * @brief free the memory allocated by decoder
9859 *
9860 * @details
9861 *
9862 *    Function : freeAperDecodeULTnlInfo
9863 *
9864 *    Functionality: added free part for the memory allocated by aper_decoder
9865 *
9866 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
9867 * @return void
9868 *
9869 * ****************************************************************/
9870
9871
9872 void freeAperDecodeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
9873 {
9874    uint8_t ulIdx=0;
9875    if(ulInfo->list.array != NULLP)
9876    {
9877       for(ulIdx=0; ulIdx<ulInfo->list.count; ulIdx++)
9878       {
9879          if(ulIdx==0&&ulInfo->list.array[ulIdx]!=NULLP)
9880          {
9881             if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
9882             {
9883                if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9884                      transportLayerAddress.buf != NULLP)
9885                {
9886                   if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
9887                         !=NULLP)
9888                   {
9889                      free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf);
9890                   }
9891                   free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9892                         transportLayerAddress.buf);
9893                }
9894                free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel);
9895             }
9896          }
9897          if(ulInfo->list.array[ulIdx]!=NULLP)
9898          {
9899             free(ulInfo->list.array[ulIdx]);
9900          }
9901       }
9902       free(ulInfo->list.array);
9903    }
9904 }
9905 /*******************************************************************
9906 *
9907 * @brief free the memory allocated by decoder
9908 *
9909 * @details
9910 *
9911 *    Function : freeAperDecodeDRBSetup
9912 *
9913 *    Functionality: free DRBSetup which is allocated by decoder
9914 *
9915 * @params[in]  DRBs_ToBeSetup_List_t *drbSet
9916 * @return void
9917 *
9918 * ****************************************************************/
9919
9920 void freeAperDecodeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
9921 {
9922    DRBs_ToBeSetup_Item_t *drbSetItem = NULLP;
9923    uint8_t  flowIdx =0;
9924    uint8_t  drbIdx =0;
9925
9926    if(drbSet->list.array != NULLP)
9927    {
9928       for(drbIdx=0; drbIdx<drbSet->list.count; drbIdx++)
9929       {
9930          if(drbIdx==0&&drbSet->list.array[drbIdx] != NULLP)
9931          {
9932             drbSetItem =&drbSet->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
9933             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
9934             {
9935                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9936                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
9937                {
9938                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9939                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9940                   {
9941                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9942                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9943                      {
9944
9945                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
9946                         {
9947
9948                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
9949                            {
9950
9951                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->\
9952                                     buf!=NULLP)
9953                               {
9954
9955                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
9956                                        flows_Mapped_To_DRB_List.list.array != NULLP)
9957                                  {
9958
9959                                     for(flowIdx=0;flowIdx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9960                                           DRB_Information.flows_Mapped_To_DRB_List.list.count; flowIdx++)
9961                                     {
9962
9963                                        if(flowIdx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9964                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9965                                        {
9966                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9967                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9968                                                 qoSFlowLevelQoSParameters.\
9969                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
9970                                           {
9971                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9972                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9973                                                    qoSFlowLevelQoSParameters.\
9974                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9975                                              {
9976
9977                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9978                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9979                                                       qoSFlowLevelQoSParameters.\
9980                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9981                                                 {
9982
9983
9984                                                    free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9985                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9986                                                          qoSFlowLevelQoSParameters.\
9987                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9988                                                 }
9989
9990                                                 free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9991                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9992                                                       qoSFlowLevelQoSParameters.\
9993                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9994                                              }
9995
9996                                              free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9997
9998                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9999                                                    qoSFlowLevelQoSParameters.\
10000                                                    qoS_Characteristics.choice.non_Dynamic_5QI);
10001                                           }
10002                                        }
10003                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
10004                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
10005                                        {
10006
10007                                           free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
10008                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]);
10009                                        }
10010                                     }
10011
10012                                     free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
10013                                           DRB_Information.flows_Mapped_To_DRB_List.list.array);
10014                                  }
10015
10016                                  free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
10017                                        DRB_Information.sNSSAI.sD->buf);
10018                               }
10019
10020                               free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD);
10021                            }
10022
10023                            free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf);
10024
10025                         }
10026
10027                         free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
10028
10029                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
10030                      }
10031
10032                      free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
10033                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
10034                   }
10035
10036                   free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
10037                         qoS_Characteristics.choice.non_Dynamic_5QI);
10038                }
10039                free(drbSetItem->qoSInformation.choice.choice_extension);
10040             }
10041             freeAperDecodeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
10042             if(drbSetItem->uLConfiguration)
10043             {
10044                free(drbSetItem->uLConfiguration);
10045             }
10046          }
10047          if(drbSet->list.array[drbIdx]!=NULLP)
10048          {
10049             free(drbSet->list.array[drbIdx]);
10050          }
10051       }
10052       free(drbSet->list.array);
10053    }
10054 }
10055
10056
10057 /*******************************************************************
10058  *
10059  * @brief builds Mac Cell Cfg
10060  *
10061  * @details
10062  *
10063  *    Function : procUeReCfgCellInfo
10064  *
10065  *    Functionality: builds Mac Cell Cfg
10066  *
10067  * @params[in] MacUeCfg *macUeCfgToSend = Used to Store the information which
10068  *                       needs to send in other layer, as well as this can be
10069  *                       the variable which stores the information in DuCb.
10070  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
10071  *                       information to other layer else it will have copyOfmacUeCfg
10072  *                       which we have stored in F1UeContextSetupDb
10073  *             void *cellInfo = CellGroupConfigRrc_t information which is send
10074  *                        by CU, which we have stored in F1UeContextSetupDb
10075  *
10076  * @return void
10077  *
10078  * ****************************************************************/
10079 uint8_t procUeReCfgCellInfo(MacUeCfg *macUeCfgToSend,MacUeCfg *storedMacUeCfg, void *cellInfo)
10080 {
10081    uint8_t ret = ROK;
10082    CellGroupConfigRrc_t *cellGrp = NULLP;
10083
10084    if(cellInfo)
10085    {
10086       cellGrp = (CellGroupConfigRrc_t *)cellInfo;
10087       ret = extractUeReCfgCellInfo(cellGrp, macUeCfgToSend, storedMacUeCfg);
10088       if(ret == RFAILED)
10089          DU_LOG("\nERROR  -->  F1AP : Failed at procUeReCfgCellInfo()");
10090    }
10091    if(ret == RFAILED)
10092    {
10093       freeUeReCfgCellGrpInfo(macUeCfgToSend);
10094    }
10095    return ret;
10096 }
10097
10098 /*******************************************************************
10099  *
10100  * @brief Filling modulation info in mac ue cfg
10101  *
10102  * @details
10103  *
10104  *    Function : duFillModulationDetails
10105  *
10106  *    Functionality: Filling modulation info in mac ue cfg
10107  *
10108  * @params[in] MAC UE Config to be updated
10109  *             Current UE configuration
10110  *             UE NR capability from CU
10111  * @return ROK     - success
10112  *         RFAILED - failure
10113  *
10114  * ****************************************************************/
10115 void duFillModulationDetails(MacUeCfg *ueCfg, MacUeCfg *oldUeCfg, void *ueCap)
10116 {
10117    UE_NR_Capability_t *ueNrCap=NULLP;
10118
10119    if(!ueCap)
10120    {
10121       memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
10122       memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
10123    }
10124    else
10125    {
10126       ueNrCap = (UE_NR_Capability_t *)ueCap;
10127
10128       /* Filling DL modulation info */
10129       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsDownlinkPerCC && \
10130          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0] && \
10131          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL)
10132       {
10133          switch(*(ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL))
10134          {
10135             case ModulationOrder_qpsk:
10136                {
10137                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
10138                   break;
10139                }
10140             case ModulationOrder_qam16:
10141                {
10142                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM16;
10143                   break;
10144                }
10145             case ModulationOrder_qam64:
10146                {
10147                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM64;
10148                   ueCfg->dlModInfo.mcsIndex = PDSCH_MCS_INDEX;
10149                   ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64;
10150                   break;
10151                }
10152             case ModulationOrder_qam256:
10153                {
10154                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM256;
10155                   break;
10156                }
10157             default:
10158                {
10159                   DU_LOG("\nERROR  -->  DU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
10160                   memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
10161                   break;
10162                }
10163          }
10164       }
10165       else
10166       {
10167          memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
10168       }
10169
10170       /* Filling UL modulation info */
10171       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsUplinkPerCC && \
10172          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0] && \
10173          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL)
10174       {
10175          switch(*(ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL))
10176          {
10177             case ModulationOrder_qpsk:
10178                {
10179                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
10180                   break;
10181                }
10182             case ModulationOrder_qam16:
10183                {
10184                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM16;
10185                   ueCfg->ulModInfo.mcsIndex = PUSCH_MCS_INDEX;
10186                   ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64;
10187                   break;
10188                }
10189             case ModulationOrder_qam64:
10190                {
10191                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM64;
10192                   break;
10193                }
10194             case ModulationOrder_qam256:
10195                {
10196                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM256;
10197                   break;
10198                }
10199             default:
10200                {
10201                   DU_LOG("\nERROR  -->  DU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
10202                   memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
10203                   break;
10204                }
10205          }
10206       }
10207       else
10208       {
10209          memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
10210       }
10211    }
10212 }
10213
10214 /*******************************************************************
10215  *
10216  * @brief Function to extract cellGrp Info present in cutoDu cont
10217  *
10218  * @details
10219  *
10220  *    Function : extractCellGrpInfo
10221  *
10222  *    Functionality: Function to extract cellGrp Info present
10223  *                   in cutoDu cont
10224  *
10225  * @params[in] ProtocolExtensionContainer_4624P16_t pointer
10226  *
10227  * @return CellGroupConfigRrc_t *
10228  *
10229  * ****************************************************************/
10230
10231 CellGroupConfigRrc_t *extractCellGrpInfo(ProtocolExtensionContainer_4624P16_t *protocolIeExtn,\
10232       DuUeCfg *ueCfgDb)
10233 {
10234    uint8_t idx2 =0;
10235    uint16_t id =0;
10236    uint16_t recvBufLen =0;
10237    CellGroupConfigRrc_t *cellGrpCfg = NULLP;
10238    CUtoDURRCInformation_ExtIEs_t *extIeInfo = NULLP;
10239    asn_dec_rval_t rval; /* Decoder return value */
10240    memset(&rval, 0, sizeof(asn_dec_rval_t));
10241
10242    if(protocolIeExtn)
10243    {
10244       for(idx2 = 0; idx2 < protocolIeExtn->list.count; idx2++)
10245       {
10246          extIeInfo = ((CUtoDURRCInformation_ExtIEs_t *)(protocolIeExtn->list.array[idx2]));
10247          id = extIeInfo->id;
10248          switch(id)
10249          {
10250             case ProtocolIE_ID_id_CellGroupConfig:
10251             {
10252                recvBufLen = extIeInfo->extensionValue.choice.CellGroupConfig.size;
10253                /* decoding the CellGroup Buf received */
10254                DU_ALLOC(cellGrpCfg, sizeof(CellGroupConfigRrc_t));
10255                if(cellGrpCfg)
10256                {
10257                   memset(cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
10258                   rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfg,
10259                      extIeInfo->extensionValue.choice.CellGroupConfig.buf, recvBufLen, 0, 0);
10260                   if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10261                   {
10262                      DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
10263                      return NULLP;
10264                   }
10265                   xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfg);
10266                   if(extractRlcCfgToAddMod(cellGrpCfg->rlc_BearerToAddModList, ueCfgDb))
10267                      return NULLP;
10268                }
10269                break;
10270             }
10271             default:
10272                DU_LOG("\nERROR  -->  F1AP : Invalid IE received CUtoDURRCInformation:%d at decodeCellGrpCfg()", id);
10273                break;
10274          }
10275       }
10276    }
10277    return cellGrpCfg;
10278 }
10279
10280 /*******************************************************************
10281  *
10282  * @brief Fills Srb List received by CU
10283  *
10284  * @details
10285  *
10286  *    Function : procSrbListToSetup
10287  *
10288  *    Functionality: Fills Srb List received  by CU
10289  *
10290  * @params[in] SRBs_ToBeSetup_Item_t *cuSrbItem
10291  *             LcCfg pointer
10292  *             RlcBearerCfg pointer
10293  * @return void
10294  *
10295  * ****************************************************************/
10296 uint8_t procSrbListToSetup(SRBs_ToBeSetup_Item_t * srbItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd)
10297 {
10298
10299    /* Filling RLC INFO */
10300    procRlcLcCfg(srbItem->sRBID, srbItem->sRBID, RB_TYPE_SRB, RLC_AM, CONFIG_ADD, NULL, rlcLcToAdd, NULL);
10301
10302    /* Filling MAC INFO */
10303    if(procMacLcCfg(srbItem->sRBID, RB_TYPE_SRB, CONFIG_ADD, NULL,NULL, NULL, NULL, macLcToAdd, NULL)  != ROK)
10304    {
10305       DU_LOG("\nERROR  -->  F1AP : Failed at MAC LC Cfg in procSrbListToSetup()");
10306       return RFAILED;
10307    }
10308
10309    return ROK;
10310 }
10311
10312
10313
10314 /*******************************************************************
10315  *
10316  * @brief extract Srb List received by CU
10317  *
10318  * @details
10319  *
10320  *    Function : extractSrbListToSetup
10321  *
10322  *    Functionality: extract Srb List received by CU
10323  *                   for both MAC and RLC
10324  *
10325  * @params[in] SRBs_ToBeSetup_Item_t pointer
10326  *             DuUeCfg pointer
10327  * @return ROK/RFAIED
10328  *
10329  * ****************************************************************/
10330
10331 uint8_t extractSrbListToSetup(SRBs_ToBeSetup_List_t *srbCfg, DuUeCfg *ueCfgDb)
10332 {
10333    uint8_t ret, srbIdx;
10334    SRBs_ToBeSetup_Item_t *srbItem = NULLP;
10335
10336    if(srbCfg)
10337    {
10338       for(srbIdx = 0; srbIdx < srbCfg->list.count; srbIdx++)
10339       {
10340          srbItem = &srbCfg->list.array[srbIdx]->value.choice.SRBs_ToBeSetup_Item;
10341          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
10342          {
10343             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in MAC");
10344             ret = RFAILED;
10345             break;
10346          }
10347          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
10348          {
10349             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in RLC");
10350             ret = RFAILED;
10351             break;
10352          }
10353          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
10354          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
10355          ret = procSrbListToSetup(srbItem, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
10356             &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs]);
10357          ueCfgDb->numRlcLcs++;
10358          ueCfgDb->numMacLcs++;
10359          DU_LOG("\nDEBUG --> DUAPP: extractSrbListToSetup: SRBID: %d [RLC,MAC,NumDrb]:[%x,%x,%x]",\
10360                             srbItem->sRBID, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
10361          if(ret == RFAILED)
10362          {
10363             DU_LOG("\nERROR  -->  F1AP:  Failed at extractSrbListToSetup()");
10364             break;
10365          }
10366       }
10367    }
10368    else
10369       ret = RFAILED;
10370
10371    return ret;
10372 }
10373
10374 /*******************************************************************
10375  *
10376  * @brief Fills Drb List received by CU
10377  *
10378  * @details
10379  *
10380  *    Function : procDrbListToSetupMod
10381  *
10382  *    Functionality: Fills Drb List received by CU
10383  *                   for both MAC and RLC
10384  *
10385  * @params[in] DRBs_ToBeSetup_Item_t , DRBs_ToBeSetupMod_Item_t,
10386  *             DRBs_ToBeModified_Item_t , lcId, LcCfg pointer,
10387  *             RlcBearerCfg , UpTnlCfg, RlcUeCfg
10388  * @return void
10389  *
10390  * ****************************************************************/
10391
10392 uint8_t procDrbListToSetupMod(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbItem,\
10393 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd, UpTnlCfg *upTnlInfo, RlcUeCfg *storedRlcUeCfg)
10394 {
10395    uint8_t cfgIdx = 0;
10396    RlcMode rlcModeInfo;
10397
10398    if(drbItem != NULLP)
10399    {
10400       /* Filling RLC INFO */
10401       procRlcLcCfg(drbItem->dRBID, lcId, RB_TYPE_DRB, drbItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd, &drbItem->\
10402       qoSInformation);
10403
10404       /* Filling MAC INFO */
10405       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, drbItem, NULL, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
10406       {
10407          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
10408          return RFAILED;
10409       }
10410    }
10411    else if(drbSetupModItem != NULLP)
10412    {
10413       procRlcLcCfg(drbSetupModItem->dRBID, lcId, RB_TYPE_DRB, drbSetupModItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd,
10414       &drbSetupModItem->qoSInformation);
10415
10416       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, NULL, drbSetupModItem, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
10417       {
10418          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
10419          return RFAILED;
10420       }
10421    }
10422    else if(drbModItem != NULLP)
10423    {
10424       /* Drb to Mod IEs doesnot have rlcMode to be modified
10425        * in ASN. Hence no change in RLC configurations */
10426       if(storedRlcUeCfg != NULLP)
10427       {
10428          for(cfgIdx = 0; cfgIdx < storedRlcUeCfg->numLcs; cfgIdx++)
10429          {
10430             if(storedRlcUeCfg->rlcLcCfg[cfgIdx].lcId == lcId)
10431             {
10432                rlcModeInfo = storedRlcUeCfg->rlcLcCfg[cfgIdx].rlcMode;
10433                break;
10434             }
10435          }
10436       }
10437
10438       procRlcLcCfg(drbModItem->dRBID, lcId, RB_TYPE_DRB, rlcModeInfo, CONFIG_MOD, NULL, rlcLcToAdd, drbModItem->qoSInformation);
10439       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_MOD, NULL, NULL, drbModItem, NULL, macLcToAdd, upTnlInfo) != ROK)
10440       {
10441          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
10442          return RFAILED;
10443       }
10444    }
10445    return ROK;
10446 }
10447
10448 /*******************************************************************
10449  *
10450  * @brief extract Drb List received by CU
10451  *
10452  * @details
10453  *
10454  *    Function : extractDrbListToSetupMod
10455  *
10456  *    Functionality: extract Drb List received by CU
10457  *                   for both MAC and RLC
10458  *
10459  * @params[in] DRBs_ToBeSetup_Item_t pointer
10460  *             DuUeCfg pointer
10461  * @return ROK/RFAIED
10462  *
10463  * ****************************************************************/
10464
10465 uint8_t extractDrbListToSetupMod(DRBs_ToBeSetup_List_t *drbCfg, DRBs_ToBeSetupMod_List_t *drbSetupModCfg,\
10466  DRBs_ToBeModified_List_t *drbModCfg, uint8_t drbCount, DuUeCfg *ueCfgDb, uint32_t *drbBitMap, RlcUeCfg *rlcUeCfg)
10467 {
10468    uint8_t ret, drbIdx = 0, lcId = 0;
10469    DRBs_ToBeSetup_Item_t *drbItem = NULLP;
10470    DRBs_ToBeSetupMod_ItemIEs_t *drbSetupModItem = NULLP;
10471    DRBs_ToBeModified_ItemIEs_t *drbModItem = NULLP;
10472
10473    ret = ROK;
10474    if(drbCount > 0)
10475    {
10476       for(drbIdx = 0; drbIdx < drbCount; drbIdx++)
10477       {
10478          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
10479          {
10480             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in MAC at extractDrbListToSetupMod()");
10481             ret = RFAILED;
10482             break;
10483          }
10484          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
10485          {
10486             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in RLC at extractDrbListToSetupMod()");
10487             ret = RFAILED;
10488             break;
10489          }
10490          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
10491          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
10492
10493          if(drbModCfg != NULLP)
10494          {
10495             drbModItem = (DRBs_ToBeModified_ItemIEs_t *) drbModCfg->list.array[drbIdx];
10496             lcId = fetchLcId(drbModItem->value.choice.DRBs_ToBeModified_Item.dRBID);
10497             if(lcId < MIN_DRB_LCID)
10498             {
10499                DU_LOG("\nERROR  --> F1AP : Failed fetching LCID %d in extractDrbListToSetupMod() for Modified List", lcId);
10500                break;
10501             }
10502             ret = procDrbListToSetupMod(lcId, NULL, NULL, &(drbModItem->value.choice.DRBs_ToBeModified_Item),\
10503             &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs],\
10504             &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
10505             if(ret == RFAILED)
10506             {
10507                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for Modified List");
10508                break;
10509             }
10510
10511          }
10512          else
10513          {
10514             lcId = getDrbLcId(drbBitMap);
10515             if(lcId == RFAILED)
10516             {
10517                DU_LOG("\nERROR  -->  F1AP :  InCorrect LCID extractDrbListToSetupMod()");
10518                ret = RFAILED;
10519                break;
10520             }
10521             if(drbCfg != NULL)
10522             {
10523                drbItem = &drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
10524                ret = procDrbListToSetupMod(lcId, drbItem, NULL, NULL, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
10525                      &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
10526                if(ret == RFAILED)
10527                {
10528                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetup List");
10529                   break;
10530                }
10531             }
10532             else if(drbSetupModCfg != NULL)
10533             {
10534                drbSetupModItem = (DRBs_ToBeSetupMod_ItemIEs_t *) drbSetupModCfg->list.array[drbIdx];
10535                ret = procDrbListToSetupMod(lcId, NULL, &(drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item), NULL,\
10536                      &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs],\
10537                      &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
10538                if(ret == RFAILED)
10539                {
10540                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetupMod List");
10541                   break;
10542                }
10543                ueCfgDb->numDrbSetupMod++;
10544             }
10545          }
10546          ueCfgDb->numRlcLcs++;
10547          ueCfgDb->numMacLcs++;
10548          ueCfgDb->numDrb++;
10549
10550          DU_LOG("\nDEBUG --> DUAPP: extractDrbListToSetupMod:lcId:%x ,BitMap:%x, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
10551                             lcId,*drbBitMap, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
10552          if(ret == RFAILED)
10553          {
10554             DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod()");
10555             break;
10556          }
10557       }
10558    }
10559    else
10560       ret = RFAILED;
10561
10562    return ret;
10563 }
10564
10565 /*******************************************************************
10566  *
10567  * @brief Function to extract Dl RRC Msg received from CU
10568  *
10569  * @details
10570  *
10571  *    Function : extractDlRrcMsg
10572  *
10573  *    Functionality: Function to extract Dl RRC Msg received from CU
10574  *
10575  * @params[in] F1AP message
10576  * @return ROK     - success
10577  *         RFAILED - failure
10578  *
10579  * ****************************************************************/
10580
10581 uint8_t extractDlRrcMsg(uint32_t gnbDuUeF1apId, uint32_t gnbCuUeF1apId, \
10582    F1DlRrcMsg *dlRrcMsg, RRCContainer_t *rrcContainer)
10583 {
10584    uint8_t ret = ROK;
10585    dlRrcMsg->rrcMsgSize = rrcContainer->size;
10586    if(dlRrcMsg->rrcMsgSize > 0)
10587    {
10588       DU_ALLOC_SHRABL_BUF(dlRrcMsg->rrcMsgPdu, dlRrcMsg->rrcMsgSize);
10589       if(!dlRrcMsg->rrcMsgPdu)
10590       {
10591          DU_LOG("\nERROR  --> DU APP : Memory allocation failed for RRC Msg in extractDlRrcMsg()");
10592          ret = RFAILED;
10593       }
10594       else
10595       {
10596          dlRrcMsg->gnbDuUeF1apId = gnbDuUeF1apId;
10597          dlRrcMsg->gnbCuUeF1apId = gnbCuUeF1apId;
10598          dlRrcMsg->srbId = SRB1_LCID;
10599          memcpy(dlRrcMsg->rrcMsgPdu, rrcContainer->buf, dlRrcMsg->rrcMsgSize);
10600       }
10601    }
10602    return ret;
10603 }
10604
10605 /*******************************************************************
10606  *
10607  * @brief Extract UE capability info
10608  *
10609  * @details
10610  *
10611  *    Function : extractUeCapability
10612  *
10613  *    Functionality: Extract UE capability info and stores in ue Cb
10614  *
10615  * @params[in] Octet string of UE capability RAT container list
10616  * @return ROK     - success
10617  *         RFAILED - failure
10618  *
10619  * ****************************************************************/
10620 UE_NR_Capability_t *extractUeCapability(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf, DuUeCb *ueCb)
10621 {
10622    uint8_t  idx;
10623    uint16_t recvBufLen;
10624    asn_dec_rval_t rval;
10625    UE_NR_Capability_t  *ueNrCap = NULLP;
10626    UE_CapabilityRAT_ContainerListRRC_t  *ueCapRatContList = NULLP;
10627
10628    /* Decoding UE Capability RAT Container List */
10629    recvBufLen = ueCapablityListBuf->size;
10630    DU_ALLOC(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10631    if(!ueCapRatContList)
10632    {
10633       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
10634       return NULLP;
10635    }
10636    memset(ueCapRatContList, 0, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10637    memset(&rval, 0, sizeof(asn_dec_rval_t));
10638    rval = aper_decode(0, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, (void **)&ueCapRatContList,
10639           ueCapablityListBuf->buf, recvBufLen, 0, 0);
10640    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10641    {
10642       DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
10643       return NULLP;
10644    }
10645    xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, ueCapRatContList);
10646
10647    /* Free encoded buffer after decoding */
10648
10649    for(idx = 0; idx < ueCapRatContList->list.count; idx++)
10650    {
10651       if(ueCapRatContList->list.array[idx]->rat_Type == RAT_Type_nr)
10652       {
10653          /* Decoding UE NR Capability */
10654           recvBufLen = ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.size;
10655           DU_ALLOC(ueNrCap, sizeof(UE_NR_Capability_t));
10656           if(!ueNrCap)
10657           {
10658              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
10659              DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10660              return NULLP;
10661           }
10662           memset(ueNrCap, 0, sizeof(UE_NR_Capability_t));
10663           memset(&rval, 0, sizeof(asn_dec_rval_t));
10664           rval = aper_decode(0, &asn_DEF_UE_NR_Capability, (void **)&ueNrCap,
10665                  ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf, recvBufLen, 0, 0);
10666           if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10667           {
10668              DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
10669              return NULLP;
10670           }
10671           xer_fprint(stdout, &asn_DEF_UE_NR_Capability, ueNrCap);
10672
10673           /* Free encoded buffer after decoding */
10674           free(ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf);
10675       }
10676       free(ueCapRatContList->list.array[idx]);
10677    }
10678
10679    /* Free Memory*/
10680    free(ueCapRatContList->list.array);
10681    DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10682    return ueNrCap;
10683 }
10684
10685 /*******************************************************************
10686 *
10687 * @brief free UE context setup request from CU
10688 *
10689 * @details
10690 *
10691 *    Function : freeAperDecodeF1UeContextSetupReq
10692 *
10693 *    Functionality: freeing part for the memory allocated by aper_decoder
10694 *
10695 * @params[in] F1AP message
10696 * @return ROK     - success
10697 *         RFAILED - failure
10698 *
10699 * ****************************************************************/
10700 void freeAperDecodeF1UeContextSetupReq(UEContextSetupRequest_t   *ueSetReq)
10701 {
10702    uint8_t ieIdx = 0;
10703
10704    if(ueSetReq->protocolIEs.list.array != NULLP)
10705    {
10706       for(ieIdx = 0; ieIdx < ueSetReq->protocolIEs.list.count; ieIdx++)
10707       {
10708          if(ueSetReq->protocolIEs.list.array[ieIdx])
10709          {
10710             switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
10711             {
10712                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10713                   break;
10714                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10715                   break;
10716                case ProtocolIE_ID_id_SpCell_ID:
10717                   freeAperDecodeNrcgi(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
10718                   break;
10719                case ProtocolIE_ID_id_ServCellIndex:
10720                   break;
10721                case ProtocolIE_ID_id_SpCellULConfigured:
10722                   break;
10723                case ProtocolIE_ID_id_CUtoDURRCInformation:
10724
10725                   freeAperDecodeCuToDuInfo(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation);
10726                   break;
10727                case ProtocolIE_ID_id_SCell_ToBeSetup_List:
10728
10729                   freeAperDecodeSplCellList(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SCell_ToBeSetup_List);
10730                   break;
10731                case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
10732
10733                   freeAperDecodeSRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List);
10734                   break;
10735                case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
10736
10737                   freeAperDecodeDRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List);
10738                   break;
10739                case ProtocolIE_ID_id_RRCContainer:
10740                   {
10741
10742                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf != NULLP)
10743                      {
10744
10745                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
10746                      }
10747                      break;
10748                   }
10749                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10750                   break;
10751                case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
10752                   {
10753                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf)
10754                      {
10755                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf);
10756                      }
10757                      break;
10758                   }
10759                default:
10760                   DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld " ,ueSetReq->protocolIEs.list.array[ieIdx]->id);
10761             }
10762             free(ueSetReq->protocolIEs.list.array[ieIdx]);
10763          }
10764       }
10765       free(ueSetReq->protocolIEs.list.array);
10766    }
10767 }
10768 /*******************************************************************
10769  *
10770  * @brief Process UE context setup request from CU
10771  *
10772  * @details
10773  *
10774  *    Function : procF1UeContextSetupReq
10775  *
10776  *    Functionality: Process UE context setup request from CU
10777  *
10778  * @params[in] F1AP message
10779  * @return ROK     - success
10780  *         RFAILED - failure
10781  *
10782  * ****************************************************************/
10783 uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
10784 {
10785    uint8_t  ret=0, ieIdx=0, ueIdx=0, cellIdx=0;
10786    bool ueCbFound = false;
10787    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0, bitRateSize=0;
10788    DuUeCb   *duUeCb = NULL;
10789    UEContextSetupRequest_t   *ueSetReq = NULL;
10790    DRBs_ToBeSetup_List_t *drbCfg = NULL;
10791
10792    ret = ROK;
10793
10794    ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
10795    for(ieIdx=0; (ieIdx < ueSetReq->protocolIEs.list.count && ret == ROK); ieIdx++)
10796    {
10797       switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
10798       {
10799          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10800             {
10801                gnbCuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
10802                break;
10803             }
10804          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10805             {
10806                gnbDuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
10807                break;
10808             }
10809          case ProtocolIE_ID_id_ServCellIndex:
10810             {
10811                cellIdx = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.ServCellIndex;
10812                for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
10813                {
10814                   if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
10815                         (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
10816                   {
10817                      ueCbFound = true;
10818                      duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
10819                      DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
10820                      if(duUeCb->f1UeDb)
10821                      {
10822                         memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
10823                         duUeCb->f1UeDb->actionType = UE_CTXT_SETUP;
10824                         duUeCb->f1UeDb->cellIdx = cellIdx;
10825                      }
10826                      else
10827                      {
10828                         DU_LOG("\nERROR  -->  F1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
10829                         ret = RFAILED;
10830                      }
10831                      break;
10832                   }
10833                   else
10834                      ueCbFound = false;
10835
10836                }
10837                if(!ueCbFound)
10838                {
10839                   DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
10840                   ret = RFAILED;
10841                }
10842                break;
10843             }
10844          case ProtocolIE_ID_id_SpCellULConfigured:
10845             /* Indicates whether the gNB-CU requests the gNB-DU to configure the uplink as no UL,
10846                UL, SUL or UL+SUL for the indicated cell for the UE */
10847             break;
10848          case ProtocolIE_ID_id_CUtoDURRCInformation:
10849             {
10850                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.uE_CapabilityRAT_ContainerList)
10851                {
10852                   duUeCb->f1UeDb->duUeCfg.ueNrCapability = \
10853                   extractUeCapability(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.\
10854                   uE_CapabilityRAT_ContainerList, duUeCb);
10855                }
10856                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.iE_Extensions)
10857                {
10858                   duUeCb->f1UeDb->duUeCfg.cellGrpCfg = extractCellGrpInfo(ueSetReq->protocolIEs.list.array[ieIdx]->\
10859                         value.choice.CUtoDURRCInformation.iE_Extensions, &duUeCb->f1UeDb->duUeCfg);
10860                   if(!duUeCb->f1UeDb->duUeCfg.cellGrpCfg)
10861                   {
10862                      DU_LOG("\nERROR  -->  F1AP: Failed to extract cell Grp Info");
10863                      //TODO: Update the failure cause in ue context Setup Response
10864                      ret = RFAILED;
10865                   }
10866                }
10867                break;
10868             }
10869          case ProtocolIE_ID_id_SCell_ToBeSetup_List:
10870             {
10871                DU_LOG("\nINFO   -->  DU_APP: Received SCell_ToBeSetup_List but  Not processing the list");
10872                break;
10873             }
10874          case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
10875             {
10876                if(extractSrbListToSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List,\
10877                &duUeCb->f1UeDb->duUeCfg))
10878                {
10879                   DU_LOG("\nERROR  -->  DU APP : Failed at extractSrbListToSetup()");
10880                   //TODO: Update the failure cause in ue context Setup Response
10881                   ret = RFAILED;
10882                }
10883                break;
10884             }
10885          case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
10886             {
10887                   drbCfg = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List;
10888
10889                   if(extractDrbListToSetupMod(drbCfg, NULL, NULL, drbCfg->list.count, &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, NULLP))
10890                   {
10891                      DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod()");
10892                      //TODO: Update the failure cause in ue context Setup Response
10893                      ret = RFAILED;
10894                   }
10895                break;
10896             }
10897          case ProtocolIE_ID_id_RRCContainer:
10898             {
10899                /* Filling Dl RRC Msg Info */
10900                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
10901                if(!duUeCb->f1UeDb->dlRrcMsg)
10902                {
10903                   DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
10904                   ret = RFAILED;
10905                }
10906                else
10907                {
10908                   duUeCb->f1UeDb->dlRrcMsgPres = true;
10909                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
10910                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
10911                         &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer);
10912                }
10913                break;
10914             }
10915          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10916             {
10917                if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
10918                {
10919                   duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
10920                }
10921                else
10922                {
10923                   DU_LOG("\nERROR  -->  Ignoring delivery report, since rrcContainer is not present");
10924                }
10925                break;
10926             }
10927          case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
10928             {
10929                /* MaximumBitRate Uplink */
10930                bitRateSize = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.size;
10931                if(bitRateSize > 0)
10932                {
10933                   DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.ambrCfg, bitRateSize);
10934                   if(!duUeCb->f1UeDb->duUeCfg.ambrCfg)
10935                   {
10936                      DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
10937                      ret = RFAILED;
10938                   }
10939                   else
10940                   {
10941                      memset(duUeCb->f1UeDb->duUeCfg.ambrCfg, 0, sizeof(AmbrCfg));
10942                      memcpy(&duUeCb->f1UeDb->duUeCfg.ambrCfg->ulBr,
10943                            ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf, bitRateSize);
10944                   }
10945                }
10946                else
10947                   ret = RFAILED;
10948                break;
10949             }
10950          default:
10951             {
10952                break;
10953             }
10954       }
10955    }
10956    if(ret == RFAILED)
10957    {
10958       /*TODO : Negative case*/
10959       // BuildAndSendUeContextSetupRsp(cellId,ueIdx);
10960       DU_LOG("\nERROR  -->  F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
10961    }
10962    else
10963       ret = duProcUeContextSetupRequest(duUeCb);
10964
10965    freeAperDecodeF1UeContextSetupReq(ueSetReq);
10966    return ret;
10967
10968 }
10969 /*******************************************************************
10970  * @brief Free the memory allocated for Dl Tunnel Info
10971  *
10972  * @details
10973  *
10974  *    Function : freeDlTnlInfo
10975  *
10976  *    Functionality:
10977  *       Free the memory allocated for Dl Tunnel Info
10978  *
10979  * @params[in] DLUPTNLInformation_ToBeSetup_List_t *
10980  * @return void
10981  *
10982  * ****************************************************************/
10983
10984 void freeDlTnlInfo(DLUPTNLInformation_ToBeSetup_List_t *tnlInfo)
10985 {
10986    uint8_t arrIdx = 0;
10987
10988    if(tnlInfo)
10989    {
10990       for(arrIdx=0; arrIdx < tnlInfo->list.count; arrIdx++)
10991       {
10992          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf,\
10993                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
10994          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf,\
10995                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
10996          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
10997          DU_FREE(tnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
10998       }
10999       DU_FREE(tnlInfo->list.array, tnlInfo->list.size);
11000    }
11001 }
11002
11003 /*******************************************************************
11004  * @brief Free the memory allocated for DRB setup List
11005  *
11006  * @details
11007  *
11008  *    Function : freeDrbSetupList
11009  *
11010  *    Functionality:
11011  *       Free the memory allocated for DRB setup list
11012  *
11013  * @params[in] DRBs_Setup_List_t *
11014  * @return void
11015  *
11016  * ****************************************************************/
11017 void freeDrbSetupList(DRBs_Setup_List_t *drbSetupList)
11018 {
11019    uint8_t arrIdx = 0;
11020    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
11021
11022    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
11023    {
11024       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
11025       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
11026       DU_FREE(drbSetupList->list.array[arrIdx],  sizeof(DRBs_Setup_Item_t));
11027    }
11028    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
11029 }
11030
11031 /*******************************************************************
11032  * @brief Free the memory allocated for UE Setup response
11033  *
11034  * @details
11035  *
11036  *    Function : FreeUeContextSetupRsp
11037  *
11038  *    Functionality:
11039  *       Free the memory allocated for UE Setup response
11040  *
11041  * @params[in] F1AP PDU for UE setup response
11042  * @return ROK     - success
11043  *         RFAILED - failure
11044  *
11045  * ****************************************************************/
11046 void FreeUeContextSetupRsp(F1AP_PDU_t *f1apMsg)
11047 {
11048    uint8_t idx;
11049    UEContextSetupResponse_t *ueSetRsp = NULLP;
11050
11051    if(f1apMsg)
11052    {
11053       if(f1apMsg->choice.successfulOutcome)
11054       {
11055          ueSetRsp = &f1apMsg->choice.successfulOutcome->value.choice.\
11056                     UEContextSetupResponse;
11057          if(ueSetRsp->protocolIEs.list.array)
11058          {
11059             for(idx = 0; idx < ueSetRsp->protocolIEs.list.count; idx++)
11060             {
11061                if(ueSetRsp->protocolIEs.list.array[idx])
11062                {
11063                   switch(ueSetRsp->protocolIEs.list.array[idx]->id)
11064                   {
11065                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11066                         break;
11067                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11068                         break;
11069                      case ProtocolIE_ID_id_DUtoCURRCInformation:
11070                         {
11071                            CellGroupConfig_t *cellGrpCfg = NULLP;
11072                            cellGrpCfg  = &ueSetRsp->protocolIEs.list.array[idx]->value.choice.\
11073                                          DUtoCURRCInformation.cellGroupConfig;
11074                            if(cellGrpCfg->buf != NULLP)
11075                            {
11076                               DU_FREE(cellGrpCfg->buf, cellGrpCfg->size);
11077                               cellGrpCfg = NULLP;
11078                            }
11079                            break;
11080                         }
11081                     case ProtocolIE_ID_id_DRBs_Setup_List:
11082                         {
11083                            freeDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
11084                            break;
11085                         }
11086                      default:
11087                         DU_LOG("\nERROR  -->  DUAPP: Invalid Id %ld at FreeUeContextSetupRsp()",\
11088                         ueSetRsp->protocolIEs.list.array[idx]->id);
11089                         break;
11090                   }
11091                   DU_FREE(ueSetRsp->protocolIEs.list.array[idx],\
11092                         sizeof(UEContextSetupResponseIEs_t));
11093                }
11094             }
11095             DU_FREE(ueSetRsp->protocolIEs.list.array, \
11096                   ueSetRsp->protocolIEs.list.size);
11097          }
11098          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11099       }
11100       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11101    }
11102 }
11103
11104 /*******************************************************************
11105  *
11106  * @brief Builds Ue context Setup Rsp DU To CU Info
11107  *
11108  * @details
11109  *
11110  *    Function : EncodeUeCntxtDuToCuInfo
11111  *
11112  *    Functionality: Builds Ue context Setup Rsp DU To CU Info
11113  *
11114  * @params[in] CellGroupConfig_t *, CellGroupConfigRrc_t *
11115  *
11116  * @return ROK     - success
11117  *         RFAILED - failure
11118  *
11119  ******************************************************************/
11120
11121 uint8_t EncodeUeCntxtDuToCuInfo(CellGroupConfig_t *duToCuCellGrp, CellGroupConfigRrc_t *duCellGrpCfg)
11122 {
11123    asn_enc_rval_t        encRetVal;
11124
11125    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, duCellGrpCfg);
11126    memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
11127    encBufSize = 0;
11128    encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, duCellGrpCfg, PrepFinalEncBuf, encBuf);
11129    /* Encode results */
11130    if(encRetVal.encoded == ENCODE_FAIL)
11131    {
11132       DU_LOG( "\nERROR  -->  F1AP : Could not encode UeCntxtDuToCuInfo (at %s)\n",\
11133             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11134       return RFAILED;
11135    }
11136    else
11137    {
11138       DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
11139       for(int i=0; i< encBufSize; i++)
11140       {
11141          printf("%x",encBuf[i]);
11142       }
11143    }
11144    duToCuCellGrp->size = encBufSize;
11145    DU_ALLOC(duToCuCellGrp->buf, duToCuCellGrp->size);
11146    if(!duToCuCellGrp->buf)
11147    {
11148       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in UeCntxtDuToCuInfo");
11149    }
11150    memcpy(duToCuCellGrp->buf, encBuf, duToCuCellGrp->size);
11151    return ROK;
11152 }
11153
11154 /*******************************************************************
11155  *
11156  * @brief Fills Dl Gtp tunnel Info
11157  *
11158  * @details
11159  *
11160  *    Function : fillGtpTunnelforDl
11161  *
11162  *    Functionality: Fills Dl Gtp tunnel Info
11163  *
11164  * @params[in]
11165  *
11166  * @return ROK     - success
11167  *         RFAILED - failure
11168  *
11169  * ****************************************************************/
11170
11171 uint8_t fillGtpTunnelforDl(GTPTunnel_t *gtpDl, GtpTnlCfg *gtpUeCfg)
11172 {
11173    uint8_t bufSize = 0;
11174
11175    gtpDl->transportLayerAddress.size    = 4*sizeof(uint8_t);
11176    DU_ALLOC(gtpDl->transportLayerAddress.buf, gtpDl->transportLayerAddress.size);
11177    if(gtpDl->transportLayerAddress.buf == NULLP)
11178    {
11179       return RFAILED;
11180    }
11181    memcpy(gtpDl->transportLayerAddress.buf, &gtpUeCfg->dlTnlAddress, gtpDl->transportLayerAddress.size);
11182
11183    /*GTP TEID*/
11184    gtpDl->gTP_TEID.size = 4 * sizeof(uint8_t);
11185    DU_ALLOC(gtpDl->gTP_TEID.buf, gtpDl->gTP_TEID.size);
11186    if(gtpDl->gTP_TEID.buf == NULLP)
11187    {
11188       return RFAILED;
11189    }
11190    bufSize = 3; /*forming an Octect String*/
11191    fillTeIdString(bufSize, gtpUeCfg->teId, gtpDl->gTP_TEID.buf);
11192
11193    return ROK;
11194 }
11195
11196 /*******************************************************************
11197  *
11198  * @brief Fills DL Tunnel Setup List
11199  *
11200  * @details
11201  *
11202  *    Function : fillDlTnlSetupList
11203  *
11204  *    Functionality: Fills the DL Tunnel Setup List
11205  *
11206  * @params[in]
11207  *
11208  * @return ROK     - success
11209  *         RFAILED - failure
11210  *
11211  * ****************************************************************/
11212
11213 uint8_t fillDlTnlSetupList(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo, UpTnlCfg *tnlCfg)
11214 {
11215    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
11216
11217    eleCount = 1;
11218    dlTnlInfo->list.count = eleCount;
11219    dlTnlInfo->list.size = (eleCount * sizeof(DLUPTNLInformation_ToBeSetup_Item_t *));
11220
11221    /* Initialize the DL Tnl Setup List Members */
11222    DU_ALLOC(dlTnlInfo->list.array, dlTnlInfo->list.size);
11223    if(dlTnlInfo->list.array == NULLP)
11224    {
11225       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL Tnl Setup List in fillDlTnlSetupList()");
11226       ret = RFAILED;
11227    }
11228    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
11229    {
11230       DU_ALLOC(dlTnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
11231       if(dlTnlInfo->list.array[arrIdx] == NULLP)
11232       {
11233          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDlTnlSetupList()", arrIdx);
11234          return RFAILED;
11235       }
11236       dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
11237       DU_ALLOC(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
11238       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel == NULLP)
11239       {
11240          DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL tunnel info in fillDlTnlSetupList()");
11241          return RFAILED;
11242       }
11243       ret = fillGtpTunnelforDl(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel,\
11244                tnlCfg->tnlCfg1);
11245       if(ret != ROK)
11246          break;
11247    }
11248    return ret;
11249 }
11250
11251 /*******************************************************************
11252  *
11253  * @brief Fills the Drb Setup List for Ue Context Setup Response
11254  *
11255  * @details
11256  *
11257  *    Function : fillDrbSetupList
11258  *
11259  *    Functionality: Fills the Drb Setup List for Ue Context Setup Response
11260  *
11261  * @params[in]
11262  *
11263  * @return ROK     - success
11264  *         RFAILED - failure
11265  *
11266  * ****************************************************************/
11267 uint8_t fillDrbSetupList(DRBs_Setup_List_t *drbSetupList, DuUeCfg *ueCfg)
11268 {
11269    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
11270    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
11271
11272    eleCount = ueCfg->numDrb;
11273    drbSetupList->list.count = eleCount;
11274    drbSetupList->list.size = \
11275         (eleCount * sizeof(DRBs_Setup_Item_t *));
11276
11277    /* Initialize the Drb Setup List Members */
11278    DU_ALLOC(drbSetupList->list.array, drbSetupList->list.size);
11279    if(drbSetupList->list.array == NULLP)
11280    {
11281       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DRB Setup List in fillDrbSetupList()");
11282       ret = RFAILED;
11283    }
11284
11285    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
11286    {
11287       DU_ALLOC(drbSetupList->list.array[arrIdx], sizeof(DRBs_Setup_Item_t));
11288       if(drbSetupList->list.array[arrIdx] == NULLP)
11289       {
11290          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDrbSetupList()", arrIdx);
11291          return RFAILED;
11292       }
11293       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
11294       drbItemIe->id = ProtocolIE_ID_id_DRBs_Setup_Item;
11295       drbItemIe->criticality = Criticality_reject;
11296       drbItemIe->value.present = DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item;
11297       drbItemIe->value.choice.DRBs_Setup_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
11298       ret = fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List,\
11299           &ueCfg->upTnlInfo[arrIdx]);
11300       if(ret != ROK)
11301          break;
11302    }
11303    return ret;
11304 }
11305
11306 /*******************************************************************
11307  *
11308  * @brief Builds and sends the UE Setup Response
11309  *
11310  * @details
11311  *
11312  *    Function : BuildAndSendUeContextSetupRsp
11313  *
11314  *    Functionality: Constructs the UE Setup Response and sends
11315  *                   it to the DU through SCTP.
11316  *
11317  * @params[in] uint8_t cellId,uint8_t ueIdx
11318  *
11319  * @return ROK     - success
11320  *         RFAILED - failure
11321  *
11322  * ****************************************************************/
11323 uint8_t BuildAndSendUeContextSetupRsp(uint8_t cellId,uint8_t ueIdx)
11324 {
11325    uint8_t   idx, ret, cellIdx, elementCnt;
11326    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
11327    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
11328    asn_enc_rval_t  encRetVal;        /* Encoder return value */
11329    F1AP_PDU_t               *f1apMsg = NULLP;
11330    UEContextSetupResponse_t *ueSetRsp = NULLP;
11331    CellGroupConfigRrc_t     *cellGrpCfg = NULLP;
11332    DuUeCb                   *ueCb = NULLP;
11333
11334    DU_LOG("\n INFO   -->  F1AP : Building UE Context Setup Response for cellId %d, ueIdx %d\n", cellId, ueIdx);
11335
11336    while(true)
11337    {
11338       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11339       if(f1apMsg == NULLP)
11340       {
11341          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11342          ret = RFAILED;
11343          break;
11344       }
11345
11346       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
11347       DU_ALLOC(f1apMsg->choice.successfulOutcome,
11348             sizeof(SuccessfulOutcome_t));
11349       if(f1apMsg->choice.successfulOutcome == NULLP)
11350       {
11351          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
11352          ret = RFAILED;
11353          break;
11354       }
11355
11356       f1apMsg->choice.successfulOutcome->procedureCode = \
11357                                                          ProcedureCode_id_UEContextSetup;
11358       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
11359       f1apMsg->choice.successfulOutcome->value.present = \
11360                                                          SuccessfulOutcome__value_PR_UEContextSetupResponse;
11361
11362       ueSetRsp =
11363          &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
11364       elementCnt = 4;
11365       ueSetRsp->protocolIEs.list.count = elementCnt;
11366       ueSetRsp->protocolIEs.list.size = \
11367                                         elementCnt * sizeof(UEContextSetupResponse_t *);
11368
11369       /* Initialize the UESetup members */
11370       DU_ALLOC(ueSetRsp->protocolIEs.list.array, \
11371             ueSetRsp->protocolIEs.list.size);
11372       if(ueSetRsp->protocolIEs.list.array == NULLP)
11373       {
11374          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
11375          ret = RFAILED;
11376          break;
11377       }
11378
11379       for(idx=0; idx<elementCnt; idx++)
11380       {
11381          DU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
11382                sizeof(UEContextSetupResponseIEs_t));
11383          if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
11384          {
11385             DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
11386             ret = RFAILED;
11387             break;
11388          }
11389       }
11390       /* Fetching Ue Cb Info*/
11391       GET_CELL_IDX(cellId, cellIdx);
11392       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
11393       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
11394       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
11395
11396       idx = 0;
11397       /*GNB CU UE F1AP ID*/
11398       ueSetRsp->protocolIEs.list.array[idx]->id = \
11399                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11400       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11401       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
11402                                                              UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
11403       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
11404
11405       /*GNB DU UE F1AP ID*/
11406       idx++;
11407       ueSetRsp->protocolIEs.list.array[idx]->id = \
11408                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11409       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11410       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
11411                                                              UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
11412       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
11413
11414
11415       /*DUtoCURRC Information */
11416       idx++;
11417       ueSetRsp->protocolIEs.list.array[idx]->id  = \
11418                                                    ProtocolIE_ID_id_DUtoCURRCInformation;
11419       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11420       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
11421                                                             UEContextSetupResponseIEs__value_PR_DUtoCURRCInformation;
11422       if(ueCb->f1UeDb)
11423       {
11424          if(ueCb->f1UeDb->duUeCfg.cellGrpCfg)
11425          {
11426             cellGrpCfg = (CellGroupConfigRrc_t*)ueCb->f1UeDb->duUeCfg.cellGrpCfg;
11427             ret = EncodeUeCntxtDuToCuInfo(&ueSetRsp->protocolIEs.list.array[idx]->value.\
11428                      choice.DUtoCURRCInformation.cellGroupConfig, cellGrpCfg);
11429             if(ret == RFAILED)
11430             {
11431                DU_LOG("\nERROR  -->  F1AP : Failed to EncodeUeCntxtDuToCuInfo in BuildAndSendUeContextSetupRsp()");
11432                freeF1UeDb(ueCb->f1UeDb);
11433                ueCb->f1UeDb = NULLP;
11434                break;
11435             }
11436          }
11437       }
11438       else
11439       {
11440          DU_LOG("\nERROR  -->  F1AP : Failed to form DUtoCU RRCInfo at BuildAndSendUeContextSetupRsp()");
11441          ret = RFAILED;
11442          break;
11443       }
11444
11445       /* Drb Setup List */
11446       idx++;
11447       ueSetRsp->protocolIEs.list.array[idx]->id  = \
11448                                  ProtocolIE_ID_id_DRBs_Setup_List;
11449       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11450       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
11451                                  UEContextSetupResponseIEs__value_PR_DRBs_Setup_List;
11452       ret = fillDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List,\
11453                &ueCb->f1UeDb->duUeCfg);
11454       if(ret == RFAILED)
11455       {
11456          DU_LOG("\nERROR  -->  F1AP : Failed to fillDrbSetupList in BuildAndSendUeContextSetupRsp()");
11457          freeF1UeDb(ueCb->f1UeDb);
11458          ueCb->f1UeDb = NULLP;
11459          break;
11460       }
11461
11462        /* Free UeContext Db created during Ue context Req */
11463        freeF1UeDb(ueCb->f1UeDb);
11464        ueCb->f1UeDb = NULLP;
11465
11466       /* TODO: To send Drb list */
11467       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11468
11469       /* Encode the UE context setup response type as APER */
11470       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
11471       encBufSize = 0;
11472       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11473             encBuf);
11474       /* Encode results */
11475       if(encRetVal.encoded == ENCODE_FAIL)
11476       {
11477          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Response structure (at %s)\n",\
11478                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11479          ret = RFAILED;
11480          break;
11481       }
11482       else
11483       {
11484          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Setup Response\n");
11485          for(int i=0; i< encBufSize; i++)
11486          {
11487             printf("%x",encBuf[i]);
11488          }
11489       }
11490
11491       /* Sending  msg  */
11492       if(sendF1APMsg()  != ROK)
11493       {
11494          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Response failed");
11495          ret = RFAILED;
11496          break;
11497       }
11498       break;
11499    }
11500    FreeUeContextSetupRsp(f1apMsg);
11501    return ret;
11502 }/* End of BuildAndSendUeContextSetupRsp */
11503 /*******************************************************************
11504 *
11505 * @brief  Build And Send Ue Context Rsp
11506 *
11507 * @details
11508 *
11509 *    Function : BuildAndSendUeCtxtRsp
11510 *
11511 *    Functionality : Build And Send Ue Context Rsp
11512
11513 * @params[in]
11514 * @return sucess = ROK
11515 *         failure = RFAILED
11516 *
11517 * ****************************************************************/
11518 uint8_t BuildAndSendUeCtxtRsp(uint8_t cellId, uint8_t ueIdx)
11519 {
11520    uint8_t cellIdx = 0, actionType = 0;
11521
11522    GET_CELL_IDX(cellId, cellIdx);
11523    actionType = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].f1UeDb->actionType;
11524
11525    switch(actionType)
11526    {
11527       case UE_CTXT_SETUP:
11528          {
11529             BuildAndSendUeContextSetupRsp(cellId,ueIdx);
11530             break;
11531          }
11532       case UE_CTXT_MOD:
11533          {
11534             BuildAndSendUeContextModRsp(cellId, ueIdx);
11535             break;
11536          }
11537       default:
11538          DU_LOG("ERROR  -->  F1AP: Invalid Action Type %d at BuildAndSendUeCtxtRsp()", actionType);
11539          break;
11540
11541    }
11542    return ROK;
11543 }
11544
11545 /*******************************************************************
11546  *
11547  * @brief deallocating the memory of  F1reset msg
11548  *
11549  * @details
11550  *
11551  *    Function : FreeF1ResetReq
11552  *
11553  *    Functionality :
11554  *         - freeing memory of F1reset request msg
11555  *
11556  * @params[in]
11557  * @return void
11558  *
11559  *
11560  * ****************************************************************/
11561 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
11562 {
11563    uint8_t idx =0 ;
11564    Reset_t *f1ResetMsg;
11565
11566    if(f1apMsg)
11567    {
11568       if(f1apMsg->choice.initiatingMessage)
11569       {
11570          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11571
11572          if(f1ResetMsg->protocolIEs.list.array)
11573          {
11574             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
11575             {
11576                if(f1ResetMsg->protocolIEs.list.array[idx])
11577                {
11578                   DU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
11579                }
11580             }
11581             DU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
11582          }
11583          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11584       }
11585       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11586    }
11587 }
11588 /*******************************************************************
11589  *
11590  * @brief Build and Send F1reset request
11591  *
11592  * @details
11593  *
11594  *    Function : BuildAndSendF1ResetReq
11595  *
11596  *    Functionality:
11597  *         - Build and Send F1reset request msg
11598  *
11599  * @params[in]
11600  * @return ROK     - success
11601  *         RFAILED - failure
11602  *
11603  * ****************************************************************/
11604 uint8_t BuildAndSendF1ResetReq()
11605 {
11606    uint8_t          elementCnt=0;
11607    uint8_t          idx=0;
11608    uint8_t          ret= RFAILED;
11609    Reset_t          *f1ResetMsg = NULLP;
11610    F1AP_PDU_t       *f1apMsg = NULLP;
11611    asn_enc_rval_t   encRetVal;
11612    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset request \n");
11613    do
11614    {
11615       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11616       if(f1apMsg == NULLP)
11617       {
11618          break;
11619       }
11620       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
11621       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11622       if(f1apMsg->choice.initiatingMessage == NULLP)
11623       {
11624          break;
11625       }
11626       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
11627       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
11628       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
11629
11630       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11631
11632       elementCnt = 3;
11633       f1ResetMsg->protocolIEs.list.count = elementCnt;
11634       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
11635
11636       /* Initialize the F1Setup members */
11637       DU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
11638       if(f1ResetMsg->protocolIEs.list.array == NULLP)
11639       {
11640          break;
11641       }
11642       for(idx=0; idx<elementCnt; idx++)
11643       {
11644          DU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
11645          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
11646          {
11647             break;
11648          }
11649       }
11650
11651       /*TransactionID*/
11652       idx=0;
11653       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
11654       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11655       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
11656       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
11657
11658       /*Cause*/
11659       idx++;
11660       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
11661       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
11662       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
11663       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
11664       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
11665
11666       /*Reset Type*/
11667       idx++;
11668       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
11669       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11670       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
11671       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
11672       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
11673
11674       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11675
11676       /* Encode the F1SetupRequest type as APER */
11677       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11678       encBufSize = 0;
11679       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11680             encBuf);
11681
11682       /* Encode results */
11683       if(encRetVal.encoded == ENCODE_FAIL)
11684       {
11685          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
11686                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11687          break;
11688       }
11689       else
11690       {
11691          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1Reset\n");
11692          for(idx=0; idx< encBufSize; idx++)
11693          {
11694             printf("%x",encBuf[idx]);
11695          }
11696       }
11697
11698       if(sendF1APMsg() != ROK)
11699       {
11700          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
11701          break;
11702       }
11703
11704       ret = ROK;
11705       break;
11706    }while(true);
11707
11708    FreeF1ResetReq(f1apMsg);
11709    return ret;
11710 }
11711 /*******************************************************************
11712  *
11713  * @brief Build And Send F1ResetAck
11714  *
11715  * @details
11716  *
11717  *    Function : BuildAndSendF1ResetAck
11718  *
11719  *    Functionality:
11720  *         - Build And Send  F1ResetRSP
11721  *
11722  * @return ROK     - success
11723  *         RFAILED - failure
11724  *
11725  * ****************************************************************/
11726 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
11727 {
11728    uint8_t idx;
11729    ResetAcknowledge_t *f1ResetAck;
11730
11731    if(f1apMsg)
11732    {
11733       if(f1apMsg->choice.successfulOutcome)
11734       {
11735          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
11736
11737          if(f1ResetAck->protocolIEs.list.array)
11738          {
11739             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
11740             {
11741                if(f1ResetAck->protocolIEs.list.array[idx])
11742                {
11743                   DU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
11744                }
11745             }
11746             DU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
11747          }
11748          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11749       }
11750       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11751    }
11752 }
11753
11754 /*******************************************************************
11755  *
11756  * @brief Build And Send F1ResetAck
11757  *
11758  * @details
11759  *
11760  *    Function : BuildAndSendF1ResetAck
11761  *
11762  *    Functionality:
11763  *         - Build And Send  F1ResetRSP
11764  *
11765  *  @params[in]
11766  * @return ROK     - success
11767  *         RFAILED - failure
11768  *
11769  * ****************************************************************/
11770 uint8_t BuildAndSendF1ResetAck()
11771 {
11772    uint8_t                idx = 0;
11773    uint8_t                elementCnt = 0;
11774    uint8_t                ret = RFAILED;
11775    F1AP_PDU_t             *f1apMsg = NULL;
11776    ResetAcknowledge_t     *f1ResetAck = NULLP;
11777    asn_enc_rval_t         encRetVal;
11778    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset Acknowledgment \n");
11779
11780    do{
11781       /* Allocate the memory for F1ResetRequest_t */
11782       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11783       if(f1apMsg == NULLP)
11784       {
11785          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11786          break;
11787       }
11788
11789       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
11790
11791       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11792       if(f1apMsg->choice.successfulOutcome == NULLP)
11793       {
11794          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11795          break;
11796       }
11797       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
11798       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
11799       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
11800
11801       elementCnt = 1;
11802
11803       f1ResetAck->protocolIEs.list.count = elementCnt;
11804       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
11805
11806       DU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
11807       if(f1ResetAck->protocolIEs.list.array == NULLP)
11808       {
11809          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
11810          break;
11811       }
11812
11813       for(idx=0; idx<elementCnt; idx++)
11814       {
11815          DU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
11816          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
11817          {
11818             break;
11819          }
11820       }
11821       /*TransactionID*/
11822       idx = 0;
11823       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
11824       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11825       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
11826       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
11827
11828       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11829
11830       /* Encode the F1SetupRequest type as UPER */
11831       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11832       encBufSize = 0;
11833       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
11834
11835       /* Check encode results */
11836       if(encRetVal.encoded == ENCODE_FAIL)
11837       {
11838          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
11839                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11840          break;
11841       }
11842       else
11843       {
11844          DU_LOG("\nDUBUG   -->  F1AP : Created APER encoded buffer for F1ResetAck\n");
11845          for(int i=0; i< encBufSize; i++)
11846          {
11847             printf("%x",encBuf[i]);
11848          }
11849       }
11850       /* Sending msg */
11851       if(sendF1APMsg() != ROK)
11852       {
11853          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Acknowledgement failed");
11854          break;
11855       }
11856
11857       ret = ROK;
11858       break;
11859    }while(true);
11860
11861    FreeF1ResetAck(f1apMsg);
11862    return ret;
11863 }
11864 /******************************************************************
11865 *
11866 * @brief free F1 reset msg allocated by aper_decoder
11867 *
11868 * @details
11869 *
11870 *    Function : freeAperDecodeF1ResetMsg
11871 *
11872 *    Functionality: free F1 reset msg allocated by aper_decoder
11873 *
11874 * @params[in] Reset_t *f1ResetMsg
11875 * @return void
11876 *
11877 * ****************************************************************/
11878
11879 void freeAperDecodeF1ResetMsg(Reset_t *f1ResetMsg)
11880 {
11881    uint8_t ieIdx =0;
11882    if(f1ResetMsg->protocolIEs.list.array)
11883    {
11884       for(ieIdx=0 ;ieIdx < f1ResetMsg->protocolIEs.list.count ; ieIdx++)
11885       {
11886          if(f1ResetMsg->protocolIEs.list.array[ieIdx])
11887          {
11888             free(f1ResetMsg->protocolIEs.list.array[ieIdx]);
11889          }
11890       }
11891       free(f1ResetMsg->protocolIEs.list.array);
11892    }
11893 }
11894
11895 /******************************************************************
11896  *
11897  * @brief Processes DL RRC Message Transfer  sent by CU
11898  *
11899  * @details
11900  *
11901  *    Function : procF1ResetReq
11902  *
11903  *    Functionality: Processes DL RRC Message Transfer sent by CU
11904  *
11905  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11906  * @return ROK     - success
11907  *         RFAILED - failure
11908  *
11909  * ****************************************************************/
11910 uint8_t procF1ResetReq(F1AP_PDU_t *f1apMsg)
11911 {
11912    /* we are currently not supporting Ue release. right now we are supporting only init case of fireset */
11913    uint8_t       ieIdx = 0;
11914    uint8_t        ret = ROK;
11915    Reset_t       *f1ResetMsg = NULLP;
11916
11917    DU_LOG("\nINFO   -->  Processing F1 reset request");
11918    f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11919
11920    for(ieIdx=0; ieIdx<f1ResetMsg->protocolIEs.list.count; ieIdx++)
11921    {
11922       switch(f1ResetMsg->protocolIEs.list.array[ieIdx]->id)
11923       {
11924          case ProtocolIE_ID_id_TransactionID:
11925             break;
11926
11927          case ProtocolIE_ID_id_Cause:
11928             break;
11929
11930          case ProtocolIE_ID_id_ResetType:
11931             {
11932                break;
11933             }
11934
11935          default:
11936             break;
11937       }
11938    }
11939    ret = BuildAndSendF1ResetAck();
11940    DU_LOG("\nINFO   -->  UE release is not supported for now");
11941
11942    freeAperDecodeF1ResetMsg(f1ResetMsg);
11943
11944    return ret;
11945 }
11946
11947 /*******************************************************************
11948  *
11949  * @brief free the RRC delivery report
11950  *
11951  * @details
11952  *
11953  *    Function : freeRrcDeliveryReport
11954  *
11955  *    Functionality: free the RRC delivery report
11956  *
11957  * @params[in]
11958  * @return ROK     - success
11959  *         RFAILED - failure
11960  *
11961  * ****************************************************************/
11962 void freeRrcDeliveryReport(F1AP_PDU_t  *f1apMsg )
11963 {
11964    uint8_t idx=0;
11965    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11966
11967    if(f1apMsg)
11968    {
11969       if(f1apMsg->choice.initiatingMessage)
11970       {
11971          rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11972          if(rrcDeliveryReport->protocolIEs.list.array)
11973          {
11974             for(idx =0 ;idx <rrcDeliveryReport->protocolIEs.list.count ;
11975                   idx++)
11976             {
11977                if(rrcDeliveryReport->protocolIEs.list.array[idx])
11978                {
11979                   DU_FREE(rrcDeliveryReport->protocolIEs.list.array[idx],
11980                         sizeof(RRCDeliveryReportIEs_t));
11981                }
11982             }
11983             DU_FREE(rrcDeliveryReport->protocolIEs.list.array,
11984                   rrcDeliveryReport->protocolIEs.list.size);
11985          }
11986          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11987       }
11988       DU_FREE(f1apMsg,
11989             sizeof(F1AP_PDU_t));
11990    }
11991 }
11992
11993 /*******************************************************************
11994 *
11995 * @brief Builds and sends the RRC delivery report
11996 *
11997 * @details
11998 *
11999 *    Function : BuildAndSendRrcDeliveryReport
12000 *
12001 *    Functionality: Builds and sends the RRC delivery report
12002 *
12003 * @params[in]
12004 *
12005 * @return ROK     - success
12006 *         RFAILED - failure
12007 *
12008 * ****************************************************************/
12009 uint8_t BuildAndSendRrcDeliveryReport(uint32_t gnbCuUeF1apId, \
12010    uint32_t gnbDuUeF1apId, RrcDeliveryReport *rrcDelivery)
12011 {
12012    uint8_t             ret = RFAILED;
12013    uint8_t             idx    = 0;
12014    uint8_t             idx1   = 0;
12015    uint8_t             elementCnt = 0;
12016    F1AP_PDU_t          *f1apMsg = NULLP;
12017    asn_enc_rval_t      encRetVal;
12018    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
12019
12020    do{
12021
12022       DU_LOG("\nINFO   -->  F1AP : Building RRC delivery Message Transfer Message\n");
12023       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12024       if(f1apMsg == NULLP)
12025       {
12026          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
12027          break;
12028       }
12029       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
12030       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
12031       if(f1apMsg->choice.initiatingMessage == NULLP)
12032       {
12033          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU  failed");
12034          break;
12035       }
12036       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_RRCDeliveryReport;
12037       f1apMsg->choice.initiatingMessage->criticality   = Criticality_ignore;
12038       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RRCDeliveryReport;
12039
12040       rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
12041       elementCnt = 4;
12042       rrcDeliveryReport->protocolIEs.list.count = elementCnt;
12043       rrcDeliveryReport->protocolIEs.list.size = elementCnt * sizeof(RRCDeliveryReportIEs_t *);
12044
12045       /* Initialize the F1Setup members */
12046       DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array, rrcDeliveryReport->protocolIEs.list.size);
12047       if(rrcDeliveryReport->protocolIEs.list.array == NULLP)
12048       {
12049          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRC Delivery  failed");
12050          break;
12051       }
12052       for(idx =0 ;idx <elementCnt; idx++)
12053       {
12054          DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array[idx], sizeof(RRCDeliveryReportIEs_t));
12055          if(rrcDeliveryReport->protocolIEs.list.array[idx] == NULLP)
12056          {
12057             break;
12058          }
12059       }
12060
12061       idx1 = 0;
12062
12063       /*GNB CU UE F1AP ID*/
12064       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
12065       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
12066       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_CU_UE_F1AP_ID;
12067       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
12068
12069       /*GNB DU UE F1AP ID*/
12070       idx1++;
12071       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
12072       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
12073       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_DU_UE_F1AP_ID;
12074       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
12075
12076       /*RRC delivery status*/
12077       idx1++;
12078       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_RRCDeliveryStatus;
12079       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
12080       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_RRCDeliveryStatus;
12081       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.delivery_status =\
12082       rrcDelivery->rrcDeliveryStatus.deliveryStatus;
12083       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.triggering_message =\
12084       rrcDelivery->rrcDeliveryStatus.triggeringMessage;
12085
12086       /* SRB ID */
12087       idx1++;
12088       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
12089       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
12090       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_SRBID;
12091       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.SRBID =  rrcDelivery->srbId;
12092
12093       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12094
12095       /* Encode the RRC DELIVERY REPORT type as APER */
12096       memset(encBuf, 0, ENC_BUF_MAX_LEN);
12097       encBufSize = 0;
12098       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
12099             encBuf);
12100
12101       /* Encode results */
12102       if(encRetVal.encoded == ENCODE_FAIL)
12103       {
12104          DU_LOG("\nERROR  -->  F1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
12105                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12106          break;
12107       }
12108       else
12109       {
12110          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for RRC Delivery Msg \n");
12111          for(idx=0; idx< encBufSize; idx++)
12112          {
12113             printf("%x",encBuf[idx]);
12114          }
12115       }
12116
12117       /* Sending msg */
12118       if(sendF1APMsg() != ROK)
12119       {
12120          DU_LOG("\nERROR  -->  F1AP : Sending RRC delivery  msg request failed");
12121          break;
12122       }
12123       ret = ROK;
12124       break;
12125
12126    }while(true);
12127
12128    freeRrcDeliveryReport(f1apMsg);
12129    return ret;
12130 }
12131
12132 /*******************************************************************
12133  *
12134  * @brief Processes cells to be activated
12135  *
12136  * @details
12137  *
12138  *    Function : extractCellsToBeActivated
12139  *
12140  *    Functionality:
12141  *      - Processes cells to be activated list received in F1SetupRsp
12142  *
12143  * @params[in] void
12144  * @return ROK     - success
12145  *         RFAILED - failure
12146  *
12147  * ****************************************************************/
12148
12149 uint8_t extractCellsToBeActivated(Cells_to_be_Activated_List_t cellsToActivate)
12150 {
12151    uint8_t  ret = ROK;
12152    uint16_t idx, nci, pci = 0;
12153    Cells_to_be_Activated_List_Item_t cell;
12154
12155    for(idx=0; idx<cellsToActivate.list.count; idx++)
12156    {
12157       nci = 0;
12158       cell = cellsToActivate.list.array[idx]->value.choice.Cells_to_be_Activated_List_Item;
12159       bitStringToInt(&cell.nRCGI.nRCellIdentity, &nci);
12160
12161       if(cell.nRPCI)
12162       {
12163          pci = *cell.nRPCI;
12164       }
12165       ret = duProcCellsToBeActivated(cell.nRCGI.pLMN_Identity.buf, nci, pci);
12166    }
12167    return ret;
12168 }
12169 /******************************************************************
12170 *
12171 * @brief Processes F1 Setup Response allocated by aper_decoder
12172 *
12173 * @details
12174 *
12175 *    Function : freeF1SetupRsp
12176 *
12177 *    Functionality: free F1 Setup Response allocated by aper_decoder
12178 *
12179 * @params[in] F1SetupResponse_t *f1SetRspMsg
12180 * @return void
12181 *
12182 * ****************************************************************/
12183
12184 void freeAperDecodeF1SetupRsp(F1SetupResponse_t *f1SetRspMsg)
12185 {
12186    uint8_t ieIdx =0;
12187    uint8_t arrIdx =0;
12188    Cells_to_be_Activated_List_t *cellToActivate =NULLP;
12189    RRC_Version_t      *rrcVer =NULLP;
12190
12191    if(f1SetRspMsg->protocolIEs.list.array)
12192    {
12193       for(ieIdx=0; ieIdx<f1SetRspMsg->protocolIEs.list.count; ieIdx++)
12194       {
12195          if(f1SetRspMsg->protocolIEs.list.array[ieIdx])
12196          {
12197             switch(f1SetRspMsg->protocolIEs.list.array[ieIdx]->id)
12198             {
12199                case ProtocolIE_ID_id_Cells_to_be_Activated_List:
12200                   {
12201                      cellToActivate =
12202                         &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.Cells_to_be_Activated_List;
12203                      if(cellToActivate->list.array)
12204                      {
12205                         for(arrIdx=0; arrIdx<cellToActivate->list.count ; arrIdx++)
12206                         {
12207                            if(cellToActivate->list.array[arrIdx])
12208                            {
12209
12210                               if(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.\
12211                               pLMN_Identity.buf)
12212                               {
12213                                  if(cellToActivate->list.array[0]->value.choice.\
12214                                        Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf)
12215                                  {
12216                                     free(cellToActivate->list.array[0]->value.choice.\
12217                                           Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf);
12218                                  }
12219
12220                                  free(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
12221                                        nRCGI.pLMN_Identity.buf);
12222                               }
12223                               free(cellToActivate->list.array[arrIdx]);
12224                            }
12225                         }
12226                         free(cellToActivate->list.array);
12227                      }
12228                      break;
12229                   }
12230                case ProtocolIE_ID_id_TransactionID:
12231                   {
12232                      break;
12233                   }
12234                case ProtocolIE_ID_id_gNB_CU_Name:
12235                   {
12236                      free(f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_Name.buf);
12237                      break;
12238                   }
12239                case ProtocolIE_ID_id_GNB_CU_RRC_Version:
12240                   {
12241                      rrcVer = &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
12242                      if(rrcVer->latest_RRC_Version.buf)
12243                      {
12244                         if(rrcVer->iE_Extensions)
12245                         {
12246                            if(rrcVer->iE_Extensions->list.array)
12247                            {
12248                               if(rrcVer->iE_Extensions->list.array[0])
12249                               {
12250                                  if(rrcVer->iE_Extensions->list.\
12251                                        array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf)
12252                                  {
12253                                     free(rrcVer->iE_Extensions->list.\
12254                                           array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf);
12255                                  }
12256                                  free(rrcVer->iE_Extensions->list.array[0]);
12257                               }
12258                               free(rrcVer->iE_Extensions->list.array);
12259                            }
12260                            free(rrcVer->iE_Extensions);
12261                         }
12262                         free(rrcVer->latest_RRC_Version.buf);
12263                      }
12264                      break;
12265
12266                   }
12267                default:
12268                   {
12269                      DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
12270                            f1SetRspMsg->protocolIEs.list.array[ieIdx]->id);
12271                   }
12272             }
12273             free(f1SetRspMsg->protocolIEs.list.array[ieIdx]);
12274          }
12275       }
12276       free(f1SetRspMsg->protocolIEs.list.array);
12277    }
12278 }
12279 /******************************************************************
12280  *
12281  * @brief Processes F1 Setup Response sent by CU
12282  *
12283  * @details
12284  *
12285  *    Function : procF1SetupRsp
12286  *
12287  *    Functionality: Processes F1 Setup Response sent by CU
12288  *
12289  * @params[in] F1AP_PDU_t ASN decoded F1AP message
12290  * @return ROK     - success
12291  *         RFAILED - failure
12292  *
12293  * ****************************************************************/
12294 uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg)
12295 {
12296    uint8_t ret = ROK;
12297    uint16_t idx =0;
12298    F1SetupResponse_t *f1SetRspMsg = NULLP;
12299    GNB_CU_Name_t     *cuName = NULLP;
12300    F1SetupRsp  f1SetRspDb;
12301    RRC_Version_t      *rrcVer =NULLP;
12302
12303    memset(&f1SetRspDb, 0, sizeof(F1SetupRsp));
12304
12305    DU_LOG("\nINFO   -->  F1AP : F1 Setup Response received");
12306    f1SetRspMsg = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
12307
12308    for(idx=0; idx<f1SetRspMsg->protocolIEs.list.count; idx++)
12309    {
12310       switch(f1SetRspMsg->protocolIEs.list.array[idx]->id)
12311       {
12312          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
12313             {
12314                extractCellsToBeActivated(f1SetRspMsg->protocolIEs.list.array[idx]->\
12315                      value.choice.Cells_to_be_Activated_List);
12316                break;
12317             }
12318          case ProtocolIE_ID_id_TransactionID:
12319             {
12320                f1SetRspDb.transId = f1SetRspMsg->protocolIEs.list.array[idx]->\
12321                                     value.choice.TransactionID;
12322                break;
12323             }
12324          case ProtocolIE_ID_id_gNB_CU_Name:
12325             {
12326                cuName = &f1SetRspMsg->protocolIEs.list.array[idx]->\
12327                         value.choice.GNB_CU_Name;
12328                strcpy(f1SetRspDb.cuName, (const char*)cuName->buf);
12329                break;
12330             }
12331          case ProtocolIE_ID_id_GNB_CU_RRC_Version:
12332             {
12333                rrcVer = &f1SetRspMsg->protocolIEs.list.array[idx]->value.choice.RRC_Version;
12334                strcpy(f1SetRspDb.rrcVersion.rrcVer,
12335                      (const char*)rrcVer->latest_RRC_Version.buf);
12336                break;
12337             }
12338          default:
12339             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
12340                   f1SetRspMsg->protocolIEs.list.array[idx]->id);
12341       }
12342       duProcF1SetupRsp();
12343    }
12344
12345    freeAperDecodeF1SetupRsp(f1SetRspMsg);
12346    return ret;
12347 }
12348 /*******************************************************************
12349 *
12350 * @brief free GNB DU config update ack
12351 *
12352 * @details
12353 *
12354 *    Function : freeAperDecodeGnbDuAck
12355 *
12356 *    Functionality: Processes GNB DU config update ack And
12357 *                     added free part for the memory allocated by aper_decoder
12358 *
12359 * @params[in] F1AP_PDU_t ASN decoded F1AP message
12360 * @return ROK     - success
12361 *         RFAILED - failure
12362 *
12363 * ****************************************************************/
12364
12365 void freeAperDecodeGnbDuAck(GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck)
12366 {
12367    uint8_t ieIdx = 0;
12368
12369    if(gnbDuAck->protocolIEs.list.array)
12370    {
12371       for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
12372       {
12373          if(gnbDuAck->protocolIEs.list.array[ieIdx])
12374          {
12375             free(gnbDuAck->protocolIEs.list.array[ieIdx]);
12376          }
12377       }
12378       free(gnbDuAck->protocolIEs.list.array);
12379    }
12380 }
12381
12382 /*******************************************************************
12383 *
12384 * @brief Building  result of gnb-du config update ack output
12385 *
12386 * @details
12387 *
12388 *    Function : duProcGnbDuCfgUpdAckMsg
12389 *
12390 *    Functionality:
12391 *        Building output of gnb-du config update ack
12392 *
12393 * @params[in] transId
12394 * @return void
12395 *
12396 * ****************************************************************/
12397
12398 uint8_t duProcGnbDuCfgUpdAckMsg(uint8_t transId)
12399 {
12400    uint8_t  ieIdx=0, arrIdx=0,ret=ROK;
12401    uint8_t  ueId =0 , ueIdx =0, totalActiveUe = 0;
12402    uint16_t cellId =0, cellIdx =0, crnti=0;
12403    CmLList *f1apPduNode = NULLP;
12404    ReservedF1apPduInfo *f1apPduInfo =NULLP;
12405    F1AP_PDU_t *f1apMsgPdu = NULLP;
12406    GNBDUConfigurationUpdate_t *gnbDuConfigUpdate = NULLP;
12407    BIT_STRING_t *cellIdentity=NULLP;
12408    struct Served_Cells_To_Delete_ItemIEs *deleteItemIe=NULLP;
12409    Served_Cells_To_Delete_List_t *cellsToDelete=NULLP;
12410    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
12411
12412    DU_LOG("\nINFO   -->  DU APP: GNB-DU config update Ack received ");
12413    f1apPduNode = searchFromReservedF1apPduList(transId);
12414    f1apPduInfo = (ReservedF1apPduInfo *)f1apPduNode->node;
12415    f1apMsgPdu = (F1AP_PDU_t *)f1apPduInfo->f1apMsg;
12416
12417    if(f1apMsgPdu)
12418    {
12419       if(f1apMsgPdu->choice.initiatingMessage)
12420       {
12421          gnbDuConfigUpdate = &f1apMsgPdu->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
12422          for(ieIdx=0; ieIdx < gnbDuConfigUpdate->protocolIEs.list.count; ieIdx++)
12423          {
12424             switch(gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->id)
12425             {
12426                case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
12427                   {
12428                      cellsToDelete = &gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
12429                                      Served_Cells_To_Delete_List;
12430                      if(cellsToDelete->list.array)
12431                      {
12432                         if(cellsToDelete->list.array[arrIdx])
12433                         {
12434                            deleteItemIe = (Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx];
12435                            deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
12436                            if(deleteItem->oldNRCGI.nRCellIdentity.buf)
12437                            {
12438                               cellIdentity = &deleteItem->oldNRCGI.nRCellIdentity;
12439                               bitStringToInt(cellIdentity, &cellId);
12440                            }
12441                         }
12442                      }
12443
12444                      GET_CELL_IDX(cellId, cellIdx);
12445                      if(duCb.actvCellLst[cellIdx] != NULLP)
12446                      {
12447                         if(duCb.actvCellLst[cellIdx]->numActvUes == 0)
12448                         {
12449                            duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
12450                            ret = duSendCellDeletReq(cellId);
12451                            if(ret == RFAILED)
12452                            {
12453                               DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to send cell delete\
12454                               request for cellId[%d]", cellId);
12455                            }
12456                         }
12457                         else
12458                         {
12459                            totalActiveUe = duCb.actvCellLst[cellIdx]->numActvUes;
12460                            while(totalActiveUe)
12461                            {
12462                               if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx].ueState != UE_ACTIVE)
12463                               {
12464                                  ueIdx++;
12465                                  continue;
12466                               }
12467
12468                               crnti = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].crnti;
12469                               GET_UE_IDX(crnti,ueId);
12470                               /* Sending Ue Context release request only for maximum supporting UEs */
12471                               ret = BuildAndSendUeContextReleaseReq(cellId, ueId);
12472                               if(ret == RFAILED)
12473                               {
12474                                  DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to build and send UE delete\
12475                                  request for cellId[%d]", cellId);
12476                               }
12477                               ueIdx++;
12478                               totalActiveUe--;
12479                            }
12480                         }
12481                      }
12482                      else
12483                      {
12484                         DU_LOG("\nERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): CellId [%d] not found", cellId);
12485                         ret = RFAILED;
12486                      }
12487                      break;
12488                   }
12489
12490                default:
12491                   break;
12492             }
12493          }
12494       }
12495    }
12496
12497    FreeDUConfigUpdate(f1apMsgPdu);
12498    deleteFromReservedF1apPduList(f1apPduNode);
12499    return ret;
12500 }
12501
12502 /*******************************************************************
12503 *
12504 * @brief Processes GNB DU config update ack
12505 *
12506 * @details
12507 *
12508 *    Function : procF1GNBDUCfgUpdAck
12509 *
12510 *    Functionality: added free part for the memory allocated by aper_decoder
12511 *
12512 * @params[in] F1AP_PDU_t *f1apMsg
12513 * @return void
12514 *
12515 * ****************************************************************/
12516 uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
12517 {
12518    uint8_t ieIdx=0,transId=0;
12519    GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
12520
12521    DU_LOG("\nINFO   -->  F1AP : GNB-DU config update acknowledgment");
12522    gnbDuAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
12523
12524    for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
12525    {
12526       switch(gnbDuAck->protocolIEs.list.array[ieIdx]->id)
12527       {
12528          case ProtocolIE_ID_id_TransactionID:
12529             {
12530                transId = gnbDuAck->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
12531                break;
12532             }
12533          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
12534             {
12535                break;
12536             }
12537          default :
12538             {
12539                DU_LOG("\nERROR  -->  F1AP: procF1GNBDUCfgUpdAck(): Invalid IE Received: %ld", \
12540                      gnbDuAck->protocolIEs.list.array[ieIdx]->id);
12541                break;
12542             }
12543       }
12544    }
12545
12546    duProcGnbDuCfgUpdAckMsg(transId);
12547
12548 #if 0
12549    /* presently we are not supporting F1 Reset from DU to CU , we are only
12550     * supporting F1 Reset from CU to DU */
12551
12552    if(BuildAndSendF1ResetReq() != ROK)
12553    {
12554       return RFAILED;
12555    }
12556 #endif
12557
12558    freeAperDecodeGnbDuAck(gnbDuAck);
12559    return ROK;
12560 }
12561 /******************************************************************
12562 *
12563 * @brief free DL RRC Message Transfer allocated by aper_decoder
12564 *
12565 * @details
12566 *
12567 *    Function : freeAperDecodef1DlRrcMsg
12568 *
12569 *    Functionality: free DL RRC Message Transfer allocated by aper_decoder
12570 *
12571 * @params[in] DLRRCMessageTransfer_t *f1DlRrcMsg
12572 * @return ROK     - success
12573 *         RFAILED - failure
12574 *
12575 * ****************************************************************/
12576
12577 void freeAperDecodef1DlRrcMsg(DLRRCMessageTransfer_t *f1DlRrcMsg)
12578 {
12579    uint8_t ieIdx =0;
12580    RRCContainer_t *rrcContainer = NULLP;
12581
12582    if(f1DlRrcMsg->protocolIEs.list.array)
12583    {
12584       for(ieIdx=0; ieIdx<f1DlRrcMsg->protocolIEs.list.count; ieIdx++)
12585       {
12586          if(f1DlRrcMsg->protocolIEs.list.array[ieIdx])
12587          {
12588             switch(f1DlRrcMsg->protocolIEs.list.array[ieIdx]->id)
12589             {
12590                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12591                   break;
12592                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12593                   break;
12594                case ProtocolIE_ID_id_SRBID:
12595                   break;
12596                case ProtocolIE_ID_id_RRCContainer:
12597                   {
12598                      rrcContainer =&f1DlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
12599                      free(rrcContainer->buf);
12600                   }
12601                case ProtocolIE_ID_id_ExecuteDuplication:
12602                   break;
12603                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
12604                   break;
12605                   break;
12606             }
12607             free(f1DlRrcMsg->protocolIEs.list.array[ieIdx]);
12608          }
12609       }
12610       free(f1DlRrcMsg->protocolIEs.list.array);
12611    }
12612 }
12613 /******************************************************************
12614  *
12615  * @brief Processes DL RRC Message Transfer  sent by CU
12616  *
12617  * @details
12618  *
12619  *    Function : procF1DlRrcMsgTrans
12620  *
12621  *    Functionality: Processes DL RRC Message Transfer sent by CU
12622  *
12623  * @params[in] F1AP_PDU_t ASN decoded F1AP message
12624  * @return ROK     - success
12625  *         RFAILED - failure
12626  *
12627  * ****************************************************************/
12628 uint8_t procF1DlRrcMsgTrans(F1AP_PDU_t *f1apMsg)
12629 {
12630    uint8_t  idx, ret;
12631    DLRRCMessageTransfer_t *f1DlRrcMsg = NULLP;
12632    F1DlRrcMsg dlMsg;
12633    memset(&dlMsg, 0, sizeof(F1DlRrcMsg));
12634
12635    DU_LOG("\nINFO   -->  DU_APP : DL RRC message transfer Recevied");
12636    f1DlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
12637
12638    ret = ROK;
12639
12640    for(idx=0; idx<f1DlRrcMsg->protocolIEs.list.count; idx++)
12641    {
12642       switch(f1DlRrcMsg->protocolIEs.list.array[idx]->id)
12643       {
12644          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12645             {
12646                dlMsg.gnbCuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
12647                break;
12648             }
12649          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12650             {
12651                dlMsg.gnbDuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
12652                break;
12653             }
12654          case ProtocolIE_ID_id_SRBID:
12655             {
12656                dlMsg.srbId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
12657                break;
12658             }
12659          case ProtocolIE_ID_id_ExecuteDuplication:
12660             dlMsg.execDup = true;
12661             break;
12662
12663          case ProtocolIE_ID_id_RRCContainer:
12664             {
12665                if(f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0)
12666                {
12667                   dlMsg.rrcMsgSize = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
12668                   DU_ALLOC_SHRABL_BUF(dlMsg.rrcMsgPdu, dlMsg.rrcMsgSize);
12669                   if(dlMsg.rrcMsgPdu)
12670                   {
12671                      memcpy(dlMsg.rrcMsgPdu, f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
12672                         dlMsg.rrcMsgSize);
12673                   }
12674                   else
12675                   {
12676                      DU_LOG("\nERROR  -->  DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
12677                      return RFAILED;
12678                   }
12679                }
12680                else
12681                {
12682                   DU_LOG("\nERROR  -->  DU_APP : RRC Container Size is invalid:%ld",\
12683                   f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
12684                   return RFAILED;
12685                }
12686                break;
12687             }
12688          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
12689             {
12690                dlMsg.deliveryStatRpt = true;
12691                break;
12692             }
12693          default:
12694             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
12695                   f1DlRrcMsg->protocolIEs.list.array[idx]->id);
12696       }
12697    }
12698
12699    ret = duProcDlRrcMsg(&dlMsg);
12700
12701    freeAperDecodef1DlRrcMsg(f1DlRrcMsg);
12702    return ret;
12703 }
12704 /*******************************************************************
12705  *
12706 * @brief Builds the DRB to be Setup Mod list
12707 *
12708 * @details
12709 *
12710 *    Function :
12711 *
12712 *    Functionality: Constructs the DRB to be Setup Mod list
12713 *
12714 * @params[in] DRBs_SetupMod_List_t *drbSet
12715 *
12716 * @return ROK     - success
12717 *         RFAILED - failure
12718 *
12719 * ****************************************************************/
12720
12721 uint8_t BuildDrbSetupModList(DRBs_SetupMod_List_t *drbSet , DuUeCfg *ueCfg)
12722 {
12723    uint8_t arrIdx =0;
12724    uint8_t drbCnt =0;
12725    struct DRBs_SetupMod_ItemIEs *drbItemIe;
12726
12727    drbCnt = ueCfg->numDrbSetupMod;
12728    drbSet->list.count = drbCnt;
12729    drbSet->list.size = drbCnt * sizeof(DRBs_SetupMod_ItemIEs_t *);
12730    DU_ALLOC(drbSet->list.array, drbSet->list.size);
12731    if(drbSet->list.array == NULLP)
12732    {
12733       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
12734       return  RFAILED;
12735    }
12736    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
12737    {
12738       DU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
12739       if(drbSet->list.array[arrIdx] == NULLP)
12740       {
12741               DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
12742               return  RFAILED;
12743       }
12744
12745       drbItemIe = (struct DRBs_SetupMod_ItemIEs *)drbSet->list.array[arrIdx];
12746       drbItemIe->id = ProtocolIE_ID_id_DRBs_SetupMod_Item;
12747       drbItemIe->criticality = Criticality_reject;
12748       drbItemIe->value.present = DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item;
12749       drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
12750       if(fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List,\
12751       &ueCfg->upTnlInfo[arrIdx])!= ROK)
12752       {
12753          DU_LOG("\nERROR  -->  F1AP : Failed to fill DlTnl SetupList in BuildDrbToBeSetupModList");
12754          return RFAILED;
12755       }
12756
12757    }
12758
12759    return ROK;
12760 }
12761 /*******************************************************************
12762 * @brief Free the memory allocated for DRB setup List
12763 *
12764 * @details
12765 *
12766 *    Function : FreeDrbSetupModList
12767 *
12768 *    Functionality:
12769 *       Free the memory allocated for DRB setup list
12770 *
12771 * @params[in] DRBs_Setup_List_t *
12772 * @return void
12773 *
12774 * ****************************************************************/
12775 void FreeDrbSetupModList(DRBs_SetupMod_List_t *drbSetupList)
12776 {
12777    uint8_t arrIdx = 0;
12778    DRBs_SetupMod_ItemIEs_t *drbItemIe = NULLP;
12779
12780    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
12781    {
12782       drbItemIe = ((DRBs_SetupMod_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
12783       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
12784       DU_FREE(drbSetupList->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
12785    }
12786    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
12787 }
12788 /*******************************************************************
12789 * @brief Free the memory allocated for UE Context Mod Response
12790 *
12791 * @details
12792 *
12793 *    Function : FreeUeContextModResp
12794 *
12795 *    Functionality:
12796 *       Free the memory allocated for UE Context Mod Response
12797 *
12798 * @params[in] F1AP_PDU_t *f1apMsg
12799 * @return void
12800 *
12801 * ****************************************************************/
12802
12803 void FreeUeContextModResp(F1AP_PDU_t *f1apMsg)
12804 {
12805    uint8_t ieIdx;
12806    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
12807    if(f1apMsg)
12808    {
12809       if(f1apMsg->choice.successfulOutcome)
12810       {
12811          ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
12812          if(ueContextModifyRes->protocolIEs.list.array)
12813          {
12814             for(ieIdx=0 ; ieIdx<ueContextModifyRes->protocolIEs.list.count; ieIdx++)
12815             {
12816                if(ueContextModifyRes->protocolIEs.list.array[ieIdx])
12817                {
12818                   switch(ueContextModifyRes->protocolIEs.list.array[ieIdx]->id)
12819                   {
12820                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12821                         break;
12822                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12823                         break;
12824                      case ProtocolIE_ID_id_DRBs_SetupMod_List:
12825                         {
12826                             FreeDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
12827                             value.choice.DRBs_SetupMod_List));
12828                             break;
12829                         }
12830                   }
12831                   DU_FREE(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
12832                }
12833
12834             }
12835             DU_FREE(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
12836          }
12837          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12838       }
12839       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12840    }
12841 }
12842
12843 /*****************************************************************i
12844 *
12845 * @brief Creating the ue context modifcation response and sending
12846 *
12847 * @details
12848 *
12849 *    Function : BuildAndSendUeContextModRsp
12850 *
12851 *    Functionality:
12852 *         - Creating the ue context modifcation response
12853 *
12854 * @params[in] uint8_t cellId,uint8_t ueIdx
12855 * @return ROK     - success
12856 *         RFAILED - failure
12857 *
12858 * ****************************************************************/
12859 uint8_t BuildAndSendUeContextModRsp(uint8_t cellId,uint8_t ueIdx)
12860 {
12861    uint8_t   ieIdx = 0;
12862    uint8_t   cellIdx =0;
12863    uint8_t   elementCnt = 0;
12864    uint8_t   ret = RFAILED;
12865    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
12866    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
12867    F1AP_PDU_t *f1apMsg = NULLP;
12868    asn_enc_rval_t         encRetVal;
12869    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
12870    DuUeCb                   *ueCb = NULLP;
12871
12872    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification response\n");
12873
12874    while(1)
12875    {
12876       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12877       if(f1apMsg == NULLP)
12878       {
12879          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
12880          break;
12881       }
12882
12883       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
12884
12885       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12886       if(f1apMsg->choice.successfulOutcome == NULLP)
12887       {
12888          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
12889          break;
12890       }
12891       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextModification;
12892       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
12893       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_UEContextModificationResponse;
12894
12895       ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
12896
12897       elementCnt = 3;
12898       ueContextModifyRes->protocolIEs.list.count = elementCnt;
12899       ueContextModifyRes->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationResponse_t*);
12900
12901       /* Initialize the UE context modification members */
12902       DU_ALLOC(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
12903       if(ueContextModifyRes->protocolIEs.list.array == NULLP)
12904       {
12905          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
12906          break;
12907       }
12908
12909       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
12910       {
12911          DU_ALLOC(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
12912          if(ueContextModifyRes->protocolIEs.list.array[ieIdx] == NULLP)
12913          {
12914             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
12915             break;
12916          }
12917       }
12918
12919       /* Fetching Ue Cb Info*/
12920       GET_CELL_IDX(cellId, cellIdx);
12921       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
12922       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
12923       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
12924
12925       ieIdx=0;
12926       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
12927       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12928       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
12929       UEContextModificationResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
12930       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
12931
12932       ieIdx++;
12933       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
12934       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12935       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present=\
12936       UEContextModificationResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
12937       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
12938
12939       ieIdx++;
12940       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_SetupMod_List;
12941       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12942       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
12943       UEContextModificationResponseIEs__value_PR_DRBs_SetupMod_List;
12944       if(ueCb->f1UeDb)
12945       {
12946          ret = BuildDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
12947                   value.choice.DRBs_SetupMod_List) , &ueCb->f1UeDb->duUeCfg);
12948          if(ret != ROK)
12949          {
12950             DU_LOG( "\nERROR  -->  F1AP : Failed to build drb setupmod List ");
12951             break;
12952          }
12953          freeF1UeDb(ueCb->f1UeDb);
12954          ueCb->f1UeDb = NULLP;
12955       }
12956       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12957
12958       /* Encode the F1SetupRequest type as APER */
12959       memset(encBuf, 0, ENC_BUF_MAX_LEN);
12960       encBufSize = 0;
12961       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,encBuf);
12962
12963       /* Encode results */
12964       if(encRetVal.encoded == ENCODE_FAIL)
12965       {
12966          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
12967                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12968          ret = RFAILED;
12969          break;
12970       }
12971       else
12972       {
12973          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Modification Response\n");
12974          for(int i=0; i< encBufSize; i++)
12975          {
12976             printf("%x",encBuf[i]);
12977          }
12978       }
12979
12980       /* Sending  msg  */
12981       if(sendF1APMsg() != ROK)
12982       {
12983          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Res Failed");
12984          ret = RFAILED;
12985          break;
12986       }
12987       break;
12988    }
12989    FreeUeContextModResp(f1apMsg);
12990    return ret;
12991 }
12992 /*******************************************************************
12993  *
12994  * @brief Deallocating the memory allocated by the aper decoder
12995  *          for QOSInfo
12996  *
12997  * @details
12998  *
12999  *    Function : freeAperDecodeQosInfo
13000  *
13001  *    Functionality:  Deallocating the memory allocated for QOSInfo
13002  *
13003  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
13004  *
13005  * @return void
13006  *
13007  * ****************************************************************/
13008
13009 void freeAperDecodeQosInfo(QoSFlowLevelQoSParameters_t *drbQos)
13010 {
13011    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
13012    {
13013       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
13014       {
13015          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
13016          {
13017             free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
13018          }
13019          free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
13020       }
13021       free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI);
13022    }
13023 }
13024 /*******************************************************************
13025  *
13026  * @brief Deallocating the memory allocated by the aper decoder
13027  *          for UlTnlInfoforDrb
13028  *
13029  * @details
13030  *
13031  *    Function : freeAperDecodeUlTnlInfoforDrbSetupMod
13032  *
13033  *    Functionality:  Deallocating memory allocated for UlTnlInfoforDrb
13034  *
13035  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
13036  *
13037  * @return void
13038  *
13039  * ****************************************************************/
13040 void freeAperDecodeUlTnlInfoforDrbSetupMod(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
13041 {
13042    uint8_t arrIdx =0;
13043
13044    if(ulInfo->list.array)
13045    {
13046       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
13047       {
13048          if(ulInfo->list.array[arrIdx])
13049          {
13050             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
13051             {
13052                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
13053                {
13054                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
13055                   {
13056                      free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
13057                            gTP_TEID.buf);
13058                   }
13059                   free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
13060                         transportLayerAddress.buf);
13061                }
13062                free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel);
13063             }
13064             free(ulInfo->list.array[arrIdx]);
13065          }
13066       }
13067       free(ulInfo->list.array);
13068    }
13069 }
13070 /*******************************************************************
13071  *
13072  * @brief Deallocating the memory allocated by the aper decoder
13073  *          for DrbSetupModItem
13074  *
13075  * @details
13076  *
13077  *    Function : freeAperDecodeDrbSetupModItem
13078  *
13079  *    Functionality:  Deallocating memory allocated for DrbSetupModItem
13080  *
13081  * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
13082  *
13083  * @return void
13084  *
13085  * ****************************************************************/
13086
13087 void freeAperDecodeDrbSetupModItem(DRBs_ToBeSetupMod_Item_t *drbItem)
13088 {
13089    uint8_t arrIdx =0;
13090    SNSSAI_t *snssai =NULLP;
13091    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
13092
13093    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
13094    switch(drbItem->qoSInformation.present)
13095    {
13096       case QoSInformation_PR_NOTHING:
13097          break;
13098       case QoSInformation_PR_eUTRANQoS:
13099          {
13100             if(drbItem->qoSInformation.choice.eUTRANQoS)
13101             {
13102                free(drbItem->qoSInformation.choice.eUTRANQoS);
13103             }
13104             break;
13105          }
13106       case QoSInformation_PR_choice_extension:
13107          {
13108             if(drbItem->qoSInformation.choice.choice_extension)
13109             {
13110                freeAperDecodeQosInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.\
13111                      DRB_Information.dRB_QoS);
13112                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
13113                if(snssai->sST.buf)
13114                {
13115                   free(snssai->sST.buf);
13116                }
13117                if(snssai->sD)
13118                {
13119                   if(snssai->sD->buf)
13120                   {
13121                      free(snssai->sD->buf);
13122                   }
13123                   free(snssai->sD);
13124                }
13125
13126                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.\
13127                          DRB_Information.flows_Mapped_To_DRB_List;
13128                if(flowMap->list.array)
13129                {
13130                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
13131                   {
13132                      if(flowMap->list.array[arrIdx] )
13133                      {
13134                         freeAperDecodeQosInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
13135                         free(flowMap->list.array[arrIdx]);
13136                      }
13137                   }
13138                   free(flowMap->list.array);
13139                }
13140
13141                free(drbItem->qoSInformation.choice.choice_extension);
13142             }
13143             break;
13144          }
13145
13146    }
13147    freeAperDecodeUlTnlInfoforDrbSetupMod(&drbItem->uLUPTNLInformation_ToBeSetup_List);
13148    if(drbItem->uLConfiguration)
13149    {
13150       free(drbItem->uLConfiguration);
13151    }
13152 }
13153
13154 /*******************************************************************
13155  *
13156  * @brief Deallocating the memory allocated by the aper decoder
13157  *          for DrbToBeSetupModList
13158  *
13159  * @details
13160  *
13161  *    Function : freeAperDecodeDrbToBeSetupModList
13162  *
13163  *    Functionality:  Deallocating memory allocated for DrbToBeSetupModList
13164  *
13165  * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
13166  *
13167  * @return void
13168  *
13169  * ****************************************************************/
13170
13171 void freeAperDecodeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
13172 {
13173    uint8_t arrIdx =0;
13174    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
13175
13176    if(drbSet->list.array)
13177    {
13178       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
13179       {
13180          if(drbSet->list.array[arrIdx] != NULLP)
13181          {
13182             if(arrIdx == 0)
13183             {
13184                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
13185                freeAperDecodeDrbSetupModItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
13186             }
13187             free(drbSet->list.array[arrIdx]);
13188          }
13189       }
13190       free(drbSet->list.array);
13191    }
13192
13193 }
13194 /*******************************************************************
13195  *
13196  * @brief Deallocating the memory allocated by the aper decoder
13197  *          for UeContextModificationReqMsg
13198  *
13199  * @details
13200  *
13201  *    Function : freeAperDecodeUeContextModificationReqMsg
13202  *
13203  *    Functionality:  Deallocating memory allocated for
13204  *                  UeContextModificationReqMsg
13205  *
13206  * @params[in] UEContextModificationRequest_t *UeContextModifyReq
13207  *
13208  * @return void
13209  *
13210  * ****************************************************************/
13211 void freeAperDecodeUeContextModificationReqMsg(UEContextModificationRequest_t *UeContextModifyReq )
13212 {
13213    uint8_t arrIdx, ieId;
13214
13215    if(UeContextModifyReq->protocolIEs.list.array)
13216    {
13217       for( arrIdx = 0 ; arrIdx<UeContextModifyReq->protocolIEs.list.count ; arrIdx++)
13218       {
13219          if(UeContextModifyReq->protocolIEs.list.array[arrIdx])
13220          {
13221             ieId = UeContextModifyReq->protocolIEs.list.array[arrIdx]->id;
13222             switch(ieId)
13223             {
13224                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13225                   break;
13226                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13227                   break;
13228                case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
13229                   {
13230                      freeAperDecodeDrbToBeSetupModList(&UeContextModifyReq->protocolIEs.list.array[arrIdx]->\
13231                            value.choice.DRBs_ToBeSetupMod_List);
13232                      break;
13233                   }
13234             }
13235             free(UeContextModifyReq->protocolIEs.list.array[arrIdx]);
13236          }
13237       }
13238       free(UeContextModifyReq->protocolIEs.list.array);
13239    }
13240 }
13241 /*******************************************************************
13242  *
13243  * @brief processing the F1 UeContextModificationReq
13244  *
13245  * @details
13246  *
13247  *    Function : procF1UeContextModificationReq
13248  *
13249  *    Functionality:  processing the F1 UeContextModificationReq
13250  *
13251  * @params[in] F1AP_PDU_t *f1apMsg
13252  *
13253  * @return
13254  * ****************************************************************/
13255 uint8_t procF1UeContextModificationReq(F1AP_PDU_t *f1apMsg)
13256 {
13257    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
13258    uint8_t  ret = ROK, ieIdx = 0, cellIdx=0, ueIdx=0;
13259    DuUeCb   *duUeCb = NULLP;
13260    DRBs_ToBeSetupMod_List_t *drbSetupModCfg;
13261    DRBs_ToBeModified_List_t *drbModifiedCfg;
13262    uint32_t gnbCuUeF1apId, gnbDuUeF1apId;
13263
13264    ueContextModifyReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
13265    for(ieIdx=0; (ieIdx < ueContextModifyReq->protocolIEs.list.count && ret == ROK); ieIdx++)
13266    {
13267       switch(ueContextModifyReq->protocolIEs.list.array[ieIdx]->id)
13268       {
13269          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13270             {
13271                gnbCuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
13272                break;
13273             }
13274          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13275             {
13276                gnbDuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
13277                break;
13278             }
13279          case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
13280          case ProtocolIE_ID_id_DRBs_ToBeModified_List:
13281             {
13282                for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
13283                {
13284                   for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
13285                   {
13286                      if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
13287                            (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
13288                      {
13289
13290                         duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
13291                         if(duUeCb->f1UeDb == NULLP)
13292                         {
13293                            DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
13294                         }
13295                         if(duUeCb->f1UeDb)
13296                         {
13297                            duUeCb->f1UeDb->actionType = UE_CTXT_MOD;
13298                            if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present ==\
13299                                  UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List)
13300                            {
13301                               drbSetupModCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
13302                               choice.DRBs_ToBeSetupMod_List;
13303
13304                               if(extractDrbListToSetupMod(NULL, drbSetupModCfg, NULL, drbSetupModCfg->list.count,\
13305                               &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, NULL))
13306                               {
13307                                  DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbSetupModList");
13308                                  ret = RFAILED;
13309                               }
13310                            }
13311
13312                            if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present == \
13313                                   UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List)
13314
13315                            {
13316                               drbModifiedCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
13317                               choice.DRBs_ToBeModified_List;
13318                               if(extractDrbListToSetupMod(NULL, NULL, drbModifiedCfg, drbModifiedCfg->list.count,\
13319                                  &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, &duUeCb->rlcUeCfg))
13320                               {
13321                                  DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbModifiedList");
13322                                  ret = RFAILED;
13323                               }
13324                            }
13325                         }
13326                         break;
13327                      }
13328                   }
13329                   if(ueIdx >= duCb.actvCellLst[cellIdx]->numActvUes)
13330                   {
13331                      DU_LOG("\nERROR  -->  DU APP : wrong values of gnbCuUeF1apId and gnbDuUeF1apId ");
13332                      ret = RFAILED;
13333                   }
13334                }
13335                break;
13336             }
13337       }
13338    }
13339    if(ret != RFAILED)
13340    {
13341       ret = duProcUeContextModReq(duUeCb);
13342    }
13343    freeAperDecodeUeContextModificationReqMsg(ueContextModifyReq);
13344    return ret;
13345 }
13346 /*****************************************************************i
13347 *
13348 * @brief Free memory allocated for UE Context Release Request
13349 *
13350 * @details
13351 *
13352 *    Function : FreeUeContextReleaseReq
13353 *
13354 *    Functionality:
13355 *         - Free memory allocated for UE Context Release Request
13356 *
13357 * @params[in] F1AP_PDU_t *f1apMsg
13358 * @return void
13359 *
13360 * *************************************************************/
13361 void FreeUeContextReleaseReq(F1AP_PDU_t *f1apMsg)
13362 {
13363    uint8_t ieIdx;
13364    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
13365
13366    if(f1apMsg)
13367    {
13368       if(f1apMsg->choice.initiatingMessage)
13369       {
13370          ueReleaseReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
13371          if(ueReleaseReq->protocolIEs.list.array)
13372          {
13373             for(ieIdx=0 ; ieIdx<ueReleaseReq->protocolIEs.list.count; ieIdx++)
13374             {
13375                DU_FREE(ueReleaseReq->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseRequest_t));
13376             }
13377             DU_FREE(ueReleaseReq->protocolIEs.list.array, ueReleaseReq->protocolIEs.list.size);
13378          }
13379          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
13380       }
13381       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
13382    }
13383
13384 }
13385 /*****************************************************************i
13386 *
13387 * @brief Build and Send UE Context Release Request
13388 *
13389 * @details
13390 *
13391 *    Function : BuildAndSendUeContextReleaseReq
13392 *
13393 *    Functionality:
13394 *         - Build and Send UE Context Release Request
13395 *
13396 * @params[in]
13397 * @return ROK     - success
13398 *         RFAILED - failure
13399 *
13400 * *************************************************************/
13401 uint8_t BuildAndSendUeContextReleaseReq(uint16_t cellId, uint8_t ueIdx)
13402 {
13403    bool memAllocFail = false;
13404    uint8_t ieIdx =0;
13405    uint8_t ret = RFAILED;
13406    uint16_t cellIdx =0;
13407    uint16_t crnti = 0;
13408    uint8_t  elementCnt = 0;
13409    uint32_t  gnbCuUeF1apId =0;   /* gNB-CU UE F1AP Id */
13410    uint32_t  gnbDuUeF1apId =0;   /* gNB-DU UE F1AP Id */
13411    asn_enc_rval_t encRetVal;
13412    F1AP_PDU_t *f1apMsg = NULLP;
13413    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
13414
13415    DU_LOG("\nINFO  --> Building the UE Context Release Request");
13416    do
13417    {
13418       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
13419       if(f1apMsg == NULLP)
13420       {
13421          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for f1apMsg");
13422          break;
13423       }
13424
13425       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
13426       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
13427       if(f1apMsg->choice.initiatingMessage == NULLP)
13428       {
13429          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for\
13430          initiatingMessage");
13431          break;
13432       }
13433       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextReleaseRequest;
13434       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
13435       f1apMsg->choice.initiatingMessage->value.present = \
13436       InitiatingMessage__value_PR_UEContextReleaseRequest;
13437
13438       ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
13439
13440       elementCnt = 2;
13441
13442       ueReleaseReq->protocolIEs.list.count = elementCnt;
13443       ueReleaseReq->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseRequest_t *);
13444
13445       /* Initialize the F1Setup members */
13446       DU_ALLOC(ueReleaseReq->protocolIEs.list.array,ueReleaseReq->protocolIEs.list.size);
13447       if(ueReleaseReq->protocolIEs.list.array == NULLP)
13448       {
13449          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE array");
13450          break;
13451       }
13452       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
13453       {
13454          DU_ALLOC(ueReleaseReq->protocolIEs.list.array[ieIdx],\
13455                sizeof(UEContextReleaseRequest_t));
13456          if(ueReleaseReq->protocolIEs.list.array[ieIdx] == NULLP)
13457          {
13458             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE elements");
13459             memAllocFail = true;
13460             break;
13461          }
13462       }
13463       if(memAllocFail == true)
13464          break;
13465
13466       /* Fetching Ue Cb Info*/
13467       GET_CELL_IDX(cellId, cellIdx);
13468       if(duCb.actvCellLst[cellIdx] == NULLP)
13469       {
13470          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): CellId[%d] does not exist", cellId);
13471          break;
13472       }
13473       else
13474       {
13475          GET_CRNTI(crnti, ueIdx);
13476          if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].crnti != crnti)
13477          {
13478             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): crnti[%d] does not exist", crnti);
13479             break;
13480          }
13481          gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
13482          gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
13483       }
13484
13485       ieIdx=0;
13486       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
13487       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13488       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present = \
13489       UEContextReleaseRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
13490       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
13491
13492       ieIdx++;
13493       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
13494       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13495       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present =\
13496       UEContextReleaseRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
13497       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
13498
13499       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13500
13501       /* Encode the F1SetupRequest type as APER */
13502       memset(encBuf, 0, ENC_BUF_MAX_LEN);
13503       encBufSize = 0;
13504       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
13505       /* Encode results */
13506       if(encRetVal.encoded == ENCODE_FAIL)
13507       {
13508          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseRequest structure (at %s)\n",\
13509                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13510          break;
13511       }
13512       else
13513       {
13514          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseRequest\n");
13515          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
13516          {
13517             printf("%x",encBuf[ieIdx]);
13518          }
13519       }
13520
13521       /* Sending msg */
13522       if(sendF1APMsg() != ROK)
13523       {
13524          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Request failed");
13525          break;
13526       }
13527       ret = ROK;
13528       break;
13529    }while(true);
13530
13531    FreeUeContextReleaseReq(f1apMsg);
13532    return ret;
13533 }
13534 /*****************************************************************i
13535  *
13536  * @brief Free memory allocated for UE Context Release Complete
13537  *
13538  * @details
13539  *
13540  *    Function : FreeUeContextReleaseComplete
13541  *
13542  *    Functionality:
13543  *         - Free memory allocated for UE Context Release Complete
13544  *
13545  * @params[in] F1AP_PDU_t *f1apMsg
13546  * @return void
13547  *
13548  * *************************************************************/
13549 void FreeUeContextReleaseComplete(F1AP_PDU_t *f1apMsg)
13550 {
13551    uint8_t ieIdx;
13552    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
13553
13554    if(f1apMsg)
13555    {
13556       if(f1apMsg->choice.successfulOutcome)
13557       {
13558          ueReleaseComplete =&f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
13559          if(ueReleaseComplete->protocolIEs.list.array)
13560          {
13561             for(ieIdx=0 ; ieIdx<ueReleaseComplete->protocolIEs.list.count; ieIdx++)
13562             {
13563                DU_FREE(ueReleaseComplete->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseComplete_t));
13564             }
13565             DU_FREE(ueReleaseComplete->protocolIEs.list.array, ueReleaseComplete->protocolIEs.list.size);
13566          }
13567          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
13568       }
13569       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
13570    }
13571
13572 }
13573 /*****************************************************************i
13574  *
13575  * @brief Build and Send UE Context Release Complete
13576  *
13577  * @details
13578  *
13579  *    Function : BuildAndSendUeContextReleaseComplete
13580  *
13581  *    Functionality:
13582  *         - Build and Send UE Context Release Complete
13583  *
13584  * @params[in]  cellId,  gnbCuUeF1apId, gnbDuUeF1apId
13585  * @return ROK     - success
13586  *         RFAILED - failure
13587  *
13588  * *************************************************************/
13589 uint8_t BuildAndSendUeContextReleaseComplete(uint16_t cellId, uint32_t gnbCuUeF1apId, uint32_t gnbDuUeF1apId)
13590 {
13591    bool memAllocFail = false;
13592    uint8_t ieIdx =0, ret = RFAILED, elementCnt = 0;
13593    asn_enc_rval_t encRetVal;
13594    F1AP_PDU_t *f1apMsg = NULLP;
13595    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
13596
13597    DU_LOG("\nINFO  --> Building the UE Context Release Complete");
13598    do
13599    {
13600       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
13601       if(f1apMsg == NULLP)
13602       {
13603          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for f1apMsg");
13604          break;
13605       }
13606
13607       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
13608       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
13609       if(f1apMsg->choice.successfulOutcome == NULLP)
13610       {
13611          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for\
13612                successfulOutcome");
13613          break;
13614       }
13615       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextRelease;
13616       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
13617       f1apMsg->choice.successfulOutcome->value.present = \
13618       SuccessfulOutcome__value_PR_UEContextReleaseComplete;
13619
13620       ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
13621
13622       elementCnt = 2;
13623       ueReleaseComplete->protocolIEs.list.count = elementCnt;
13624       ueReleaseComplete->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseComplete_t *);
13625
13626       /* Initialize the UE Release Complete members */
13627       DU_ALLOC(ueReleaseComplete->protocolIEs.list.array,ueReleaseComplete->protocolIEs.list.size);
13628       if(ueReleaseComplete->protocolIEs.list.array == NULLP)
13629       {
13630          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE array");
13631          break;
13632       }
13633       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
13634       {
13635          DU_ALLOC(ueReleaseComplete->protocolIEs.list.array[ieIdx],\
13636                sizeof(UEContextReleaseComplete_t));
13637          if(ueReleaseComplete->protocolIEs.list.array[ieIdx] == NULLP)
13638          {
13639             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE\
13640             elements");
13641             memAllocFail = true;
13642             break;
13643          }
13644       }
13645       if(memAllocFail == true)
13646          break;
13647
13648
13649       ieIdx=0;
13650       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
13651       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13652       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present = \
13653       UEContextReleaseCompleteIEs__value_PR_GNB_CU_UE_F1AP_ID;
13654       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
13655
13656       ieIdx++;
13657       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
13658       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13659       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present =\
13660       UEContextReleaseCompleteIEs__value_PR_GNB_DU_UE_F1AP_ID;
13661       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
13662
13663       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13664
13665       /* Encode the F1SetupComplete type as APER */
13666       memset(encBuf, 0, ENC_BUF_MAX_LEN);
13667       encBufSize = 0;
13668       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
13669       /* Encode results */
13670       if(encRetVal.encoded == ENCODE_FAIL)
13671       {
13672          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseComplete structure (at %s)\n",\
13673                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13674          break;
13675       }
13676       else
13677       {
13678          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseComplete\n");
13679          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
13680          {
13681             printf("%x",encBuf[ieIdx]);
13682          }
13683       }
13684
13685       /* Sending msg */
13686       if(sendF1APMsg() != ROK)
13687       {
13688          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Complete failed");
13689          break;
13690       }
13691       ret = ROK;
13692       break;
13693    }while(true);
13694
13695    if(ret == ROK && (duCb.actvCellLst[cellId-1]->numActvUes == 0))
13696    {
13697       duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
13698       ret = duSendCellDeletReq(cellId);
13699       if(ret != ROK)
13700       {
13701          DU_LOG("\nERROR  -->  F1AP: BuildAndSendUeContextReleaseComplete(): Failed to process cell\
13702                Delete req for CellId");
13703       }
13704    }
13705    FreeUeContextReleaseComplete(f1apMsg);
13706    return ret;
13707
13708 }
13709
13710 /*******************************************************************
13711 *
13712 * @brief added free part for the memory allocated by aper_decoder
13713 *
13714 * @details
13715 *
13716 *    Function : freeAperDecodeUeContextReleaseCommand
13717 *
13718 *    Functionality: added free part for the memory allocated by aper_decoder
13719 *
13720 * @params[in] F1AP_PDU_t *f1apMsg
13721 * @return void
13722 *
13723 * ****************************************************************/
13724 void freeAperDecodeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
13725 {
13726    uint8_t ieIdx=0;
13727    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
13728
13729    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
13730
13731    if(ueContextReleaseCommand->protocolIEs.list.array)
13732    {
13733       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
13734       {
13735          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
13736          {
13737             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
13738             {
13739                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13740                   break;
13741                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13742                   break;
13743                case ProtocolIE_ID_id_Cause:
13744                   break;
13745                case ProtocolIE_ID_id_RRCContainer:
13746                {
13747                   if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
13748                   {
13749                      free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
13750                   }
13751                   break;
13752                }
13753                default :
13754                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
13755                        ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
13756                   break;
13757             }
13758          }
13759          free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]);
13760       }
13761       free(ueContextReleaseCommand->protocolIEs.list.array);
13762    }
13763 }
13764 /*******************************************************************
13765 *
13766 * @brief processing of UE Context Release Command
13767 *
13768 * @details
13769 *
13770 *    Function : procF1UeContextReleaseCommand
13771 *
13772 *    Functionality: processing of UE Context Release Command
13773 *
13774 * @params[in] F1AP_PDU_t *f1apMsg
13775 * @return void
13776 *
13777 * ****************************************************************/
13778 uint8_t procF1UeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
13779 {
13780    uint8_t  ieIdx=0, ret=ROK, ueIdx=0;
13781    uint16_t cellIdx =0;
13782    bool ueIdxFound;
13783    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0;
13784    DuUeCb   *duUeCb = NULLP;
13785    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
13786
13787    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
13788
13789    if(ueContextReleaseCommand->protocolIEs.list.array)
13790    {
13791       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
13792       {
13793          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
13794          {
13795             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
13796             {
13797                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13798                   {
13799                      gnbCuUeF1apId= ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13800                                     value.choice.GNB_CU_UE_F1AP_ID;
13801                      break;
13802                   }
13803
13804                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13805                   {
13806                      gnbDuUeF1apId = ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13807                                      value.choice.GNB_DU_UE_F1AP_ID;
13808                      break;
13809                   }
13810
13811                case ProtocolIE_ID_id_Cause:
13812                   {
13813                      break;
13814                   }
13815
13816                case ProtocolIE_ID_id_RRCContainer:
13817                   {
13818                      for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
13819                      {
13820                         for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
13821                         {
13822                            if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
13823                                  (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
13824                            {
13825                               duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
13826                               DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
13827                               if(duUeCb->f1UeDb)
13828                               {
13829                                  memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
13830                                  duUeCb->f1UeDb->actionType = UE_CTXT_RELEASE;
13831                                  duUeCb->f1UeDb->cellIdx = cellIdx;
13832                                  /* Filling Dl RRC Msg Info */
13833                                  DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
13834                                  if(!duUeCb->f1UeDb->dlRrcMsg)
13835                                  {
13836                                     DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
13837                                     Memory allocation failed ");
13838                                     ret = RFAILED;
13839                                  }
13840                                  else
13841                                  {
13842                                     duUeCb->f1UeDb->dlRrcMsgPres = true;
13843                                     memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
13844                                     ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
13845                                           &ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13846                                           value.choice.RRCContainer);
13847                                  }
13848
13849                               }
13850                               else
13851                               {
13852                                  DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
13853                                  Memory allocation failed ");
13854                                  ret = RFAILED;
13855
13856                               }
13857
13858                               ueIdxFound = true;
13859                               break;
13860                            }
13861                         }
13862                         if(ueIdxFound == true)
13863                         {
13864                            break;
13865                         }
13866                      }
13867                      if(!ueIdxFound)
13868                      {
13869                         DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextReleaseCommand()");
13870                         ret = RFAILED;
13871                      }
13872
13873
13874                      break;
13875                   }
13876                default :
13877                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
13878                         ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
13879                   break;
13880             }
13881          }
13882       }
13883    }
13884    if(ret != RFAILED)
13885    {
13886       duProcUeContextReleaseCommand(duUeCb);
13887    }
13888    freeAperDecodeUeContextReleaseCommand(f1apMsg);
13889    return ret;
13890 }
13891 /**************************************************************
13892  *
13893  * @brief Handles received F1AP message and sends back response
13894  *
13895  * @details
13896  *
13897  *    Function : F1APMsgHdlr
13898  *
13899  *    Functionality:
13900  *         - Decodes received F1AP control message
13901  *         - Prepares response message, encodes and sends to SCTP
13902  *
13903  * @params[in]
13904  * @return ROK     - success
13905  *         RFAILED - failure
13906  *
13907  * ****************************************************************/
13908 void F1APMsgHdlr(Buffer *mBuf)
13909 {
13910    int i =0;
13911    char *recvBuf =NULLP;
13912    MsgLen copyCnt =0;
13913    MsgLen recvBufLen =0;
13914    F1AP_PDU_t *f1apMsg =NULLP;
13915    asn_dec_rval_t rval; /* Decoder return value */
13916    F1AP_PDU_t f1apasnmsg ;
13917    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
13918    ODU_PRINT_MSG(mBuf, 0,0);
13919
13920    /* Copy mBuf into char array to decode it */
13921    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
13922    DU_ALLOC(recvBuf, (Size)recvBufLen);
13923
13924    if(recvBuf == NULLP)
13925    {
13926       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
13927       return;
13928    }
13929    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
13930    {
13931       DU_LOG("\nERROR   -->  F1AP : Failed while copying %d", copyCnt);
13932       return;
13933    }
13934
13935    printf("\nDEBUG   -->  F1AP : Received flat buffer to be decoded : ");
13936    for(i=0; i< recvBufLen; i++)
13937    {
13938       printf("%x",recvBuf[i]);
13939    }
13940
13941    /* Decoding flat buffer into F1AP messsage */
13942    f1apMsg = &f1apasnmsg;
13943    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
13944
13945    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
13946    DU_FREE(recvBuf, (Size)recvBufLen);
13947
13948    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
13949    {
13950       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
13951       return;
13952    }
13953    printf("\n");
13954    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13955
13956    switch(f1apMsg->present)
13957    {
13958       case F1AP_PDU_PR_successfulOutcome:
13959          {
13960             switch(f1apMsg->choice.successfulOutcome->value.present)
13961             {
13962                case SuccessfulOutcome__value_PR_ResetAcknowledge:
13963                   {
13964                      DU_LOG("\nINFO   -->  F1AP : F1ResetAcknowledge is received successfully ");
13965                      break;
13966                   }
13967                case SuccessfulOutcome__value_PR_F1SetupResponse:
13968                   {
13969 #ifndef ODU_TEST_STUB
13970                      procF1SetupRsp(f1apMsg);
13971 #endif
13972                      break;
13973                   }
13974
13975                case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
13976                   {
13977                      procF1GNBDUCfgUpdAck(f1apMsg);
13978                      break;
13979                   }
13980
13981                default:
13982                   {
13983                      DU_LOG("\nERROR  -->  F1AP : Invalid type of SuccessfulOutcome__value_PR_ResetAcknowledge [%d]",\
13984                            f1apMsg->choice.successfulOutcome->value.present);
13985                      return;
13986                   }
13987             }/* End of switch(successfulOutcome) */
13988             free(f1apMsg->choice.successfulOutcome);
13989             break;
13990          }
13991       case F1AP_PDU_PR_initiatingMessage:
13992          {
13993             switch(f1apMsg->choice.initiatingMessage->value.present)
13994             {
13995                case InitiatingMessage__value_PR_Reset:
13996                   {
13997                      procF1ResetReq(f1apMsg);
13998                      break;
13999                   }
14000                case InitiatingMessage__value_PR_DLRRCMessageTransfer:
14001                   {
14002                      procF1DlRrcMsgTrans(f1apMsg);
14003                      break;
14004                   }
14005                case InitiatingMessage__value_PR_UEContextSetupRequest:
14006                   {
14007                      procF1UeContextSetupReq(f1apMsg);
14008                      break;
14009                   }
14010                case InitiatingMessage__value_PR_UEContextModificationRequest:
14011                   {
14012                      procF1UeContextModificationReq(f1apMsg);
14013                      break;
14014                   }
14015                case InitiatingMessage__value_PR_UEContextReleaseCommand:
14016                   {
14017                       procF1UeContextReleaseCommand(f1apMsg);
14018                       break;
14019                   }
14020                default:
14021                   {
14022                      DU_LOG("\nERROR  -->  F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
14023                            f1apMsg->choice.initiatingMessage->value.present);
14024                      return;
14025                   }
14026             }/* End of switch(initiatingMessage) */
14027             free(f1apMsg->choice.initiatingMessage);
14028             break;
14029          }
14030
14031       default:
14032          {
14033             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
14034             return;
14035          }
14036          free(f1apMsg);
14037
14038    }/* End of switch(f1apMsg->present) */
14039
14040 } /* End of F1APMsgHdlr */
14041
14042 /**********************************************************************
14043   End of file
14044  **********************************************************************/