src/du_app/du_f1ap_msg_hdl.c

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   4 #                                                                              #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
   6 #   you may not use this file except in compliance with the License.           #
   7 #   You may obtain a copy of the License at                                    #
   8 #                                                                              #
   9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10 #                                                                              #
  11 #   Unless required by applicable law or agreed to in writing, software        #
  12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
  14 #   See the License for the specific language governing permissions and        #
  15 #   limitations under the License.                                             #
  16 ################################################################################
  17 *******************************************************************************/
  18
  19 /* This file contains F1AP message handler functions */
  20 #include "common_def.h"
  21 #include "lrg.h"
  22 #include "legtp.h"
  23 #include "lkw.x"
  24 #include "lrg.x"
  25 #include "F1AP-PDU.h"
  26 #include "du_app_mac_inf.h"
  27 #include "du_cfg.h"
  28 #include "du_app_rlc_inf.h"
  29 #include "du_mgr_main.h"
  30 #include "du_utils.h"
  31 #include "RAT-Type.h"
  32 #include "FeatureSetUplinkPerCC.h"
  33 #include "FeatureSetDownlinkPerCC.h"
  34 #include "FeatureSets.h"
  35 #include "UE-NR-Capability.h"
  36 #include "UE-CapabilityRAT-Container.h"
  37 #include "UE-CapabilityRAT-ContainerListRRC.h"
  38 #include "GNB-DU-System-Information.h"
  39 #include "CellGroupConfigRrc.h"
  40 #include "MAC-CellGroupConfig.h"
  41 #include "SchedulingRequestConfig.h"
  42 #include "SchedulingRequestToAddMod.h"
  43 #include "BSR-Config.h"
  44 #include "TAG-Config.h"
  45 #include "TAG.h"
  46 #include "PHR-Config.h"
  47 #include "RLC-Config.h"
  48 #include "UL-AM-RLC.h"
  49 #include "DL-AM-RLC.h"
  50 #include "LogicalChannelConfig.h"
  51 #include "RLC-BearerConfig.h"
  52 #include "PhysicalCellGroupConfig.h"
  53 #include "SpCellConfig.h"
  54 #include "TDD-UL-DL-ConfigDedicated.h"
  55 #include "ServingCellConfig.h"
  56 #include "ControlResourceSet.h"
  57 #include "SearchSpace.h"
  58 #include "PDCCH-Config.h"
  59 #include "PDSCH-TimeDomainResourceAllocation.h"
  60 #include "PDSCH-TimeDomainResourceAllocationList.h"
  61 #include "PDSCH-CodeBlockGroupTransmission.h"
  62 #include "PDSCH-ServingCellConfig.h"
  63 #include "DMRS-DownlinkConfig.h"
  64 #include "PDSCH-Config.h"
  65 #include "BWP-DownlinkDedicated.h"
  66 #include "PUSCH-TimeDomainResourceAllocation.h"
  67 #include "PUSCH-TimeDomainResourceAllocationList.h"
  68 #include "DMRS-UplinkConfig.h"
  69 #include "PUSCH-Config.h"
  70 #include "SRS-ResourceId.h"
  71 #include "SRS-Resource.h"
  72 #include "SRS-ResourceSet.h"
  73 #include "SRS-Config.h"
  74 #include "BWP-UplinkDedicated.h"
  75 #include "PUSCH-ServingCellConfig.h"
  76 #include "UplinkConfig.h"
  77 #include "DUtoCURRCContainer.h"
  78 #include "GBR-QoSFlowInformation.h"
  79 #include "QoSFlowLevelQoSParameters.h"
  80 #include "PUCCH-Config.h"
  81 #include "PUCCH-ResourceSet.h"
  82 #include "PUCCH-Resource.h"
  83 #include "PUCCH-PowerControl.h"
  84 #include "P0-PUCCH.h"
  85 #include "PUCCH-PathlossReferenceRS.h"
  86 #include "PUCCH-format0.h"
  87 #include "PUCCH-format1.h"
  88 #include "PUCCH-format2.h"
  89 #include "PUCCH-format3.h"
  90 #include "PUCCH-format4.h"
  91 #include "PUCCH-FormatConfig.h"
  92 #include "SchedulingRequestResourceConfig.h"
  93 #include<ProtocolIE-Field.h>
  94 #include "ProtocolExtensionField.h"
  95 #include "odu_common_codec.h"
  96 #include "du_mgr.h"
  97 #include "du_cell_mgr.h"
  98 #include "du_f1ap_msg_hdl.h"
  99 #include "DRBs-Setup-Item.h"
 100 #include "DLUPTNLInformation-ToBeSetup-List.h"
 101 #include "DLUPTNLInformation-ToBeSetup-Item.h"
 102 #include "UPTransportLayerInformation.h"
 103 #include "GTPTunnel.h"
 104
 105 #ifdef O1_ENABLE
 106 #include "ConfigInterface.h"
 107 extern StartupConfig g_cfg;
 108 #endif
 109
 110 DuCfgParams duCfgParam;
 111
 112 /************************************************************************
 113  *
 114  * @brief Converts enum values into actual value of Poll retransmit timer
 115  *
 116  * @details
 117  *
 118  *    Function : getPollPdu
 119  *
 120  *    Functionality: Converts enum values into actual value of poll
 121  *    retransmit timer
 122  *
 123  * @params[in] Enum value of pollPdu
 124  * @return Actual value of pollPdu
 125  *
 126  * **********************************************************************/
 127
 128 uint16_t getPollRetxTmr(uint8_t pollRetxTmrCfg)
 129 {
 130    uint16_t pollRetxTmr;
 131
 132    /* All values of poll retx timer are at interval of 5ms.
 133     * This is valid upto 250ms
 134     * Hence converting the enum value to actual value by multiplying it to 5
 135     */
 136    if(pollRetxTmrCfg <= T_PollRetransmit_ms250)
 137       pollRetxTmr = (pollRetxTmrCfg + 1) * 5;
 138    else
 139    {
 140       switch(pollRetxTmrCfg)
 141       {
 142          case T_PollRetransmit_ms300:
 143             pollRetxTmr = 300;
 144             break;
 145          case T_PollRetransmit_ms350:
 146             pollRetxTmr = 350;
 147             break;
 148          case T_PollRetransmit_ms400:
 149             pollRetxTmr = 400;
 150             break;
 151          case T_PollRetransmit_ms450:
 152             pollRetxTmr = 450;
 153             break;
 154          case T_PollRetransmit_ms500:
 155             pollRetxTmr = 500;
 156             break;
 157          case T_PollRetransmit_ms800:
 158             pollRetxTmr = 800;
 159             break;
 160          default:
 161             DU_LOG("\nERROR  -->  F1AP: Invalid value of Poll Retransmit timer");
 162             pollRetxTmr = 0;
 163       }
 164    }
 165    return pollRetxTmr;
 166 }
 167
 168 /*******************************************************************
 169  *
 170  * @brief Converts enum values into actual value of PollPdu
 171  *
 172  * @details
 173  *
 174  *    Function : getPollPdu
 175  *
 176  *    Functionality: Converts enum values into actual value of PollPdu
 177  *
 178  * @params[in] Enum value of pollPdu
 179  * @return Actual value of pollPdu
 180  *
 181  * ****************************************************************/
 182 int32_t getPollPdu(uint8_t pollPduCfg)
 183 {
 184    int32_t pollPdu;
 185    switch(pollPduCfg)
 186    {
 187       case PollPDU_p4:
 188          pollPdu = 4;
 189          break;
 190       case PollPDU_p8:
 191          pollPdu = 8;
 192          break;
 193       case PollPDU_p16:
 194          pollPdu = 16;
 195          break;
 196       case PollPDU_p32:
 197          pollPdu = 32;
 198          break;
 199       case PollPDU_p64:
 200          pollPdu = 64;
 201          break;
 202       case PollPDU_p128:
 203          pollPdu = 128;
 204          break;
 205       case PollPDU_p256:
 206          pollPdu = 256;
 207          break;
 208       case PollPDU_p512:
 209          pollPdu = 512;
 210          break;
 211       case PollPDU_p1024:
 212          pollPdu = 1024;
 213          break;
 214       case PollPDU_p2048:
 215          pollPdu = 2048;
 216          break;
 217       case PollPDU_p4096:
 218          pollPdu = 4096;
 219          break;
 220       case PollPDU_p6144:
 221          pollPdu = 6144;
 222          break;
 223       case PollPDU_p8192:
 224          pollPdu = 8192;
 225          break;
 226       case PollPDU_p12288:
 227          pollPdu = 12288;
 228          break;
 229       case PollPDU_p16384:
 230          pollPdu = 16384;
 231          break;
 232       case PollPDU_p20480:
 233          pollPdu = 20480;
 234          break;
 235       case PollPDU_p24576:
 236          pollPdu = 24576;
 237          break;
 238       case PollPDU_p28672:
 239          pollPdu = 28672;
 240          break;
 241       case PollPDU_p32768:
 242          pollPdu = 32768;
 243          break;
 244       case PollPDU_p40960:
 245          pollPdu = 40960;
 246          break;
 247       case PollPDU_p49152:
 248          pollPdu = 49152;
 249          break;
 250       case PollPDU_p57344:
 251          pollPdu = 57344;
 252          break;
 253       case PollPDU_p65536:
 254          pollPdu = 65536;
 255          break;
 256       case PollPDU_infinity:
 257          pollPdu = -1;
 258          break;
 259       default:
 260          DU_LOG("\nERROR  -->  F1AP: Invalid value of poll pdu");
 261          pollPdu = 0;
 262          break;
 263    }
 264    return pollPdu;
 265 }
 266
 267 /*******************************************************************
 268  *
 269  * @brief Converts enum values into actual value of poll bytes
 270  *
 271  * @details
 272  *
 273  *    Function : getPollByte
 274  *
 275  *    Functionality: Converts enum values into actual value of pollBytes
 276  *
 277  * @params[in] Enum value
 278  * @return Actual value
 279  *
 280  * ****************************************************************/
 281 int32_t getPollByte(uint16_t pollBytesCfg)
 282 {
 283    int32_t pollBytes;
 284    switch(pollBytesCfg)
 285    {
 286       case PollByte_kB1:
 287          pollBytes = 1000;
 288          break;
 289       case PollByte_kB2:
 290          pollBytes = 2000;
 291          break;
 292       case PollByte_kB5:
 293          pollBytes = 5000;
 294          break;
 295       case PollByte_kB8:
 296          pollBytes = 8000;
 297          break;
 298       case PollByte_kB10:
 299          pollBytes = 10000;
 300          break;
 301       case PollByte_kB15:
 302          pollBytes = 15000;
 303          break;
 304       case PollByte_kB25:
 305          pollBytes = 25000;
 306          break;
 307       case PollByte_kB50:
 308          pollBytes = 50000;
 309          break;
 310       case PollByte_kB75:
 311          pollBytes = 75000;
 312          break;
 313       case PollByte_kB100:
 314          pollBytes = 100000;
 315          break;
 316       case PollByte_kB125:
 317          pollBytes = 125000;
 318          break;
 319       case PollByte_kB250:
 320          pollBytes = 250000;
 321          break;
 322       case PollByte_kB375:
 323          pollBytes = 375000;
 324          break;
 325       case PollByte_kB500:
 326          pollBytes = 500000;
 327          break;
 328       case PollByte_kB750:
 329          pollBytes = 750000;
 330          break;
 331       case PollByte_kB1000:
 332          pollBytes = 1000000;
 333          break;
 334       case PollByte_kB1250:
 335          pollBytes = 1250000;
 336          break;
 337       case PollByte_kB1500:
 338          pollBytes = 1500000;
 339          break;
 340       case PollByte_kB2000:
 341          pollBytes = 2000000;
 342          break;
 343       case PollByte_kB3000:
 344          pollBytes = 3000000;
 345          break;
 346       case PollByte_kB4000:
 347          pollBytes = 4000000;
 348          break;
 349       case PollByte_kB4500:
 350          pollBytes = 4500000;
 351          break;
 352       case PollByte_kB5000:
 353          pollBytes = 5000000;
 354          break;
 355       case PollByte_kB5500:
 356          pollBytes = 5500000;
 357          break;
 358       case PollByte_kB6000:
 359          pollBytes = 6000000;
 360          break;
 361       case PollByte_kB6500:
 362          pollBytes = 6500000;
 363          break;
 364       case PollByte_kB7000:
 365          pollBytes = 7000000;
 366          break;
 367       case PollByte_kB7500:
 368          pollBytes = 7500000;
 369          break;
 370       case PollByte_mB8:
 371          pollBytes = 8000000;
 372          break;
 373       case PollByte_mB9:
 374          pollBytes = 9000000;
 375          break;
 376       case PollByte_mB10:
 377          pollBytes = 10000000;
 378          break;
 379       case PollByte_mB11:
 380          pollBytes = 11000000;
 381          break;
 382       case PollByte_mB12:
 383          pollBytes = 12000000;
 384          break;
 385       case PollByte_mB13:
 386          pollBytes = 13000000;
 387          break;
 388       case PollByte_mB14:
 389          pollBytes = 14000000;
 390          break;
 391       case PollByte_mB15:
 392          pollBytes = 15000000;
 393          break;
 394       case PollByte_mB16:
 395          pollBytes = 16000000;
 396          break;
 397       case PollByte_mB17:
 398          pollBytes = 17000000;
 399          break;
 400       case PollByte_mB18:
 401          pollBytes = 18000000;
 402          break;
 403       case PollByte_mB20:
 404          pollBytes = 20000000;
 405          break;
 406       case PollByte_mB25:
 407          pollBytes = 25000000;
 408          break;
 409       case PollByte_mB30:
 410          pollBytes = 30000000;
 411          break;
 412       case PollByte_mB40:
 413          pollBytes = 40000000;
 414          break;
 415       case PollByte_infinity:
 416          pollBytes = -1;
 417          break;
 418       default:
 419          DU_LOG("\nERROR  -->  F1AP: Invalid value of poll bytes");
 420          pollBytes = 0;
 421    }
 422    return pollBytes;
 423 }
 424
 425 /*******************************************************************
 426  *
 427  * @brief Converts enum values into actual value of maxRetx
 428  *
 429  * @details
 430  *
 431  *    Function : getMaxRetx
 432  *
 433  *    Functionality: Converts enum values into actual value of maxRetx
 434  *
 435  * @params[in] Enum value
 436  * @return Actual value
 437  *
 438  * ****************************************************************/
 439 uint8_t getMaxRetx(uint8_t maxRetxCfg)
 440 {
 441    uint8_t maxRetx;
 442    switch(maxRetxCfg)
 443    {
 444       case UL_AM_RLC__maxRetxThreshold_t1:
 445          maxRetx = 1;
 446          break;
 447       case UL_AM_RLC__maxRetxThreshold_t2:
 448          maxRetx = 2;
 449          break;
 450       case UL_AM_RLC__maxRetxThreshold_t3:
 451          maxRetx = 3;
 452          break;
 453       case UL_AM_RLC__maxRetxThreshold_t4:
 454          maxRetx = 4;
 455          break;
 456       case UL_AM_RLC__maxRetxThreshold_t6:
 457          maxRetx = 6;
 458          break;
 459       case UL_AM_RLC__maxRetxThreshold_t8:
 460          maxRetx = 8;
 461          break;
 462       case UL_AM_RLC__maxRetxThreshold_t16:
 463          maxRetx = 16;
 464          break;
 465       case UL_AM_RLC__maxRetxThreshold_t32:
 466          maxRetx = 32;
 467          break;
 468       default:
 469          DU_LOG("\nERROR  -->  F1AP: Invalid configuration for Max retransmission threshold");
 470          maxRetx = 0;
 471    }
 472    return maxRetx;
 473 }
 474
 475 /*******************************************************************
 476  * @brief Converts enum values into actual value of reassembly timer
 477  *
 478  * @details
 479  *
 480  *    Function : getReAsmblTmr
 481  *
 482  *    Functionality: Converts enum values into actual value of reassembly
 483  *    timer
 484  *
 485  * @params[in] Enum value of reassembly timer
 486  * @return Actual value of reassembly timer
 487  *
 488  * **********************************************************************/
 489
 490 int8_t getReAsmblTmr(uint8_t reAsmblTmrCfg)
 491 {
 492    int8_t reAsmblTmr = 0;
 493
 494    if(reAsmblTmrCfg == T_Reassembly_ms0)
 495    {
 496       reAsmblTmr = 0;
 497    }
 498    else if(reAsmblTmrCfg >= T_Reassembly_ms5 || reAsmblTmrCfg <= T_Reassembly_ms100)
 499    {
 500      /* All values of re assembly timer are at interval of 5ms.
 501       * This is valid upto 100ms
 502       * Hence converting the enum value to actual value by multiplying it to 5
 503       */
 504       reAsmblTmr = reAsmblTmrCfg * 5;
 505    }
 506    else if(reAsmblTmrCfg >= T_Reassembly_ms110 || reAsmblTmrCfg <= T_Reassembly_ms200)
 507    {
 508      /* All values of re assembly timer are at interval of 10ms.
 509       * This is valid upto 200ms
 510       * since enum value starts from 20 for 100ms, subtracting 10 and
 511       * converting the enum value to actual value by multiplying it to 10
 512       */
 513       reAsmblTmr = ((reAsmblTmrCfg-10) * 10);
 514    }
 515    else
 516    {
 517       DU_LOG("\nERROR  -->  F1AP : Invalid value of Re Assembly timer %d", reAsmblTmrCfg);
 518       reAsmblTmr = -1;
 519    }
 520    return reAsmblTmr;
 521 }
 522
 523 /************************************************************************
 524  *
 525  * @brief Converts enum values into actual value of status prohibit timer
 526  *
 527  * @details
 528  *
 529  *    Function : getStatProhTmr
 530  *
 531  *    Functionality: Converts enum values into actual value of status prohibit
 532  *    timer
 533  *
 534  * @params[in] Enum value of status prohibit timer
 535  * @return Actual value of status prohibit timer
 536  *
 537  * **********************************************************************/
 538
 539 int16_t getStatProhTmr(uint8_t statProhTmrCfg)
 540 {
 541    int16_t statProhTmr =0;
 542
 543    if(statProhTmrCfg == T_StatusProhibit_ms0)
 544    {
 545       statProhTmr = 0;
 546    }
 547    else if(statProhTmrCfg >= T_StatusProhibit_ms5 || statProhTmrCfg <= T_StatusProhibit_ms250)
 548    {
 549       /* All values of re assembly timer are at interval of 5ms.
 550        * This is valid upto 250ms
 551        * Hence converting the enum value to actual value by multiplying it to 5
 552        */
 553       statProhTmr = statProhTmrCfg * 5;
 554    }
 555    else
 556    {
 557       switch(statProhTmrCfg)
 558       {
 559          case T_StatusProhibit_ms300:
 560             statProhTmr = 300;
 561             break;
 562          case T_StatusProhibit_ms350:
 563             statProhTmr = 350;
 564             break;
 565          case T_StatusProhibit_ms400:
 566             statProhTmr = 400;
 567             break;
 568          case T_StatusProhibit_ms450:
 569             statProhTmr = 450;
 570             break;
 571          case T_StatusProhibit_ms500:
 572             statProhTmr = 500;
 573             break;
 574          case T_StatusProhibit_ms800:
 575             statProhTmr = 800;
 576             break;
 577          case T_StatusProhibit_ms1000:
 578             statProhTmr = 1000;
 579             break;
 580          case T_StatusProhibit_ms1200:
 581             statProhTmr = 1200;
 582             break;
 583          case T_StatusProhibit_ms1600:
 584             statProhTmr = 1600;
 585             break;
 586          case T_StatusProhibit_ms2000:
 587             statProhTmr = 2000;
 588             break;
 589          case T_StatusProhibit_ms2400:
 590             statProhTmr = 2400;
 591             break;
 592          default:
 593             DU_LOG("\nInvalid value of Status Prohibit timer %d", statProhTmrCfg);
 594             statProhTmr = -1;
 595             break;
 596       }
 597    }
 598    return statProhTmr;
 599 }
 600
 601 /*******************************************************************
 602 *
 603 * @brief Adding F1AP pdu to reserved pdu list
 604 *
 605 * @details
 606 *
 607 *    Function : addToReservedF1apPduList
 608 *
 609 *    Functionality: Adding F1AP pdu to reserved pdu list.
 610 *     These pdu are awaiting aknowledgment from CU
 611 *
 612 * @params[in] uint8_t transId, F1AP_PDU_t *f1apMsg
 613 *
 614 * @return ROK - success
 615 *         RFAILED - failure
 616 *
 617 * ****************************************************************/
 618
 619 void addToReservedF1apPduList(uint8_t transId, F1AP_PDU_t *f1apPdu)
 620 {
 621    CmLList         *node = NULLP;
 622    ReservedF1apPduInfo *pduInfo = NULLP;
 623    DU_ALLOC(pduInfo, sizeof(ReservedF1apPduInfo));
 624    if(pduInfo)
 625    {
 626       DU_ALLOC(node, sizeof(CmLList));
 627       if(node)
 628       {
 629          pduInfo->transId = transId;
 630          pduInfo->f1apMsg = (void*) f1apPdu;
 631
 632          node->node = (PTR)pduInfo;
 633          cmLListAdd2Tail(&duCb.reservedF1apPduList, node);
 634       }
 635    }
 636 }
 637
 638 /*******************************************************************
 639 *
 640 * @brief searching for F1AP pdu from ReservedF1apPduList
 641 *
 642 * @details
 643 *
 644 *    Function : searchFromReservedF1apPduList
 645 *
 646 *    Functionality: searching for F1AP pdu information
 647 *
 648 * @params[in] uint8_t transId
 649 *
 650 * @return pointer to F1AP_PDU_t
 651 *
 652 * ****************************************************************/
 653
 654 CmLList *searchFromReservedF1apPduList(uint8_t transId)
 655 {
 656    CmLList         *node;
 657    ReservedF1apPduInfo *f1apPdu;
 658    if(duCb.reservedF1apPduList.count)
 659    {
 660       CM_LLIST_FIRST_NODE(&duCb.reservedF1apPduList, node);
 661       while(node)
 662       {
 663          f1apPdu = (ReservedF1apPduInfo*)node->node;
 664          if(f1apPdu->transId == transId)
 665          {
 666             return node;
 667          }
 668          node = node->next;
 669       }
 670    }
 671    return NULL;
 672 }
 673
 674 /*******************************************************************
 675 *
 676 * @brief deleting F1AP pdu information from ReservedF1apPduList
 677 *
 678 * @details
 679 *
 680 *    Function : deleteFromReservedF1apPduList
 681 *
 682 *    Functionality: deleting pdu information from ReservedF1apPduList
 683 *
 684 * @params[in] CmLList *node
 685 *
 686 * @return void
 687 *
 688 * ****************************************************************/
 689
 690 void deleteFromReservedF1apPduList(CmLList *node)
 691 {
 692    ReservedF1apPduInfo *f1apPdu;
 693
 694    if(node != NULL)
 695    {
 696       f1apPdu = (ReservedF1apPduInfo *)node->node;
 697       cmLListDelFrm(&duCb.reservedF1apPduList, node);
 698       DU_FREE(f1apPdu, sizeof(ReservedF1apPduInfo));
 699       DU_FREE(node, sizeof(CmLList));
 700       node = NULL;
 701    }
 702 }
 703
 704 /*******************************************************************
 705  *
 706  * @brief Builds Uplink Info for NR
 707  *
 708  * @details
 709  *
 710  *    Function : BuildULNRInfo
 711  *
 712  *    Functionality: Building NR Uplink Info
 713  *
 714  * @params[in] NRFreqInfo_t *ulnrfreq
 715  * @return ROK     - success
 716  *         RFAILED - failure
 717  *
 718  * ****************************************************************/
 719 uint8_t BuildULNRInfo(NRFreqInfo_t *ulnrfreq)
 720 {
 721    uint8_t idx=0;
 722    ulnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 723                        fdd.ulNrFreqInfo.nrArfcn;
 724    ulnrfreq->freqBandListNr.list.count = 1;
 725    ulnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 726    DU_ALLOC(ulnrfreq->freqBandListNr.list.array,ulnrfreq->freqBandListNr.list.size);
 727    if(ulnrfreq->freqBandListNr.list.array == NULLP)
 728    {
 729       return RFAILED;
 730    }
 731    for(idx=0;idx<ulnrfreq->freqBandListNr.list.count;idx++)
 732    {
 733       DU_ALLOC(ulnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 734       if(ulnrfreq->freqBandListNr.list.array[idx] == NULLP)
 735       {
 736          return RFAILED;
 737       }
 738    }
 739    ulnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 740                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
 741                                                                  freqBand[0].nrFreqBand;
 742    ulnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 743    return ROK;
 744 }
 745 /*******************************************************************
 746  *
 747  * @brief Builds Downlink NR Info
 748  *
 749  * @details
 750  *
 751  *    Function : BuildDLNRInfo
 752  *
 753  *    Functionality: Building Downlink NR Info
 754  *
 755  * @params[in] NRFreqInfo_t *dlnrfreq
 756  * @return ROK     - success
 757  *         RFAILED - failure
 758  *
 759  * ****************************************************************/
 760 uint8_t BuildDLNRInfo(NRFreqInfo_t *dlnrfreq)
 761 {
 762    uint8_t idx=0;
 763    dlnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 764                        fdd.dlNrFreqInfo.nrArfcn;
 765    dlnrfreq->freqBandListNr.list.count = 1;
 766    dlnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 767    DU_ALLOC(dlnrfreq->freqBandListNr.list.array,dlnrfreq->freqBandListNr.list.size);
 768    if(dlnrfreq->freqBandListNr.list.array == NULLP)
 769    {
 770       return RFAILED;
 771    }
 772    for(idx=0;idx< dlnrfreq->freqBandListNr.list.count;idx++)
 773    {
 774       DU_ALLOC(dlnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 775       if(dlnrfreq->freqBandListNr.list.array[idx] == NULLP)
 776       {
 777          return RFAILED;
 778       }
 779    }
 780    dlnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 781                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
 782                                                                  freqBand[0].nrFreqBand;
 783    dlnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 784
 785    return ROK;
 786 }
 787
 788 /*******************************************************************
 789  *
 790  * @brief Builds NRCell ID
 791  *
 792  * @details
 793  *
 794  *    Function : BuildNrCellId
 795  *
 796  *    Functionality: Building the NR Cell ID
 797  *
 798  * @params[in] BIT_STRING_t *nrcell
 799  * @return ROK     - success
 800  *         RFAILED - failure
 801  *
 802  * ****************************************************************/
 803
 804 S16 BuildNrCellId(BIT_STRING_t *nrcell)
 805 {
 806    memset(nrcell->buf, 0, nrcell->size);
 807    nrcell->buf[4]   = 16;
 808    nrcell->bits_unused = 4;
 809    return ROK;
 810 }
 811
 812 /*******************************************************************
 813  *
 814  * @brief Builds Nrcgi
 815  *
 816  * @details
 817  *
 818  *    Function : BuildNrcgi
 819  *
 820  *    Functionality: Building the PLMN ID and NR Cell id
 821  *
 822  * @params[in] NRCGI_t *nrcgi
 823  * @return ROK     - success
 824  *         RFAILED - failure
 825  *
 826  * ****************************************************************/
 827 uint8_t BuildNrcgi(NRCGI_t *nrcgi)
 828 {
 829    uint8_t ret;
 830    uint8_t byteSize = 5;
 831    /* Allocate Buffer Memory */
 832    nrcgi->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 833    DU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
 834    if(nrcgi->pLMN_Identity.buf == NULLP)
 835    {
 836       return RFAILED;
 837    }
 838    ret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 839          nrcgi->pLMN_Identity.buf); // Building PLMN function
 840    if(ret != ROK)
 841    {
 842       return RFAILED;
 843    }
 844    /*nrCellIdentity*/
 845    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
 846    DU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
 847    if(nrcgi->nRCellIdentity.buf == NULLP)
 848    {
 849       return RFAILED;
 850    }
 851    BuildNrCellId(&nrcgi->nRCellIdentity);
 852
 853    return ROK;
 854 }
 855 /*******************************************************************
 856  *
 857  * @brief Builds FiveGStac
 858  *
 859  * @details
 860  *
 861  *    Function : BuildFiveGSTac
 862  *
 863  *    Functionality: Building the FiveGSTac
 864  *
 865  * @params[in] OCTET_STRING_t *fivegsTac
 866  * @return ROK     - success
 867  *         RFAILED - failure
 868  *
 869  * ****************************************************************/
 870 uint8_t BuildFiveGSTac(Served_Cell_Information_t *servcell)
 871 {
 872    DU_ALLOC(servcell->fiveGS_TAC,sizeof(FiveGS_TAC_t));
 873    if(servcell->fiveGS_TAC == NULLP)
 874    {
 875       return RFAILED;
 876    }
 877    servcell->fiveGS_TAC->size = 3 * sizeof(uint8_t);
 878    DU_ALLOC(servcell->fiveGS_TAC->buf,\
 879          sizeof(servcell->fiveGS_TAC->size));
 880    if(servcell->fiveGS_TAC->buf == NULLP)
 881    {
 882       return RFAILED;
 883    }
 884    servcell->fiveGS_TAC->buf[0] = 0;
 885    servcell->fiveGS_TAC->buf[1] = 0;
 886    servcell->fiveGS_TAC->buf[2] = duCfgParam.srvdCellLst[0].duCellInfo.tac;
 887    return ROK;
 888 }
 889 /*******************************************************************
 890  *
 891  * @brief Builds NR Mode
 892  *
 893  * @details
 894  *
 895  *    Function : BuildNrMode
 896  *
 897  *    Functionality: Building the NR Mode
 898  *
 899  * @params[in] NR_Mode_Info_t *fdd
 900  * @return ROK     - success
 901  *         RFAILED - failure
 902  *
 903  * ****************************************************************/
 904 uint8_t BuildNrMode(NR_Mode_Info_t *mode)
 905 {
 906    uint8_t BuildDLNRInforet=0;
 907    uint8_t BuildULNRInforet=0;
 908    /* FDD Mode */
 909    mode->present = NR_Mode_Info_PR_fDD;
 910    if(mode->present == NR_Mode_Info_PR_fDD)
 911    {
 912       DU_ALLOC(mode->choice.fDD,sizeof(FDD_Info_t));
 913       if(mode->choice.fDD == NULLP)
 914       {
 915          return RFAILED;
 916       }
 917       BuildULNRInforet = BuildULNRInfo(&mode->choice.fDD->uL_NRFreqInfo);
 918       if(BuildULNRInforet != ROK)
 919       {
 920          return RFAILED;
 921       }
 922       BuildDLNRInforet = BuildDLNRInfo(&mode->choice.fDD->dL_NRFreqInfo);
 923       if(BuildDLNRInforet != ROK)
 924       {
 925          return RFAILED;
 926       }
 927    }
 928    mode->choice.fDD->uL_Transmission_Bandwidth.nRSCS = \
 929                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 930                                                        f1Mode.mode.fdd.ulTxBw.nrScs;
 931    mode->choice.fDD->uL_Transmission_Bandwidth.nRNRB = \
 932                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 933                                                        f1Mode.mode.fdd.ulTxBw.nrb;
 934    mode->choice.fDD->dL_Transmission_Bandwidth.nRSCS = \
 935                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 936                                                        f1Mode.mode.fdd.dlTxBw.nrScs;
 937    mode->choice.fDD->dL_Transmission_Bandwidth.nRNRB = \
 938                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 939                                                        f1Mode.mode.fdd.dlTxBw.nrb;
 940    return ROK;
 941 }
 942 /*******************************************************************
 943  *
 944  * @brief Builds IE Extensions for Served PLMNs
 945  *
 946  * @details
 947  *
 948  *    Function : BuildExtensions
 949  *
 950  *    Functionality: Building the IE Extensions
 951  *
 952  * @params[in] struct ProtocolExtensionContainer_4624P3 *buildextend
 953  * @return ROK     - success
 954  *         RFAILED - failure
 955  *
 956  * ****************************************************************/
 957 uint8_t BuildExtensions(ProtocolExtensionContainer_4624P3_t **ieExtend)
 958 {
 959    uint8_t idx;
 960    uint8_t plmnidx;
 961    uint8_t extensionCnt=1;
 962    uint8_t sliceId=0;
 963    uint8_t sdId;
 964    DU_ALLOC(*ieExtend,sizeof(ProtocolExtensionContainer_4624P3_t));
 965    if((*ieExtend) == NULLP)
 966    {
 967       return RFAILED;
 968    }
 969    (*ieExtend)->list.count = extensionCnt;
 970    (*ieExtend)->list.size = \
 971                             extensionCnt * sizeof(ServedPLMNs_ItemExtIEs_t *);
 972    DU_ALLOC((*ieExtend)->list.array,(*ieExtend)->list.size);
 973    if((*ieExtend)->list.array == NULLP)
 974    {
 975       return RFAILED;
 976    }
 977    for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
 978    {
 979       DU_ALLOC((*ieExtend)->list.array[plmnidx],\
 980             sizeof(ServedPLMNs_ItemExtIEs_t));
 981       if((*ieExtend)->list.array[plmnidx] == NULLP)
 982       {
 983          return RFAILED;
 984       }
 985    }
 986    idx = 0;
 987    (*ieExtend)->list.array[idx]->id = ProtocolIE_ID_id_TAISliceSupportList;
 988    (*ieExtend)->list.array[idx]->criticality = Criticality_ignore;
 989    (*ieExtend)->list.array[idx]->extensionValue.present = \
 990                                                           ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
 991    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 992       list.count = 1;
 993    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 994       list.size = sizeof(SliceSupportItem_t *);
 995    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 996          list.array,sizeof(SliceSupportItem_t *));
 997    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 998          list.array == NULLP)
 999    {
1000       return RFAILED;
1001    }
1002    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1003          list.array[sliceId],sizeof(SliceSupportItem_t));
1004    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1005          list.array[sliceId] == NULLP)
1006    {
1007       return RFAILED;
1008    }
1009    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1010       list.array[sliceId]->sNSSAI.sST.size = sizeof(uint8_t);
1011    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
1012          .list.array[sliceId]->sNSSAI.sST.buf,(*ieExtend)->list.array[idx]->\
1013          extensionValue.choice.SliceSupportList.\
1014          list.array[sliceId]->sNSSAI.sST.size);
1015    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
1016          .list.array[sliceId]->sNSSAI.sST.buf == NULLP)
1017    {
1018       return RFAILED;
1019    }
1020    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1021       list.array[sliceId]->sNSSAI.sST.buf[0] = 3;
1022    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1023          list.array[sliceId]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1024    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1025          list.array[sliceId]->sNSSAI.sD == NULLP)
1026    {
1027       return RFAILED;
1028    }
1029    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1030       list.array[sliceId]->sNSSAI.sD->size = 3*sizeof(uint8_t);
1031    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1032          list.array[sliceId]->sNSSAI.sD->buf,(*ieExtend)->list.array[idx]->extensionValue.choice.\
1033          SliceSupportList.list.array[sliceId]->sNSSAI.sD->size);
1034    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1035          list.array[sliceId]->sNSSAI.sD->buf == NULLP)
1036    {
1037       return RFAILED;
1038    }
1039    sdId = 0;
1040    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1041       list.array[sliceId]->sNSSAI.sD->buf[sdId] = 3;
1042    sdId++;
1043    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1044       list.array[sliceId]->sNSSAI.sD->buf[sdId] = 6;
1045    sdId++;
1046    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1047       list.array[sliceId]->sNSSAI.sD->buf[sdId] = 9;
1048    return ROK;
1049 }
1050 /*******************************************************************
1051  *
1052  * @brief Builds Served PLMN
1053  *
1054  * @details
1055  *
1056  *    Function : BuildServedPlmn
1057  *
1058  *    Functionality: Building the Served PLMN
1059  *
1060  * @params[in] GNB_DU_Served_Cells_Item_t *srvCellItem
1061  * @return ROK     - success
1062  *         RFAILED - failure
1063  *
1064  * ****************************************************************/
1065 uint8_t  BuildServedPlmn(ServedPLMNs_List_t *srvplmn)
1066 {
1067    uint8_t  plmnidx;
1068    uint8_t  servPlmnCnt=1;
1069    uint8_t buildPlmnIdret=0;
1070    uint8_t BuildExtensionsret=0;
1071    srvplmn->list.count = servPlmnCnt;
1072    srvplmn->list.size = \
1073                         servPlmnCnt*sizeof(ServedPLMNs_Item_t *);
1074    DU_ALLOC(srvplmn->list.array,srvplmn->list.size);
1075    if(srvplmn->list.array == NULLP)
1076    {
1077       return RFAILED;
1078    }
1079    for(plmnidx=0; plmnidx<servPlmnCnt; plmnidx++)
1080    {
1081       DU_ALLOC(srvplmn->list.array[plmnidx],\
1082             sizeof(ServedPLMNs_Item_t));
1083       if(srvplmn->list.array[plmnidx] == NULLP)
1084       {
1085          return RFAILED;
1086       }
1087    }
1088    srvplmn->list.array[0]->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
1089    DU_ALLOC(srvplmn->list.array[0]->pLMN_Identity.buf, srvplmn->list.array[0]->pLMN_Identity.size);
1090    buildPlmnIdret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
1091          srvplmn->list.array[0]->pLMN_Identity.buf);
1092    if(buildPlmnIdret!= ROK)
1093    {
1094       return RFAILED;
1095    }
1096    BuildExtensionsret = BuildExtensions(&srvplmn->list.array[0]->iE_Extensions);
1097    if(BuildExtensionsret!= ROK)
1098    {
1099       return RFAILED;
1100    }
1101    return ROK;
1102 }
1103 /*******************************************************************
1104  *
1105  * @brief Builds Served Cell List
1106  *
1107  * @details
1108  *
1109  *    Function : BuildServedCellList
1110  *
1111  *    Functionality: Building Served Cell List
1112  *
1113  * @params[in] PLMNID plmn
1114  * @return ROK     - success
1115  *         RFAILED - failure
1116  *
1117  * ****************************************************************/
1118
1119 uint8_t BuildServedCellList(GNB_DU_Served_Cells_List_t *duServedCell)
1120 {
1121    uint8_t  BuildNrcgiret=0;
1122    uint8_t  BuildFiveGSTacret=0;
1123    uint8_t  BuildServedPlmnret=0;
1124    uint8_t  BuildNrModeret=0;
1125    uint8_t  idx;
1126    uint8_t  plmnidx;
1127    uint8_t  plmnCnt=1;
1128    GNB_DU_Served_Cells_Item_t *srvCellItem;
1129    duServedCell->list.size = plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t *);
1130    duServedCell->list.count = plmnCnt;
1131
1132    DU_ALLOC(duServedCell->list.array, duServedCell->list.size);
1133    if(duServedCell->list.array == NULLP)
1134    {
1135       return RFAILED;
1136    }
1137    for(plmnidx=0; plmnidx<plmnCnt; plmnidx++)
1138    {
1139       DU_ALLOC(duServedCell->list.array[plmnidx],\
1140             sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1141       if(duServedCell->list.array[plmnidx] == NULLP)
1142       {
1143          return RFAILED;
1144       }
1145    }
1146    idx = 0;
1147    duServedCell->list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_Served_Cells_Item;
1148    duServedCell->list.array[idx]->criticality = Criticality_reject;
1149    duServedCell->list.array[idx]->value.present = \
1150                                                   GNB_DU_Served_Cells_ItemIEs__value_PR_GNB_DU_Served_Cells_Item;
1151    srvCellItem = \
1152                  &duServedCell->list.array[idx]->value.choice.GNB_DU_Served_Cells_Item;
1153    /*nRCGI*/
1154    BuildNrcgiret = BuildNrcgi(&srvCellItem->served_Cell_Information.nRCGI);
1155    if(BuildNrcgiret != ROK)
1156    {
1157       return RFAILED;
1158    }
1159    /*nRPCI*/
1160    srvCellItem->served_Cell_Information.nRPCI = \
1161                                                 duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
1162
1163    /*fiveGS_TAC*/
1164    BuildFiveGSTacret = BuildFiveGSTac(&srvCellItem->served_Cell_Information);
1165    if(BuildFiveGSTacret != ROK)
1166    {
1167       return RFAILED;
1168    }
1169    /*Served PLMNs*/
1170    BuildServedPlmnret = BuildServedPlmn(&srvCellItem->served_Cell_Information.servedPLMNs);
1171    if(BuildServedPlmnret !=ROK)
1172    {
1173       return RFAILED;
1174    }
1175    /*nR Mode Info with FDD*/
1176    BuildNrModeret = BuildNrMode(&srvCellItem->served_Cell_Information.nR_Mode_Info);
1177    if(BuildNrModeret != ROK)
1178    {
1179       return RFAILED;
1180    }
1181    /*Measurement timing Config*/
1182    srvCellItem->served_Cell_Information.measurementTimingConfiguration.\
1183       size = sizeof(uint8_t);
1184    DU_ALLOC(srvCellItem->served_Cell_Information.\
1185          measurementTimingConfiguration.buf,srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1186    if(srvCellItem->served_Cell_Information.\
1187          measurementTimingConfiguration.buf == NULLP)
1188    {
1189       return RFAILED;
1190    }
1191    srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf[0] = \
1192                                                                                 duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
1193
1194    /* GNB DU System Information */
1195    DU_ALLOC(srvCellItem->gNB_DU_System_Information,
1196          sizeof(GNB_DU_System_Information_t));
1197    if(!srvCellItem->gNB_DU_System_Information)
1198    {
1199       return RFAILED;
1200    }
1201    /* MIB */
1202    srvCellItem->gNB_DU_System_Information->mIB_message.size = duCfgParam.srvdCellLst[0].duSysInfo.mibLen;
1203    DU_ALLOC(srvCellItem->gNB_DU_System_Information->mIB_message.buf,
1204          srvCellItem->gNB_DU_System_Information->mIB_message.size);
1205    if(!srvCellItem->gNB_DU_System_Information->mIB_message.buf)
1206    {
1207       return RFAILED;
1208    }
1209    memcpy(srvCellItem->gNB_DU_System_Information->mIB_message.buf, duCfgParam.srvdCellLst[0].duSysInfo.mibMsg, \
1210                    srvCellItem->gNB_DU_System_Information->mIB_message.size);
1211
1212    /* SIB1 */
1213    srvCellItem->gNB_DU_System_Information->sIB1_message.size =\
1214                                                               duCfgParam.srvdCellLst[0].duSysInfo.sib1Len;
1215
1216    DU_ALLOC(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,
1217          srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1218    if(!srvCellItem->gNB_DU_System_Information->sIB1_message.buf)
1219    {
1220       return RFAILED;
1221    }
1222    for(int x=0; x<srvCellItem->gNB_DU_System_Information->sIB1_message.size; x++)
1223    {
1224       srvCellItem->gNB_DU_System_Information->sIB1_message.buf[x]=\
1225                                                                   duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg[x];
1226    }
1227    return ROK;
1228 }
1229 /*******************************************************************
1230  *
1231  * @brief Builds RRC Version
1232  *
1233  * @details
1234  *
1235  *    Function : BuildRrcVer
1236  *
1237  *    Functionality: Building RRC Version
1238  *
1239  * @params[in] int idx,int elementCnt,RRC_Version_t *rrcver
1240  * @return ROK     - success
1241  *         RFAILED - failure
1242  *
1243  * ****************************************************************/
1244 uint8_t BuildRrcVer(RRC_Version_t *rrcVer)
1245 {
1246    uint8_t rrcExt;
1247    uint8_t rrcLatest;
1248    rrcVer->latest_RRC_Version.size = sizeof(uint8_t);
1249    DU_ALLOC(rrcVer->latest_RRC_Version.buf,sizeof(uint8_t));
1250    if(rrcVer->latest_RRC_Version.buf == NULLP)
1251    {
1252       return RFAILED;
1253    }
1254    rrcVer->latest_RRC_Version.buf[0] = 0;
1255    rrcVer->latest_RRC_Version.bits_unused = 5;
1256    DU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1257    if(rrcVer->iE_Extensions == NULLP)
1258    {
1259       return RFAILED;
1260    }
1261    rrcVer->iE_Extensions->list.count = 1;
1262    rrcVer->iE_Extensions->list.size = sizeof(RRC_Version_ExtIEs_t *);
1263    DU_ALLOC(rrcVer->iE_Extensions->list.array,rrcVer->iE_Extensions->list.size);
1264    if(rrcVer->iE_Extensions->list.array == NULLP)
1265    {
1266       return RFAILED;
1267    }
1268    rrcExt = 0;
1269    DU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
1270          sizeof(RRC_Version_ExtIEs_t));
1271    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
1272    {
1273       return RFAILED;
1274    }
1275    rrcVer->iE_Extensions->list.array[rrcExt]->id = \
1276                                                    ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
1277    rrcVer->iE_Extensions->list.array[rrcExt]->criticality = Criticality_reject;
1278    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.present =\
1279                                                                       RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
1280    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1281       .Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
1282    DU_ALLOC(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1283          .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1284          array[rrcExt]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1285    if(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1286          .Latest_RRC_Version_Enhanced.buf == NULLP)
1287    {
1288       return RFAILED;
1289    }
1290    rrcLatest = 0;
1291    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1292       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 15;
1293    rrcLatest++;
1294    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1295       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 5;
1296    rrcLatest++;
1297    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1298       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 0;
1299    return ROK;
1300 }
1301 /*******************************************************************
1302  *
1303  * @brief Sends F1 msg over SCTP
1304  *
1305  * @details
1306  *
1307  *    Function : sendF1APMsg
1308  *
1309  *    Functionality: Sends F1 msg over SCTP
1310  *
1311  * @params[in] Region region
1312  *             Pool pool
1313  * @return ROK     - success
1314  *         RFAILED - failure
1315  *
1316  * ****************************************************************/
1317 uint8_t sendF1APMsg()
1318 {
1319    Buffer *mBuf = NULLP;
1320
1321    if(ODU_GET_MSG_BUF(DU_APP_MEM_REGION, DU_POOL, &mBuf) == ROK)
1322    {
1323       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
1324       {
1325             ODU_PRINT_MSG(mBuf, 0,0);
1326
1327             if(sctpSend(mBuf, F1_INTERFACE) != ROK)
1328             {
1329                DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
1330                ODU_PUT_MSG_BUF(mBuf);
1331                return RFAILED;
1332             }
1333       }
1334       else
1335       {
1336          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
1337          ODU_PUT_MSG_BUF(mBuf);
1338          return RFAILED;
1339       }
1340       ODU_PUT_MSG_BUF(mBuf);
1341    }
1342    else
1343    {
1344       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
1345       return RFAILED;
1346    }
1347    return ROK;
1348 } /* sendF1APMsg */
1349
1350 /*******************************************************************
1351  *
1352  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1353  *
1354  * @details
1355  *
1356  *    Function :  FreeRrcVer
1357  *
1358  *    Functionality: deallocating the memory of function BuildRrcVer
1359  *
1360  * @params[in] RRC_Version_t *rrcVer
1361  *
1362  * @return void
1363  *
1364  *****************************************************************/
1365 void FreeRrcVer(RRC_Version_t *rrcVer)
1366 {
1367    if(rrcVer->latest_RRC_Version.buf != NULLP)
1368    {
1369       if(rrcVer->iE_Extensions != NULLP)
1370       {
1371          if(rrcVer->iE_Extensions->list.array != NULLP)
1372          {
1373             if(rrcVer->iE_Extensions->list.array[0] != NULLP)
1374             {
1375                if(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf
1376                      != NULLP)
1377                {
1378                   DU_FREE(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice\
1379                         .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1380                         array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1381                }
1382                DU_FREE(rrcVer->iE_Extensions->list.array[0],sizeof(RRC_Version_ExtIEs_t));
1383             }
1384             DU_FREE(rrcVer->iE_Extensions->list.array,sizeof(RRC_Version_ExtIEs_t*));
1385          }
1386          DU_FREE(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1387       }
1388       DU_FREE(rrcVer->latest_RRC_Version.buf,rrcVer->latest_RRC_Version.size);
1389    }
1390 }
1391 /*******************************************************************
1392  *
1393  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1394  *
1395  * @details
1396  *
1397  *    Function :  FreeServedCellList
1398  *
1399  *    Functionality:  deallocating the memory of function BuildServedCellList
1400
1401  *
1402  * @params[in] GNB_DU_Served_Cells_List_t *duServedCell
1403  *
1404  * @return void
1405  *
1406  * ****************************************************************/
1407 void FreeServedCellList( GNB_DU_Served_Cells_List_t *duServedCell)
1408 {
1409    uint8_t   plmnCnt=1;
1410    uint8_t  sliceId=0;
1411    uint8_t  extensionCnt=1;
1412    uint8_t  plmnIdx=0;
1413    GNB_DU_Served_Cells_Item_t *srvCellItem;
1414    ServedPLMNs_Item_t  *servedPlmnItem;
1415    SliceSupportItem_t  *sliceSupportItem;
1416
1417    if(duServedCell->list.array!=NULLP)
1418    {
1419       if(duServedCell->list.array[0]!=NULLP)
1420       {
1421          srvCellItem= &duServedCell->list.array[0]->value.choice.GNB_DU_Served_Cells_Item;
1422
1423          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1424                srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size * sizeof(uint8_t));
1425          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1426                srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size * sizeof(uint8_t));
1427
1428          if(srvCellItem->served_Cell_Information.fiveGS_TAC!=NULLP)
1429          {
1430             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
1431                   sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
1432             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,sizeof(FiveGS_TAC_t));
1433          }
1434
1435          if(srvCellItem->served_Cell_Information.servedPLMNs.list.array!=NULLP)
1436          {
1437             if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx] != NULLP)
1438             {
1439                servedPlmnItem = srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx];
1440                DU_FREE(servedPlmnItem->pLMN_Identity.buf, servedPlmnItem->pLMN_Identity.size * sizeof(uint8_t));
1441
1442                if(servedPlmnItem->iE_Extensions != NULLP)
1443                {
1444                   if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1445                   {
1446                      if(servedPlmnItem->iE_Extensions->list.array[0] != NULLP)
1447                      {
1448                         if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.list.\
1449                               array != NULLP)
1450                         {
1451                            if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.list.\
1452                                  array[sliceId] != NULLP)
1453                            {
1454                               sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1455                                                  SliceSupportList.list.array[sliceId];
1456
1457                               DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sizeof(uint8_t));
1458
1459                               if(sliceSupportItem->sNSSAI.sD != NULLP)
1460                               {
1461                                  DU_FREE(sliceSupportItem->sNSSAI.sD->buf, sliceSupportItem->sNSSAI.sD->size);
1462                                  DU_FREE(sliceSupportItem->sNSSAI.sD, sizeof(OCTET_STRING_t));
1463                               }
1464
1465                               DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1466                                     list.array[sliceId], sizeof(SliceSupportItem_t));
1467                            }
1468                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1469                                  list.array, sizeof(SliceSupportItem_t*));
1470                         }
1471                         DU_FREE(servedPlmnItem->iE_Extensions->list.array[0], sizeof(ServedPLMNs_ItemExtIEs_t));
1472                      }
1473                      DU_FREE(servedPlmnItem->iE_Extensions->list.array, extensionCnt*sizeof(ServedPLMNs_ItemExtIEs_t*));
1474                   }
1475                   DU_FREE(servedPlmnItem->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P3_t));
1476                }
1477                DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx], sizeof(ServedPLMNs_Item_t));
1478             }
1479             DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array, sizeof(ServedPLMNs_Item_t *));
1480          }
1481
1482          if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD != NULLP)
1483          {
1484             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
1485                   freqBandListNr.list.array != NULLP)
1486             {
1487                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.\
1488                      list.array[0],sizeof(FreqBandNrItem_t));
1489                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.\
1490                      list.array,sizeof(FreqBandNrItem_t*));
1491             }
1492
1493             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1494                   freqBandListNr.list.array)
1495             {
1496                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1497                      freqBandListNr.list.array[0],sizeof(FreqBandNrItem_t));
1498                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1499                      freqBandListNr.list.array,sizeof(FreqBandNrItem_t *));
1500             }
1501             DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD, sizeof(FDD_Info_t));
1502          }
1503
1504          DU_FREE(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1505                srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1506
1507          if(srvCellItem->gNB_DU_System_Information != NULLP)
1508          {
1509             if(srvCellItem->gNB_DU_System_Information->mIB_message.buf != NULLP)
1510             {
1511                DU_FREE(srvCellItem->gNB_DU_System_Information->mIB_message.buf,\
1512                      srvCellItem->gNB_DU_System_Information->mIB_message.size);
1513             }
1514
1515             if(srvCellItem->gNB_DU_System_Information->sIB1_message.buf != NULLP)
1516             {
1517                DU_FREE(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,\
1518                      srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1519             }
1520
1521             DU_FREE(srvCellItem->gNB_DU_System_Information, sizeof(GNB_DU_System_Information_t));
1522          }
1523
1524          DU_FREE(duServedCell->list.array[0], sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1525       }
1526       DU_FREE(duServedCell->list.array, plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t*));
1527    }
1528 }
1529
1530 /*******************************************************************
1531  *
1532  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1533  *
1534  * @details
1535  *
1536  *    Function :  FreeF1SetupReq
1537  *
1538  *    Functionality:  deallocating the memory of function BuildAndSendF1SetupReq
1539  *
1540  * @params[in] F1AP_PDU_t *f1apMsg
1541  *
1542  * @return void
1543  *
1544  * ****************************************************************/
1545 void FreeF1SetupReq(F1AP_PDU_t *f1apMsg)
1546 {
1547    uint8_t ieIdx, ieIdx2;
1548    F1SetupRequest_t *f1SetupReq=NULLP;
1549
1550    if(f1apMsg != NULLP)
1551    {
1552       if(f1apMsg->choice.initiatingMessage != NULLP)
1553       {
1554          f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1555          if(f1SetupReq->protocolIEs.list.array != NULLP)
1556          {
1557             for(ieIdx = 0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
1558             {
1559                if(f1SetupReq->protocolIEs.list.array[ieIdx] != NULLP)
1560                {
1561                   switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
1562                   {
1563                      case ProtocolIE_ID_id_TransactionID:
1564                         break;
1565                      case ProtocolIE_ID_id_gNB_DU_ID:
1566                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1567                               f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1568                         break;
1569                      case ProtocolIE_ID_id_gNB_DU_Name:
1570                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,\
1571                               strlen((char *)duCfgParam.duName));
1572                         break;
1573                      case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
1574                         FreeServedCellList(&f1SetupReq->protocolIEs.list.\
1575                               array[ieIdx]->value.choice.GNB_DU_Served_Cells_List);
1576                         break;
1577                      case ProtocolIE_ID_id_GNB_DU_RRC_Version:
1578                         FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version);
1579                         break;
1580                      default:
1581                         DU_LOG("\nERROR  -->  Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id);
1582                         break;
1583                   }
1584                }
1585             }
1586             for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++)
1587             {
1588                DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx2],sizeof(F1SetupRequestIEs_t));
1589             }
1590             DU_FREE(f1SetupReq->protocolIEs.list.array,\
1591                   f1SetupReq->protocolIEs.list.size);
1592          }
1593          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1594       }
1595       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1596    }
1597 }
1598 /*******************************************************************
1599  *
1600  * @brief Builds and Send the F1SetupRequest
1601  *
1602  * @details
1603  *
1604  *    Function : BuildAndSendF1SetupReq
1605  *
1606  * Functionality:Fills the F1SetupRequest
1607  *
1608  * @return ROK     - success
1609  *         RFAILED - failure
1610  *
1611  ******************************************************************/
1612 uint8_t BuildAndSendF1SetupReq()
1613 {
1614    uint8_t   ret, ieIdx, elementCnt;
1615    F1AP_PDU_t                 *f1apMsg = NULLP;
1616    F1SetupRequest_t           *f1SetupReq=NULLP;
1617    GNB_DU_Served_Cells_List_t *duServedCell=NULLP;
1618    RRC_Version_t              *rrcVer=NULLP;
1619    asn_enc_rval_t             encRetVal;        /* Encoder return value */
1620    ret= RFAILED;
1621
1622    DU_LOG("\nINFO   -->  F1AP : Building F1 Setup Request\n");
1623    do
1624    {
1625       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1626       if(f1apMsg == NULLP)
1627       {
1628          break;
1629       }
1630       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1631       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1632       if(f1apMsg->choice.initiatingMessage == NULLP)
1633       {
1634          break;
1635       }
1636       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_F1Setup;
1637       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
1638       f1apMsg->choice.initiatingMessage->value.present = \
1639                                                          InitiatingMessage__value_PR_F1SetupRequest;
1640
1641       f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1642
1643       elementCnt = (duCfgParam.duName != NULL) ? 5 : 4;
1644
1645       f1SetupReq->protocolIEs.list.count = elementCnt;
1646       f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t );
1647
1648       /* Initialize the F1Setup members */
1649       DU_ALLOC(f1SetupReq->protocolIEs.list.array,f1SetupReq->protocolIEs.list.size);
1650       if(f1SetupReq->protocolIEs.list.array == NULLP)
1651       {
1652          break;
1653       }
1654       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
1655       {
1656          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx],\
1657                sizeof(F1SetupRequestIEs_t));
1658          if(f1SetupReq->protocolIEs.list.array[ieIdx] == NULLP)
1659          {
1660             break;
1661          }
1662       }
1663
1664       ieIdx = 0;
1665       /*TransactionID*/
1666       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransactionID;
1667       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1668       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present =\
1669                                                                F1SetupRequestIEs__value_PR_TransactionID;
1670       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = \
1671                                                                              TRANS_ID;
1672
1673       /*DU ID*/
1674       ieIdx++;
1675       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
1676       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1677       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1678                                                                 F1SetupRequestIEs__value_PR_GNB_DU_ID;
1679       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size =\
1680                                                                              sizeof(uint8_t);
1681
1682       DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1683             f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1684       if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == \
1685             NULLP)
1686       {
1687          break;
1688       }
1689
1690       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] =\
1691          duCfgParam.duId;
1692
1693       /*DU Name*/
1694       if(duCfgParam.duName != NULL)
1695       {
1696          ieIdx++;
1697          f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_Name;
1698          f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
1699          f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = F1SetupRequestIEs__value_PR_GNB_DU_Name;
1700          f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.size =\
1701             strlen((char *)duCfgParam.duName);
1702          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.\
1703                GNB_DU_Name.buf, strlen((char *)duCfgParam.duName));
1704          if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.\
1705                buf == NULLP)
1706          {
1707             break;
1708          }
1709          strcpy((char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.\
1710                choice.GNB_DU_Name.buf,
1711                (char*)&duCfgParam.duName);
1712
1713       }
1714
1715       /*Served Cell list */
1716       ieIdx++;
1717       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1718                                                      ProtocolIE_ID_id_gNB_DU_Served_Cells_List;
1719       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1720       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1721                                                                 F1SetupRequestIEs__value_PR_GNB_DU_Served_Cells_List;
1722       duServedCell = &f1SetupReq->protocolIEs.list.\
1723                      array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
1724       if(BuildServedCellList(duServedCell))
1725       {
1726          break;
1727       }
1728       /*RRC Version*/
1729       ieIdx++;
1730       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1731                                                      ProtocolIE_ID_id_GNB_DU_RRC_Version ;
1732       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1733       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1734                                                                 F1SetupRequestIEs__value_PR_RRC_Version;
1735       rrcVer = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
1736       if(BuildRrcVer(rrcVer))
1737       {
1738          break;
1739       }
1740       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1741
1742       /* Encode the F1SetupRequest type as APER */
1743       memset(encBuf, 0, ENC_BUF_MAX_LEN);
1744       encBufSize = 0;
1745       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1746             encBuf);
1747
1748       /* Encode results */
1749       if(encRetVal.encoded == ENCODE_FAIL)
1750       {
1751          DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupRequest structure (at %s)\n",\
1752                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1753          break;
1754       }
1755       else
1756       {
1757          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1SetupRequest\n");
1758          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
1759          {
1760             printf("%x",encBuf[ieIdx]);
1761          }
1762       }
1763
1764       /* Sending msg */
1765       if(sendF1APMsg() != ROK)
1766       {
1767          DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup request failed");
1768          break;
1769       }
1770
1771       ret=ROK;
1772       break;
1773    }while(true);
1774
1775    FreeF1SetupReq(f1apMsg);
1776
1777    return ret;
1778 }/* End of BuildAndSendF1SetupReq */
1779
1780 /*******************************************************************
1781  *
1782  * @brief Deallocating memory allocated for Served_Cells_To_Modify_Item_t
1783  *
1784  * @details
1785  *
1786  *    Function : freeCellsToModifyItem
1787  *
1788  *    Functionality: Deallocating memory of variables allocated in
1789  *                    BuildAndSendDUConfigUpdate function
1790  *
1791  * @params[in]  Served_Cells_To_Modify_Item_t *modifyItem
1792  *
1793  * @return ROK     - void
1794  *
1795  * ****************************************************************/
1796
1797 void freeCellsToModifyItem(Served_Cells_To_Modify_Item_t *modifyItem)
1798 {
1799    uint8_t arrIdx=0,i=0;
1800    ServedPLMNs_Item_t *servedPlmnItem = NULLP;
1801    SliceSupportItem_t *sliceSupportItem = NULLP;
1802
1803    DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf, modifyItem->oldNRCGI.pLMN_Identity.size);
1804    DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf, modifyItem->oldNRCGI.nRCellIdentity.size);
1805
1806    DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1807            modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
1808    DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1809          modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
1810
1811    if(modifyItem->served_Cell_Information.servedPLMNs.list.array != NULLP)
1812    {
1813       if(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx] != NULLP)
1814       {
1815          servedPlmnItem = modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx];
1816
1817          DU_FREE(servedPlmnItem->pLMN_Identity.buf,servedPlmnItem->pLMN_Identity.size);
1818
1819          if(servedPlmnItem->iE_Extensions != NULLP)
1820          {
1821             if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1822             {
1823                if(servedPlmnItem->iE_Extensions->list.array[arrIdx] != NULLP)
1824                {
1825                   if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.list.array != NULLP)
1826                   {
1827                      if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.list.array[arrIdx] != NULLP)
1828                      {
1829                         sliceSupportItem = modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx]->iE_Extensions->\
1830                                            list.array[arrIdx]->extensionValue.choice.SliceSupportList.list.array[arrIdx];
1831
1832                         DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sliceSupportItem->sNSSAI.sST.size);
1833                         if(sliceSupportItem->sNSSAI.sD != NULLP)
1834                         {
1835                            DU_FREE(sliceSupportItem->sNSSAI.sD->buf, sliceSupportItem->sNSSAI.sD->size);
1836                            DU_FREE(sliceSupportItem->sNSSAI.sD,sizeof(OCTET_STRING_t));
1837                         }
1838                         DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1839                               list.array[arrIdx], sizeof(SliceSupportItem_t));
1840                      }
1841                      DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.list.array,
1842                            servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.list.size);
1843                   }
1844                }
1845                for(i=0; i < servedPlmnItem->iE_Extensions->list.count ; i++)
1846                {
1847                   DU_FREE(servedPlmnItem->iE_Extensions->list.array[i], sizeof(ServedPLMNs_ItemExtIEs_t ));
1848                }
1849                DU_FREE(servedPlmnItem->iE_Extensions->list.array, servedPlmnItem->iE_Extensions->list.size);
1850             }
1851             DU_FREE(servedPlmnItem->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1852          }
1853       }
1854       for(i=0;i<modifyItem->served_Cell_Information.servedPLMNs.list.count;i++)
1855       {
1856          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[i], sizeof(ServedPLMNs_Item_t));
1857       }
1858       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1859             modifyItem->served_Cell_Information.servedPLMNs.list.size);
1860    }
1861
1862    if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD != NULLP)
1863    {
1864       if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1865       {
1866          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
1867                array[arrIdx], sizeof(FreqBandNrItem_t));
1868          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array, \
1869                modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1870       }
1871
1872       if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1873       {
1874          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.\
1875              array[arrIdx], sizeof(FreqBandNrItem_t));
1876          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,\
1877                modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1878       }
1879       DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD,sizeof(FDD_Info_t));
1880    }
1881
1882    DU_FREE(modifyItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1883       modifyItem->served_Cell_Information.measurementTimingConfiguration.size);
1884 }
1885
1886 /*******************************************************************
1887  *
1888  * @brief Deallocating memory of BuildAndSendDUConfigUpdate
1889  *
1890  * @details
1891  *
1892  *    Function : FreeDUConfigUpdate
1893  *
1894  *    Functionality: Deallocating memory of variables allocated in
1895  *                    BuildAndSendDUConfigUpdate function
1896  *
1897  * @params[in]  F1AP_PDU_t *f1apDuCfg
1898  *
1899  * @return ROK     - void
1900  *
1901  * ****************************************************************/
1902 void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg)
1903 {
1904    uint8_t  ieIdx=0, cellModifyIdx=0, cellDeleteIdx=0;
1905    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
1906    Served_Cells_To_Modify_List_t  *cellsToModify=NULLP;
1907    Served_Cells_To_Delete_List_t  *cellsToDelete=NULLP;
1908    Served_Cells_To_Delete_Item_t  *deleteItem = NULLP;
1909    Served_Cells_To_Delete_ItemIEs_t *deleteItemIe = NULLP;
1910
1911    if(f1apDuCfg != NULLP)
1912    {
1913       if(f1apDuCfg->choice.initiatingMessage != NULLP)
1914       {
1915          duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->\
1916                        value.choice.GNBDUConfigurationUpdate;
1917          if(duCfgUpdate->protocolIEs.list.array != NULLP)
1918          {
1919             for(ieIdx=0; ieIdx<duCfgUpdate->protocolIEs.list.count; ieIdx++)
1920             {
1921                if(duCfgUpdate->protocolIEs.list.array[ieIdx] != NULLP)
1922                {
1923                   switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
1924                   {
1925                      case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
1926                         {
1927                            cellsToModify = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1928                                            value.choice.Served_Cells_To_Modify_List;
1929                            if(cellsToModify->list.array != NULLP)
1930                            {
1931                               for(cellModifyIdx=0; cellModifyIdx<cellsToModify->list.count ;cellModifyIdx++)
1932                               {
1933                                  if(cellsToModify->list.array[cellModifyIdx] != NULLP)
1934                                  {
1935                                     freeCellsToModifyItem(&cellsToModify->list.array[cellModifyIdx]->value.choice.\
1936                                           Served_Cells_To_Modify_Item);
1937                                     DU_FREE(cellsToModify->list.array[cellModifyIdx],\
1938                                           sizeof(Served_Cells_To_Modify_ItemIEs_t));
1939                                  }
1940                               }
1941                               DU_FREE(cellsToModify->list.array,cellsToModify->list.size);
1942                            }
1943                            break;
1944                         }
1945                      case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
1946                         {
1947                            cellsToDelete = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1948                                            value.choice.Served_Cells_To_Delete_List;
1949                            if(cellsToDelete->list.array != NULLP)
1950                            {
1951                               for(cellDeleteIdx=0; cellDeleteIdx<cellsToDelete->list.count ;cellDeleteIdx++)
1952                               {
1953                                  if(cellsToDelete->list.array[cellDeleteIdx] != NULLP)
1954                                  {
1955                                     deleteItemIe = ((Served_Cells_To_Delete_ItemIEs_t*)\
1956                                           cellsToDelete->list.array[cellDeleteIdx]);
1957                                     deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
1958                                     DU_FREE(deleteItem->oldNRCGI.pLMN_Identity.buf,\
1959                                           deleteItem->oldNRCGI.pLMN_Identity.size);
1960                                     DU_FREE(deleteItem->oldNRCGI.nRCellIdentity.buf,\
1961                                           deleteItem->oldNRCGI.nRCellIdentity.size);
1962                                     DU_FREE(cellsToDelete->list.array[cellDeleteIdx],\
1963                                           sizeof(Served_Cells_To_Delete_ItemIEs_t));
1964                                  }
1965                               }
1966                               DU_FREE(cellsToDelete->list.array,cellsToDelete->list.size);
1967                            }
1968
1969                            break;
1970                         }
1971                      case ProtocolIE_ID_id_gNB_DU_ID:
1972                         {
1973                            DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1974                                  duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1975                            break;
1976                         }
1977                   }
1978                   DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx],\
1979                         sizeof(GNBDUConfigurationUpdateIEs_t));
1980                }
1981             }
1982             DU_FREE(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
1983          }
1984          DU_FREE(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
1985       }
1986       DU_FREE(f1apDuCfg, (Size)sizeof(F1AP_PDU_t));
1987    }
1988 }
1989
1990 /*******************************************************************
1991  *
1992  * @brief Fills Served Plmns required in ServCellInfo IE
1993  *
1994  * @details
1995  *
1996  *    Function : fillServedPlmns
1997  *
1998  *    Functionality: Fills Served Plmns required in ServCellInfo IE
1999  *
2000  * @params[in] Pointer to ServedPLMNs_List_t *
2001  *
2002  * @return ROK     - success
2003  *         RFAILED - failure
2004  *
2005  *****************************************************************/
2006
2007 uint8_t fillServedPlmns(ServedPLMNs_List_t *servedPlmn)
2008 {
2009    uint8_t ieIdx, ieListCnt;
2010
2011    servedPlmn->list.array[0]->pLMN_Identity.size = 3*sizeof(uint8_t);
2012    DU_ALLOC(servedPlmn->list.array[0]->pLMN_Identity.buf, servedPlmn->list.\
2013          array[0]->pLMN_Identity.size);
2014    if(servedPlmn->list.array[0]->pLMN_Identity.buf == NULLP)
2015    {
2016       return RFAILED;
2017    }
2018    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.plmn[0],\
2019          servedPlmn->list.array[0]->pLMN_Identity.buf);
2020    DU_ALLOC(servedPlmn->list.array[0]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
2021    if(servedPlmn->list.array[0]->iE_Extensions == NULLP)
2022    {
2023       return RFAILED;
2024    }
2025
2026    ieListCnt=1;
2027    servedPlmn->list.array[0]->iE_Extensions->list.count = ieListCnt;
2028    servedPlmn->list.array[0]->iE_Extensions->list.size = ieListCnt *sizeof(ServedPLMNs_ItemExtIEs_t *);
2029    DU_ALLOC(servedPlmn->list.array[0]->iE_Extensions->list.array,servedPlmn->list.array[0]->\
2030          iE_Extensions->list.size);
2031    if(servedPlmn->list.array[0]->iE_Extensions->list.array == NULLP)
2032    {
2033       return RFAILED;
2034    }
2035    for(ieIdx=0;ieIdx<ieListCnt;ieIdx++)
2036    {
2037       DU_ALLOC(servedPlmn->list.array[0]->iE_Extensions->list.array[ieIdx],\
2038             sizeof(ServedPLMNs_ItemExtIEs_t));
2039       if(servedPlmn->list.array[0]->iE_Extensions->list.array[ieIdx] == NULLP)
2040       {
2041          return RFAILED;
2042       }
2043    }
2044    //plmnIeExt = servedPlmn->list.array[0]->iE_Extensions;
2045    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->id =ProtocolIE_ID_id_TAISliceSupportList;
2046    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->criticality = Criticality_ignore;
2047    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->extensionValue.present = \
2048       ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
2049    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2050       list.count = 1;
2051    servedPlmn->list.array[0]->\
2052       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2053       list.size = sizeof(SliceSupportItem_t *);
2054    DU_ALLOC(servedPlmn->list.array[0]->\
2055          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2056          list.array,servedPlmn->list.array[0]->\
2057          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.list.size);
2058    if(servedPlmn->list.array[0]->\
2059          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2060          list.array == NULLP)
2061    {
2062       return RFAILED;
2063    }
2064
2065    DU_ALLOC(servedPlmn->list.array[0]->\
2066          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2067          list.array[0],sizeof( SliceSupportItem_t));
2068    if(servedPlmn->list.array[0]->\
2069          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2070          list.array[0] == NULLP)
2071    {
2072       return RFAILED;
2073    }
2074    servedPlmn->list.array[0]->\
2075       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2076       list.array[0]->sNSSAI.sST.size = sizeof(uint8_t);
2077    DU_ALLOC(servedPlmn->list.array[0]->\
2078          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2079          list.array[0]->sNSSAI.sST.buf,servedPlmn->list.array[0]->\
2080          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.list.array[0]->sNSSAI.sST.size);
2081    if(servedPlmn->list.array[0]->\
2082          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2083          list.array[0]->sNSSAI.sST.buf == NULLP)
2084    {
2085       return RFAILED;
2086    }
2087    servedPlmn->list.array[0]->\
2088       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2089       list.array[0]->sNSSAI.sST.buf[0] = 3;
2090    DU_ALLOC(servedPlmn->list.array[0]->\
2091          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2092          list.array[0]->sNSSAI.sD,sizeof(OCTET_STRING_t));
2093    if(servedPlmn->list.array[0]->\
2094          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2095          list.array[0]->sNSSAI.sD == NULLP)
2096    {
2097       return RFAILED;
2098    }
2099    servedPlmn->list.array[0]->\
2100       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2101       list.array[0]->sNSSAI.sD->size = 3*sizeof(uint8_t);
2102    DU_ALLOC(servedPlmn->list.array[0]->\
2103          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2104          list.array[0]->sNSSAI.sD->buf,servedPlmn->list.array[0]->\
2105          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2106          list.array[0]->sNSSAI.sD->size);
2107    if(servedPlmn->list.array[0]->\
2108          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2109          list.array[0]->sNSSAI.sD->buf == NULLP)
2110    {
2111       return RFAILED;
2112    }
2113    servedPlmn->list.array[0]->\
2114       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2115       list.array[0]->sNSSAI.sD->buf[0] = 3;
2116    servedPlmn->list.array[0]->\
2117       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2118       list.array[0]->sNSSAI.sD->buf[1] = 6;
2119    servedPlmn->list.array[0]->\
2120       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2121       list.array[0]->sNSSAI.sD->buf[2] = 9;
2122    return ROK;
2123 }
2124
2125 /*******************************************************************
2126  *
2127  * @brief Fills Nr Fdd Info required in ServCellInfo IE
2128  *
2129  * @details
2130  *
2131  *    Function : fillNrFddInfo
2132  *
2133  *    Functionality: Fills Nr Fdd Info required in ServCellInfo IE
2134  *
2135  * @params[in] Pointer to NR_Mode_Info_t *
2136  *
2137  * @return ROK     - success
2138  *         RFAILED - failure
2139  *
2140  *****************************************************************/
2141
2142 uint8_t fillNrFddInfo(NR_Mode_Info_t *nrFdd)
2143 {
2144    nrFdd->choice.fDD->uL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.\
2145       f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn;
2146    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.count = 1;
2147    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t*);
2148    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
2149          array, nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size);
2150    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2151    {
2152       return RFAILED;
2153    }
2154    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0], \
2155       sizeof(FreqBandNrItem_t));
2156    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2157    {
2158       return RFAILED;
2159    }
2160    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2161       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
2162       freqBand[0].nrFreqBand;
2163    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2164    nrFdd->choice.fDD->dL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.\
2165       dlNrFreqInfo.nrArfcn;
2166    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.count = 1;
2167    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
2168    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,nrFdd->\
2169          choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
2170    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2171    {
2172       return RFAILED;
2173    }
2174    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0],\
2175          sizeof(FreqBandNrItem_t));
2176    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2177    {
2178       return RFAILED;
2179    }
2180    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2181       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
2182       freqBand[0].nrFreqBand;
2183    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2184
2185    /*Transmission Bandwidth*/
2186    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2187       f1Mode.mode.fdd.ulTxBw.nrScs;
2188    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2189       f1Mode.mode.fdd.ulTxBw.nrb;
2190    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2191       f1Mode.mode.fdd.dlTxBw.nrScs;
2192    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2193       f1Mode.mode.fdd.dlTxBw.nrb;
2194
2195    return ROK;
2196 }
2197
2198 /*******************************************************************
2199  *
2200  * @brief Fills ServCellInfo IE
2201  *
2202  * @details
2203  *
2204  *    Function : fillServedCellInfo
2205  *
2206  *    Functionality: Fills ServCellInfo
2207  *
2208  * @params[in] Pointer to Served_Cell_Information_t *
2209  *
2210  * @return ROK     - success
2211  *         RFAILED - failure
2212  *
2213  *****************************************************************/
2214
2215 uint8_t fillServedCellInfo(Served_Cell_Information_t *srvCellInfo)
2216 {
2217    uint8_t tmp, ieIdx, ieListCnt;
2218
2219    /*nRCGI*/
2220    srvCellInfo->nRCGI.pLMN_Identity.size =3*sizeof(uint8_t);
2221    DU_ALLOC(srvCellInfo->nRCGI.pLMN_Identity.buf,\
2222          srvCellInfo->nRCGI.pLMN_Identity.size);
2223    if(srvCellInfo->nRCGI.pLMN_Identity.buf == NULLP)
2224    {
2225       return RFAILED;
2226    }
2227    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2228          srvCellInfo->nRCGI.pLMN_Identity.buf);
2229    srvCellInfo->nRCGI.nRCellIdentity.size =5*sizeof(uint8_t);
2230    DU_ALLOC(srvCellInfo->nRCGI.nRCellIdentity.buf,\
2231          srvCellInfo->nRCGI.nRCellIdentity.size);
2232    if(srvCellInfo->nRCGI.nRCellIdentity.buf == NULLP)
2233    {
2234       return RFAILED;
2235    }
2236    for (tmp = 0 ; tmp < srvCellInfo->\
2237          nRCGI.nRCellIdentity.size-1 ; tmp++)
2238    {
2239       srvCellInfo->nRCGI.nRCellIdentity.buf[tmp] = 0;
2240    }
2241    srvCellInfo->nRCGI.nRCellIdentity.buf[4] = 16;
2242    srvCellInfo->nRCGI.nRCellIdentity.bits_unused =4;
2243
2244    /*nRPCI*/
2245    srvCellInfo->nRPCI = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
2246
2247    /*servedPLMNs*/
2248    ieListCnt = 1;
2249    srvCellInfo->servedPLMNs.list.count = ieListCnt;
2250    srvCellInfo->servedPLMNs.list.size = ieListCnt*sizeof(ServedPLMNs_Item_t *);
2251    DU_ALLOC(srvCellInfo->servedPLMNs.list.array,\
2252          srvCellInfo->servedPLMNs.list.size);
2253    if(srvCellInfo->servedPLMNs.list.array == NULLP)
2254    {
2255       return RFAILED;
2256    }
2257    for(ieIdx=0; ieIdx < ieListCnt; ieIdx++)
2258    {
2259       DU_ALLOC(srvCellInfo->servedPLMNs.list.array[ieIdx],\
2260             sizeof(ServedPLMNs_Item_t));
2261       if(srvCellInfo->servedPLMNs.list.array[ieIdx]== NULLP)
2262       {
2263          return RFAILED;
2264       }
2265    }
2266    if(fillServedPlmns(&srvCellInfo->servedPLMNs))
2267    {
2268       return RFAILED;
2269    }
2270
2271    /*nR Mode Info with FDD*/
2272    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_fDD;
2273    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.fDD,\
2274          sizeof(FDD_Info_t));
2275    if(srvCellInfo->nR_Mode_Info.choice.fDD == NULLP)
2276    {
2277       return RFAILED;
2278    }
2279    if(fillNrFddInfo(&srvCellInfo->nR_Mode_Info))
2280       return RFAILED;
2281
2282    /*Measurement timing Config*/
2283    srvCellInfo->measurementTimingConfiguration.size = sizeof(uint8_t);
2284    DU_ALLOC(srvCellInfo->measurementTimingConfiguration.\
2285          buf,srvCellInfo->measurementTimingConfiguration.size);
2286    if(srvCellInfo->measurementTimingConfiguration.buf == NULLP)
2287    {
2288       return RFAILED;
2289    }
2290    srvCellInfo->measurementTimingConfiguration.\
2291          buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
2292
2293    return ROK;
2294 }
2295
2296 /*******************************************************************
2297  *
2298  * @brief Fills ServCellToModItem IE
2299  *
2300  * @details
2301  *
2302  *    Function : fillServCellToModItem
2303  *
2304  *    Functionality: Fills ServCellToModItem IE
2305  *
2306  * @params[in] Pointer to Served_Cells_To_Modify_Item_t *
2307  *
2308  * @return ROK     - success
2309  *         RFAILED - failure
2310  *
2311  *****************************************************************/
2312
2313 uint8_t fillServCellToModItem(Served_Cells_To_Modify_Item_t *modifyItem)
2314 {
2315    uint8_t ieIdx;
2316
2317    /*pLMN_Identity*/
2318    modifyItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2319    DU_ALLOC(modifyItem->oldNRCGI.pLMN_Identity.buf,modifyItem->oldNRCGI.pLMN_Identity.size);
2320    if(modifyItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2321    {
2322       return RFAILED;
2323    }
2324    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2325          modifyItem->oldNRCGI.pLMN_Identity.buf);
2326
2327    /*nRCellIdentity*/
2328    modifyItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2329    DU_ALLOC(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2330          modifyItem->oldNRCGI.nRCellIdentity.size);
2331    if(modifyItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2332    {
2333       return RFAILED;
2334    }
2335    for(ieIdx = 0; ieIdx < modifyItem->oldNRCGI.nRCellIdentity.size-1; ieIdx++)
2336    {
2337       modifyItem->oldNRCGI.nRCellIdentity.buf[ieIdx] = 0;
2338    }
2339    modifyItem->oldNRCGI.nRCellIdentity.buf[4] = 16;
2340    modifyItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
2341
2342    if(fillServedCellInfo(&modifyItem->served_Cell_Information))
2343       return RFAILED;
2344    else
2345       return ROK;
2346 }
2347
2348 /*******************************************************************
2349  *
2350  * @brief Builds ServCellToModList
2351  *
2352  * @details
2353  *
2354  *    Function : buildServCellToModList
2355  *
2356  *    Functionality: Builds the serv cell to Mod List
2357  *
2358  * @params[in] Pointer to Served_Cells_To_Modify_List_t *
2359  *
2360  * @return ROK     - success
2361  *         RFAILED - failure
2362  *
2363  *****************************************************************/
2364
2365 uint8_t buildServCellToModList(Served_Cells_To_Modify_List_t *cellsToModify)
2366 {
2367    uint8_t ieListCnt, ieIdx;
2368    Served_Cells_To_Modify_Item_t *modifyItem = NULLP;
2369
2370    ieListCnt = 1;
2371    cellsToModify->list.count = ieListCnt;
2372    cellsToModify->list.size = ieListCnt*sizeof(Served_Cells_To_Modify_ItemIEs_t *);
2373    DU_ALLOC(cellsToModify->list.array,cellsToModify->list.size);
2374    if(cellsToModify->list.array == NULLP)
2375    {
2376       return RFAILED;
2377    }
2378    for(ieIdx=0; ieIdx< ieListCnt; ieIdx++)
2379    {
2380       DU_ALLOC(cellsToModify->list.array[ieIdx],sizeof(Served_Cells_To_Modify_ItemIEs_t));
2381       if(cellsToModify->list.array[ieIdx] == NULLP)
2382       {
2383          return RFAILED;
2384       }
2385    }
2386    cellsToModify->list.array[0]->id = ProtocolIE_ID_id_Served_Cells_To_Modify_Item;
2387    cellsToModify->list.array[0]->criticality = Criticality_reject;
2388    cellsToModify->list.array[0]->value.present =\
2389       Served_Cells_To_Modify_ItemIEs__value_PR_Served_Cells_To_Modify_Item;
2390    modifyItem=&cellsToModify->list.array[0]->value.choice.Served_Cells_To_Modify_Item;
2391
2392    if(fillServCellToModItem(modifyItem))
2393       return RFAILED;
2394    else
2395       return ROK;
2396 }
2397 /*******************************************************************
2398  *
2399  * @brief filling the DeleteItemList
2400  *
2401  * @details
2402  *
2403  *    Function : fillCellToDeleteItem
2404  *
2405  *    Functionality: Filling the DeleteItemIe
2406  *
2407  * @params[in] Pointer to Served_Cells_To_Delete_ItemIEs_t
2408  *
2409  * @return ROK     - success
2410  *         RFAILED - failure
2411  *
2412  *****************************************************************/
2413 uint8_t fillCellToDeleteItem(struct Served_Cells_To_Delete_ItemIEs *deleteItemIe)
2414 {
2415    uint8_t arrIdx;
2416    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
2417
2418    deleteItemIe->id = ProtocolIE_ID_id_Served_Cells_To_Delete_Item;
2419    deleteItemIe->criticality = Criticality_reject;
2420    deleteItemIe->value.present =\
2421    Served_Cells_To_Delete_ItemIEs__value_PR_Served_Cells_To_Delete_Item;
2422    deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
2423
2424    /*pLMN_Identity*/
2425    deleteItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2426    DU_ALLOC(deleteItem->oldNRCGI.pLMN_Identity.buf,deleteItem->oldNRCGI.pLMN_Identity.size);
2427    if(deleteItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2428    {
2429       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2430       return RFAILED;
2431    }
2432    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2433          deleteItem->oldNRCGI.pLMN_Identity.buf);
2434
2435    /*nRCellIdentity*/
2436    deleteItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2437    DU_ALLOC(deleteItem->oldNRCGI.nRCellIdentity.buf,\
2438          deleteItem->oldNRCGI.nRCellIdentity.size);
2439    if(deleteItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2440    {
2441       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2442       return RFAILED;
2443    }
2444    for(arrIdx = 0; arrIdx < deleteItem->oldNRCGI.nRCellIdentity.size-1; arrIdx++)
2445    {
2446       deleteItem->oldNRCGI.nRCellIdentity.buf[arrIdx] = 0;
2447    }
2448    deleteItem->oldNRCGI.nRCellIdentity.buf[4] = 16;
2449    deleteItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
2450    return ROK;
2451 }
2452 /*******************************************************************
2453  *
2454  * @brief Builds ServCellToDeleteList
2455  *
2456  * @details
2457  *
2458  *    Function : buildServCellToDeleteList
2459  *
2460  *    Functionality: Builds the serv cell to delete List
2461  *
2462  * @params[in] Pointer to Served_Cells_To_Delete_List_t *
2463  *
2464  * @return ROK     - success
2465  *         RFAILED - failure
2466  *
2467  *****************************************************************/
2468
2469 uint8_t buildServCellToDeleteList(Served_Cells_To_Delete_List_t *cellsToDelete)
2470 {
2471    uint8_t ieListCnt, arrIdx;
2472
2473    ieListCnt = 1;
2474    cellsToDelete->list.count = ieListCnt;
2475    cellsToDelete->list.size = ieListCnt*sizeof(Served_Cells_To_Delete_ItemIEs_t *);
2476
2477    DU_ALLOC(cellsToDelete->list.array,cellsToDelete->list.size);
2478    if(cellsToDelete->list.array == NULLP)
2479    {
2480       DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2481       return RFAILED;
2482    }
2483
2484    for(arrIdx=0; arrIdx< ieListCnt; arrIdx++)
2485    {
2486       DU_ALLOC(cellsToDelete->list.array[arrIdx],sizeof(Served_Cells_To_Delete_ItemIEs_t));
2487       if(cellsToDelete->list.array[arrIdx] == NULLP)
2488       {
2489          DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2490          return RFAILED;
2491       }
2492    }
2493
2494    arrIdx=0;
2495    if(fillCellToDeleteItem((Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx]) !=ROK)
2496    {
2497       DU_LOG("\nERROR  -->  F1AP: buildServCellToDeleteList(): failed to fill Served_Cells_To_Delete_ItemIEs");
2498       return RFAILED;
2499    }
2500    return ROK;
2501 }
2502
2503 /*******************************************************************
2504  *
2505  * @brief Builds and sends the DUConfigUpdate
2506  *
2507  * @details
2508  *
2509  *    Function : BuildAndSendDUConfigUpdate
2510  *
2511  *    Functionality: Constructs the DU Update message and sends
2512  *                   it to the CU through SCTP.
2513  *
2514  * @params[in] void **buf,Buffer to which encoded pattern is written into
2515  * @params[in] int *size,size of buffer
2516  *
2517  * @return ROK     - success
2518  *         RFAILED - failure
2519  *
2520  * ****************************************************************/
2521 uint8_t BuildAndSendDUConfigUpdate(ServCellAction servCellAction)
2522 {
2523    uint8_t ret =0, ieIdx=0, elementCnt=0;
2524    bool memAlloctionFailure = false;
2525    F1AP_PDU_t                 *f1apDuCfg = NULLP;
2526    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
2527    asn_enc_rval_t encRetVal;     /* Encoder return value */
2528
2529    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2530    ret= RFAILED;
2531
2532    while(true)
2533    {
2534       DU_LOG("\nINFO   -->  F1AP : Building DU config update\n");
2535       /* Allocate the memory for F1DuCfg */
2536       DU_ALLOC(f1apDuCfg, sizeof(F1AP_PDU_t));
2537       if(f1apDuCfg == NULLP)
2538       {
2539          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2540          break;
2541       }
2542
2543       f1apDuCfg->present = F1AP_PDU_PR_initiatingMessage;
2544       DU_ALLOC(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2545       if(f1apDuCfg->choice.initiatingMessage == NULLP)
2546       {
2547          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2548          break;
2549       }
2550
2551       f1apDuCfg->choice.initiatingMessage->procedureCode = \
2552                                                            ProcedureCode_id_gNBDUConfigurationUpdate;
2553       f1apDuCfg->choice.initiatingMessage->criticality = Criticality_reject;
2554       f1apDuCfg->choice.initiatingMessage->value.present = \
2555                                                            InitiatingMessage__value_PR_GNBDUConfigurationUpdate;
2556       duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\
2557                     choice.GNBDUConfigurationUpdate;
2558       elementCnt = 3;
2559       duCfgUpdate->protocolIEs.list.count = elementCnt;
2560       duCfgUpdate->protocolIEs.list.size = \
2561                                            elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t*);
2562
2563       /* Initialize the F1Setup members */
2564       DU_ALLOC(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2565       if(duCfgUpdate->protocolIEs.list.array == NULLP)
2566       {
2567          DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2568          break;
2569       }
2570       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
2571       {
2572          DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx],sizeof(GNBDUConfigurationUpdateIEs_t));
2573          if(duCfgUpdate->protocolIEs.list.array[ieIdx] == NULLP)
2574          {
2575             DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2576             memAlloctionFailure = true;
2577             break;
2578          }
2579       }
2580
2581       if(memAlloctionFailure == true)
2582       {
2583          break;
2584       }
2585       /*TransactionID*/
2586       ieIdx = 0;
2587       duCfgUpdate->protocolIEs.list.array[ieIdx]->id=ProtocolIE_ID_id_TransactionID;
2588       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
2589       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2590       GNBDUConfigurationUpdateIEs__value_PR_TransactionID;
2591       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = TRANS_ID;
2592
2593       ieIdx++;
2594       if(servCellAction == SERV_CELL_TO_MODIFY)
2595       {
2596          /*Served Cell to Modify */
2597          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2598          ProtocolIE_ID_id_Served_Cells_To_Modify_List;
2599          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2600          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2601          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Modify_List;
2602          if(buildServCellToModList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2603                   Served_Cells_To_Modify_List))
2604          {
2605             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToModList");
2606             break;
2607          }
2608       }
2609       else
2610       {
2611          /*Served Cell to Delete */
2612          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2613          ProtocolIE_ID_id_Served_Cells_To_Delete_List;
2614          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2615          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2616          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Delete_List;
2617          if(buildServCellToDeleteList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2618          Served_Cells_To_Delete_List)!=ROK)
2619          {
2620             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToDeleteList");
2621             break;
2622          }
2623
2624       }
2625       // NOTE :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
2626       /*GNB DU ID */
2627       ieIdx++;
2628       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
2629       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
2630       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2631       GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID;
2632       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size = sizeof(uint8_t);
2633       DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2634             duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2635       if(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == NULLP)
2636       {
2637          DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): Memory allocation failed for GNB_DU_ID");
2638          break;
2639       }
2640       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] = duCfgParam.duId;
2641
2642       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
2643
2644       /* Encode the DU Config Update type as APER */
2645       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
2646       encBufSize = 0;
2647       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
2648
2649       /* Checking encode results */
2650       if(encRetVal.encoded == ENCODE_FAIL)
2651       {
2652          DU_LOG("ERROR  -->  F1AP : Could not encode DUConfigUpdate structure (at %s)\n",\
2653                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2654          break;
2655       }
2656       else
2657       {
2658          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DUConfigUpdate\n");
2659          for(ieIdx =0; ieIdx < encBufSize; ieIdx++)
2660          {
2661             printf("%x",encBuf[ieIdx]);
2662          }
2663       }
2664       /* Sending msg */
2665       if(sendF1APMsg() != ROK)
2666       {
2667          DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update failed");
2668          break;
2669       }
2670
2671       ret = ROK;
2672       break;
2673    }
2674
2675    addToReservedF1apPduList(TRANS_ID,f1apDuCfg);
2676    return ret;
2677 }
2678
2679
2680 /*******************************************************************
2681  *
2682  * @brief free the ULRRCMessageTransfer
2683  *
2684  * @details
2685  *
2686  *    Function : FreeULRRCMessageTransfer
2687  *
2688  *    Functionality: Deallocating the memory of variable allocated in
2689  *                      FreeULRRCMessageTransfer
2690  *
2691  * @params[in]
2692  *
2693  * @return ROK     - void
2694  *
2695  ******************************************************************/
2696 void FreeULRRCMessageTransfer( F1AP_PDU_t *f1apMsg)
2697 {
2698    uint8_t idx1;
2699    ULRRCMessageTransfer_t  *ulRRCMsg;
2700
2701    if(f1apMsg != NULLP)
2702    {
2703       if(f1apMsg->choice.initiatingMessage != NULLP)
2704       {
2705          ulRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2706          if(ulRRCMsg->protocolIEs.list.array != NULLP)
2707          {
2708             for(idx1=0;idx1<ulRRCMsg->protocolIEs.list.count;idx1++)
2709             {
2710                if(ulRRCMsg->protocolIEs.list.array[idx1] != NULLP)
2711                {
2712                   if(ulRRCMsg->protocolIEs.list.array[idx1]->value.present ==
2713                         ULRRCMessageTransferIEs__value_PR_RRCContainer)
2714                   {
2715                      DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2716                            ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2717                   }
2718                   DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1],sizeof(ULRRCMessageTransferIEs_t));
2719                }
2720             }
2721             DU_FREE(ulRRCMsg->protocolIEs.list.array,ulRRCMsg->protocolIEs.list.size );
2722          }
2723          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2724       }
2725       DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
2726    }
2727 }
2728 /*******************************************************************
2729  *
2730  * @brief Builds and sends the ULRRCMessageTransfer
2731  *
2732  * @details
2733  *
2734  *    Function : BuildAndSendULRRCMessageTransfer
2735  *
2736  *    Functionality: Constructs the UL RRC Message Transfer and sends
2737  *                   it to the CU through SCTP.
2738  *
2739  * @params[in]
2740  *
2741  * @return ROK     - success
2742  *         RFAILED - failure
2743  *
2744  * ****************************************************************/
2745 uint8_t BuildAndSendULRRCMessageTransfer(DuUeCb  ueCb, uint8_t lcId, \
2746       uint16_t msgLen, uint8_t *rrcMsg)
2747 {
2748    uint8_t   elementCnt =0;
2749    uint8_t   idx1 =0;
2750    uint8_t   idx =0;
2751    F1AP_PDU_t                   *f1apMsg = NULLP;
2752    ULRRCMessageTransfer_t       *ulRRCMsg = NULLP;
2753    asn_enc_rval_t               encRetVal;        /* Encoder return value */
2754    uint8_t ret =RFAILED;
2755
2756    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2757
2758    while(true)
2759    {
2760       DU_LOG("\n INFO   -->  F1AP : Building UL RRC Message Transfer Message\n");
2761
2762       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
2763       if(f1apMsg == NULLP)
2764       {
2765          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2766          break;
2767       }
2768       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
2769       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2770       if(f1apMsg->choice.initiatingMessage == NULLP)
2771       {
2772          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
2773          break;
2774       }
2775       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_ULRRCMessageTransfer;
2776       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
2777       f1apMsg->choice.initiatingMessage->value.present = \
2778                                                          InitiatingMessage__value_PR_ULRRCMessageTransfer;
2779       ulRRCMsg =
2780          &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2781       elementCnt = 4;
2782       ulRRCMsg->protocolIEs.list.count = elementCnt;
2783       ulRRCMsg->protocolIEs.list.size = \
2784                                         elementCnt * sizeof(ULRRCMessageTransferIEs_t *);
2785
2786       /* Initialize the F1Setup members */
2787       DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size);
2788       if(ulRRCMsg->protocolIEs.list.array == NULLP)
2789       {
2790          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
2791          break;
2792       }
2793       for(idx=0; idx<elementCnt; idx++)
2794       {
2795          DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t));
2796          if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP)
2797          {
2798             break;
2799          }
2800       }
2801
2802       idx1 = 0;
2803
2804       /*GNB CU UE F1AP ID*/
2805       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
2806       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2807       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2808                                                               ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
2809       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = ueCb.gnbCuUeF1apId;
2810
2811       /*GNB DU UE F1AP ID*/
2812       idx1++;
2813       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
2814       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2815       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2816                                                               ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
2817       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = ueCb.gnbDuUeF1apId;
2818
2819       /*SRBID*/
2820       idx1++;
2821       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
2822       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2823       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2824                                                               ULRRCMessageTransferIEs__value_PR_SRBID;
2825       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = lcId;
2826
2827       /*RRCContainer*/
2828       idx1++;
2829       ulRRCMsg->protocolIEs.list.array[idx1]->id  = ProtocolIE_ID_id_RRCContainer;
2830       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2831       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2832                                                               ULRRCMessageTransferIEs__value_PR_RRCContainer;
2833       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size = msgLen;
2834       DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2835             ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
2836       if(!ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
2837       {
2838          DU_LOG(" ERROR  -->  F1AP : Memory allocation for BuildAndSendULRRCMessageTransfer failed");
2839          break;
2840       }
2841       memset(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, 0, msgLen);
2842       memcpy(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, \
2843             rrcMsg, ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2844
2845       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2846
2847       /* Encode the F1SetupRequest type as APER */
2848       memset(encBuf, 0, ENC_BUF_MAX_LEN);
2849       encBufSize = 0;
2850       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
2851             encBuf);
2852       /* Encode results */
2853       if(encRetVal.encoded == ENCODE_FAIL)
2854       {
2855          DU_LOG( "\nERROR  -->  F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
2856                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2857          break;
2858       }
2859       else
2860       {
2861          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
2862          for(int i=0; i< encBufSize; i++)
2863          {
2864             printf("%x",encBuf[i]);
2865          }
2866       }
2867
2868       /* Sending  msg  */
2869       if(sendF1APMsg()  !=      ROK)
2870       {
2871          DU_LOG("\nERROR  -->   F1AP : Sending  UL RRC Message Transfer Failed");
2872          break;
2873       }
2874       ret = ROK;
2875       break;
2876    }
2877    FreeULRRCMessageTransfer(f1apMsg);
2878
2879    return ret;
2880 }/* End of BuildAndSendULRRCMessageTransfer*/
2881
2882 /*******************************************************************
2883  *
2884  * @brief Builds tag config
2885  *
2886  * @details
2887  *
2888  *    Function : BuildTagConfig
2889  *
2890  *    Functionality: Builds tag config in MacCellGroupConfig
2891  *
2892  * @params[in] TAG_Config *tag_Config
2893  *
2894  * @return ROK     - success
2895  *         RFAILED - failure
2896  *
2897  * ****************************************************************/
2898 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
2899 {
2900    struct TAG_Config__tag_ToAddModList *tagList;
2901    uint8_t                     idx, elementCnt;
2902
2903    tagConfig->tag_ToReleaseList = NULLP;
2904    tagConfig->tag_ToAddModList = NULLP;
2905    DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
2906    if(!tagConfig->tag_ToAddModList)
2907    {
2908       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2909       return RFAILED;
2910    }
2911
2912    elementCnt = 1; //ODU_VALUE_ONE;
2913    tagList = tagConfig->tag_ToAddModList;
2914    tagList->list.count = elementCnt;
2915    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
2916
2917    tagList->list.array = NULLP;
2918    DU_ALLOC(tagList->list.array, tagList->list.size);
2919    if(!tagList->list.array)
2920    {
2921       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2922       return RFAILED;
2923    }
2924
2925    for(idx=0; idx<tagList->list.count; idx++)
2926    {
2927       tagList->list.array[idx] = NULLP;
2928       DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
2929       if(!tagList->list.array[idx])
2930       {
2931          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2932          return RFAILED;
2933       }
2934    }
2935
2936    idx = 0;
2937    tagList->list.array[idx]->tag_Id = TAG_ID;
2938    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
2939
2940    return ROK;
2941 }
2942
2943 /*******************************************************************
2944  *
2945  * @brief Builds PHR Config
2946  *
2947  * @details
2948  *
2949  *    Function : BuildPhrConfig
2950  *
2951  *    Functionality: Builds phrConfig in MacCellGroupConfig
2952  *
2953  * @params[in] PHR Config *
2954  *
2955  * @return ROK     - success
2956  *         RFAILED - failure
2957  *
2958  * ****************************************************************/
2959 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
2960 {
2961
2962    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
2963    phrConfig->choice.setup = NULLP;
2964    DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
2965    if(!phrConfig->choice.setup)
2966    {
2967       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
2968       return RFAILED;
2969    }
2970
2971    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
2972    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
2973    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
2974    phrConfig->choice.setup->multiplePHR              = false;
2975    phrConfig->choice.setup->dummy                    = false;
2976    phrConfig->choice.setup->phr_Type2OtherCell       = false;
2977    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
2978
2979    return ROK;
2980 }
2981
2982 /*******************************************************************
2983  *
2984  * @brief Builds BSR Config
2985  *
2986  * @details
2987  *
2988  *    Function : BuildBsrConfig
2989  *
2990  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
2991  *
2992  * @params[in] BSR_Config *bsrConfig
2993  *
2994  * @return ROK     - success
2995  *         RFAILED - failure
2996  *
2997  * ****************************************************************/
2998 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
2999 {
3000    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
3001    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
3002    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
3003
3004    return ROK;
3005 }
3006
3007 /*******************************************************************
3008  *
3009  * @brief Builds scheduling request config
3010  *
3011  * @details
3012  *
3013  *    Function : BuildSchedulingReqConfig
3014  *
3015  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
3016  *
3017  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
3018  *
3019  * @return ROK     - success
3020  *         RFAILED - failure
3021  *
3022  * ****************************************************************/
3023 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
3024 {
3025    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
3026    uint8_t                     idx, elementCnt;
3027
3028    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
3029    DU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
3030          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
3031    if(!schedulingRequestConfig->schedulingRequestToAddModList)
3032    {
3033       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3034       return RFAILED;
3035    }
3036
3037    elementCnt = 1; //ODU_VALUE_ONE;
3038    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
3039    schReqList->list.count = elementCnt;
3040    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
3041
3042    schReqList->list.array = NULLP;
3043    DU_ALLOC(schReqList->list.array, schReqList->list.size);
3044    if(!schReqList->list.array)
3045    {
3046       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3047       return RFAILED;
3048    }
3049
3050    for(idx=0;idx<schReqList->list.count; idx++)
3051    {
3052       schReqList->list.array[idx] = NULLP;
3053       DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
3054       if(!schReqList->list.array[idx])
3055       {
3056          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3057          return RFAILED;
3058       }
3059    }
3060
3061    idx = 0;
3062    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
3063
3064    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
3065    DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
3066    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
3067    {
3068       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3069       return RFAILED;
3070    }
3071    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
3072    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
3073    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
3074
3075    return ROK;
3076 }
3077
3078 /*******************************************************************
3079  *
3080  * @brief Builds RLC Config
3081  *
3082  * @details
3083  *
3084  *    Function : BuildRlcConfig
3085  *
3086  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
3087  *
3088  * @params[in] RLC_Config *rlcConfig
3089  *
3090  * @return ROK     - success
3091  *         RFAILED - failure
3092  *
3093  * ****************************************************************/
3094 uint8_t BuildRlcConfig(struct RLC_Config *rlcConfig)
3095 {
3096
3097    rlcConfig->present = RLC_Config_PR_am;
3098
3099    rlcConfig->choice.am = NULLP;
3100    DU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
3101    if(!rlcConfig->choice.am)
3102    {
3103       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3104       return RFAILED;
3105    }
3106
3107    /* UL */
3108    rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
3109    DU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3110    if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
3111    {
3112       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3113       return RFAILED;
3114    }
3115    *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3116    rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
3117    rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
3118    rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
3119    rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
3120
3121    /* DL */
3122    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
3123    DU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3124    if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
3125    {
3126       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3127       return RFAILED;
3128    }
3129    *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3130    rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
3131    rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
3132
3133    return ROK;
3134 }
3135
3136 /*******************************************************************
3137  *
3138  * @brief Builds MAC LC Config
3139  *
3140  * @details
3141  *
3142  *    Function : BuildMacLCConfig
3143  *
3144  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
3145  *
3146  * @params[in] struct LogicalChannelConfig macLcConfig
3147  *
3148  * @return ROK     - success
3149  *         RFAILED - failure
3150  *
3151  * ****************************************************************/
3152 uint8_t BuildMacLCConfig(struct LogicalChannelConfig *macLcConfig)
3153 {
3154
3155    macLcConfig->ul_SpecificParameters = NULLP;
3156    DU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
3157    if(!macLcConfig->ul_SpecificParameters)
3158    {
3159       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3160       return RFAILED;
3161    }
3162
3163    macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
3164    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     PRIORTISIED_BIT_RATE;
3165    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     BUCKET_SIZE_DURATION;
3166    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
3167    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
3168    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
3169    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
3170
3171    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
3172    DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
3173    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
3174    {
3175       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3176       return RFAILED;
3177    }
3178    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
3179
3180    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
3181    DU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
3182    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
3183    {
3184       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3185       return RFAILED;
3186    }
3187    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
3188
3189    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
3190    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
3191    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
3192
3193    return ROK;
3194 }
3195
3196 /*******************************************************************
3197  *
3198  * @brief Builds RLC Bearer to Add/Mod list
3199  *
3200  * @details
3201  *
3202  *    Function :BuildRlcBearerToAddModList
3203  *
3204  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
3205  *
3206  * @params[in] rlc_BearerToAddModList
3207  *
3208  * @return ROK     - success
3209  *         RFAILED - failure
3210  *
3211  * ****************************************************************/
3212 uint8_t BuildRlcBearerToAddModList(struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
3213 {
3214    uint8_t                     idx, elementCnt;
3215
3216    elementCnt = 1;
3217    rlcBearerList->list.count = elementCnt;
3218    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
3219
3220    rlcBearerList->list.array = NULLP;
3221    DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
3222    if(!rlcBearerList->list.array)
3223    {
3224       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3225       return RFAILED;
3226    }
3227
3228    for(idx=0; idx<rlcBearerList->list.count; idx++)
3229    {
3230       rlcBearerList->list.array[idx] = NULLP;
3231       DU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
3232       if(!rlcBearerList->list.array[idx])
3233       {
3234          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3235          return RFAILED;
3236       }
3237    }
3238
3239    idx = 0;
3240    rlcBearerList->list.array[idx]->logicalChannelIdentity = SRB1_LCID;
3241
3242    DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, \
3243       sizeof(struct RLC_BearerConfig__servedRadioBearer));
3244    if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3245    {
3246       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3247       return RFAILED;
3248    }
3249
3250    rlcBearerList->list.array[idx]->servedRadioBearer->present = \
3251       RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
3252    rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = \
3253       SRB1_LCID;
3254
3255    rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3256    rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3257    DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3258    if(!rlcBearerList->list.array[idx]->rlc_Config)
3259    {
3260       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3261       return RFAILED;
3262    }
3263
3264    if(BuildRlcConfig(rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3265    {
3266       DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3267       return RFAILED;
3268    }
3269
3270    rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3271    DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, \
3272       sizeof(struct LogicalChannelConfig));
3273    if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3274    {
3275       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3276       return RFAILED;
3277    }
3278
3279    if(BuildMacLCConfig(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3280    {
3281       DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3282       return RFAILED;
3283    }
3284
3285    return ROK;
3286 }
3287
3288 /*******************************************************************
3289  *
3290  * @brief Build Control resource set to add/modify list
3291  *
3292  * @details
3293  *
3294  *    Function : BuildControlRSetToAddModList
3295  *
3296  *    Functionality: Build Control resource set to add/modify list
3297  *
3298  * @params[in]
3299  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3300  *
3301  * @return ROK     - success
3302  *         RFAILED - failure
3303  *
3304  * ****************************************************************/
3305    uint8_t BuildControlRSetToAddModList
3306 (
3307  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3308  )
3309 {
3310    uint8_t idx;
3311    uint8_t elementCnt;
3312    uint8_t numBytes, bitsUnused;
3313    struct ControlResourceSet *controlRSet;
3314    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3315    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3316
3317
3318    elementCnt = 1;
3319    controlRSetList->list.count = elementCnt;
3320    controlRSetList->list.size = \
3321                                 elementCnt * sizeof(struct ControlResourceSet *);
3322
3323    controlRSetList->list.array = NULLP;
3324    DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3325    if(!controlRSetList->list.array)
3326    {
3327       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3328       return RFAILED;
3329    }
3330
3331    for(idx = 0; idx < elementCnt; idx++)
3332    {
3333       controlRSetList->list.array[idx] = NULLP;
3334       DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3335       if(!controlRSetList->list.array[idx])
3336       {
3337          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3338          return RFAILED;
3339       }
3340    }
3341
3342    idx=0;
3343    controlRSet = controlRSetList->list.array[idx];
3344
3345    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3346
3347    /* size 6 bytes
3348     * 3 LSBs unsued
3349     * Bit string stored ff0000000000
3350     */
3351    numBytes = 6;
3352    bitsUnused = 3;
3353    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3354
3355    controlRSet->frequencyDomainResources.buf = NULLP;
3356    DU_ALLOC(controlRSet->frequencyDomainResources.buf, \
3357          controlRSet->frequencyDomainResources.size);
3358    if(!controlRSet->frequencyDomainResources.buf)
3359    {
3360       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3361       return RFAILED;
3362    }
3363
3364    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3365    coreset0EndPrb = CORESET0_END_PRB;
3366    coreset1StartPrb = coreset0EndPrb + 6;
3367    coreset1NumPrb = CORESET1_NUM_PRB;
3368    /* calculate the PRBs */
3369    freqDomRscAllocType0(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3370    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3371    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3372
3373    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3374    controlRSet->cce_REG_MappingType.present = \
3375                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3376
3377    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3378    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3379    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3380    controlRSet->tci_PresentInDCI = NULLP;
3381 #if 0
3382    uint8_t tciStateIdx;
3383
3384    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3385          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3386    if(!controlRset->tci_StatesPDCCH_ToAddList)
3387    {
3388       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3389       return RFAILED;
3390    }
3391
3392    elementCnt = 1;
3393    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3394    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3395    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3396          controlRset->tci_StatesPDCCH_ToAddList->list.size)
3397       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3398       {
3399          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3400          return RFAILED;
3401       }
3402
3403    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3404    {
3405       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3406       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3407       {
3408          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3409          return RFAILED;
3410       }
3411    }
3412
3413    tciStateIdx = 0;
3414    /* TODO */
3415    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3416
3417    DU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3418    if(!controlRset->tci_PresentInDCI)
3419    {
3420       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3421       return RFAILED;
3422    }
3423    /* TODO */
3424    *(controlRset->tci_PresentInDCI);
3425 #endif
3426
3427    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3428    DU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3429    if(!controlRSet->pdcch_DMRS_ScramblingID)
3430    {
3431       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3432       return RFAILED;
3433    }
3434    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3435
3436    return ROK;
3437 } /* End BuildControlRSetToAddModList */
3438
3439 /*******************************************************************
3440  *
3441  * @brief Build search space to add/modify list
3442  *
3443  * @details
3444  *
3445  *    Function : BuildSearchSpcToAddModList
3446  *
3447  *    Functionality: Build search space to add/modify list
3448  *
3449  * @params[in]
3450  * @return ROK     - success
3451  *         RFAILED - failure
3452  *
3453  * ****************************************************************/
3454    uint8_t BuildSearchSpcToAddModList
3455 (
3456  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
3457  )
3458 {
3459    uint8_t idx;
3460    uint8_t numBytes;
3461    uint8_t byteIdx;
3462    uint8_t bitsUnused;
3463    uint8_t elementCnt;
3464    struct SearchSpace *searchSpc;
3465
3466    elementCnt = 1;
3467    searchSpcList->list.count = elementCnt;
3468    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3469
3470    searchSpcList->list.array = NULLP;
3471    DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3472    if(!searchSpcList->list.array)
3473    {
3474       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3475       return RFAILED;
3476    }
3477
3478    for(idx = 0; idx < elementCnt; idx++)
3479    {
3480       searchSpcList->list.array[idx] = NULLP;
3481       DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3482       if(!searchSpcList->list.array[idx])
3483       {
3484          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3485          return RFAILED;
3486       }
3487    }
3488
3489    idx = 0;
3490    searchSpc = searchSpcList->list.array[idx];
3491
3492    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3493
3494    searchSpc->controlResourceSetId = NULLP;
3495    DU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3496    if(!searchSpc->controlResourceSetId)
3497    {
3498       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3499       return RFAILED;
3500    }
3501    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3502
3503    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3504    DU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
3505          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3506    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3507    {
3508       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3509       return RFAILED;
3510    }
3511    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
3512                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3513
3514    searchSpc->duration = NULLP;
3515    searchSpc->monitoringSymbolsWithinSlot = NULLP;
3516    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3517    if(!searchSpc->monitoringSymbolsWithinSlot)
3518    {
3519       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3520       return RFAILED;
3521    }
3522
3523    /* Values taken from reference logs :
3524     * size 2 bytes
3525     * 2 LSBs unsued
3526     * Bit string stores 8000
3527     */
3528    numBytes = 2;
3529    bitsUnused = 2;
3530
3531    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3532    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3533    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
3534          searchSpc->monitoringSymbolsWithinSlot->size);
3535    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3536    {
3537       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3538       return RFAILED;
3539    }
3540
3541    byteIdx = 0;
3542    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
3543                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3544    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3545    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3546
3547    searchSpc->nrofCandidates = NULLP;
3548    DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3549    if(!searchSpc->nrofCandidates)
3550    {
3551       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3552       return RFAILED;
3553    }
3554
3555    searchSpc->nrofCandidates->aggregationLevel1 = \
3556                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3557    searchSpc->nrofCandidates->aggregationLevel2 = \
3558                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3559    searchSpc->nrofCandidates->aggregationLevel4 = \
3560                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3561    searchSpc->nrofCandidates->aggregationLevel8 = \
3562                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3563    searchSpc->nrofCandidates->aggregationLevel16 = \
3564                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3565
3566    searchSpc->searchSpaceType = NULLP;
3567    DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3568    if(!searchSpc->searchSpaceType)
3569    {
3570       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3571       return RFAILED;
3572    }
3573
3574    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3575
3576    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3577    DU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
3578          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3579    if(!searchSpc->searchSpaceType->choice.ue_Specific)
3580    {
3581       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3582       return RFAILED;
3583    }
3584    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
3585                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3586
3587    return ROK;
3588 }/* End BuildSearchSpcToAddModList */
3589
3590 /*******************************************************************
3591  *
3592  * @brief Builds BWP DL dedicated PDCCH config
3593  *
3594  * @details
3595  *
3596  *    Function : BuildBWPDlDedPdcchCfg
3597  *
3598  *    Functionality: Builds BWP DL dedicated PDCCH config
3599  *
3600  * @params[in] struct PDCCH_Config *pdcchCfg
3601  *
3602  * @return ROK     - success
3603  *         RFAILED - failure
3604  *
3605  * ****************************************************************/
3606 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
3607 {
3608    pdcchCfg->controlResourceSetToAddModList = NULLP;
3609    DU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
3610          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3611    if(!pdcchCfg->controlResourceSetToAddModList)
3612    {
3613       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3614       return RFAILED;
3615    }
3616
3617    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
3618    {
3619       return RFAILED;
3620    }
3621
3622    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3623
3624    pdcchCfg->searchSpacesToAddModList = NULLP;
3625    DU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3626          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3627    if(!pdcchCfg->searchSpacesToAddModList)
3628    {
3629       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3630       return RFAILED;
3631    }
3632
3633    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3634    {
3635       return RFAILED;
3636    }
3637
3638    pdcchCfg->searchSpacesToReleaseList = NULLP;
3639    pdcchCfg->downlinkPreemption = NULLP;
3640    pdcchCfg->tpc_PUSCH = NULLP;
3641    pdcchCfg->tpc_PUCCH = NULLP;
3642    pdcchCfg->tpc_SRS = NULLP;
3643
3644    return ROK;
3645 }
3646
3647 /*******************************************************************
3648  *
3649  * @brief Builds DMRS DL PDSCH Mapping type A
3650  *
3651  * @details
3652  *
3653  *    Function : BuildDMRSDLPdschMapTypeA
3654  *
3655  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3656  *
3657  * @params[in]
3658  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3659  * @return ROK     - success
3660  *         RFAILED - failure
3661  *
3662  * ****************************************************************/
3663    uint8_t BuildDMRSDLPdschMapTypeA
3664 (
3665  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3666  )
3667 {
3668    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3669    dmrsDlCfg->choice.setup = NULLP;
3670    DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3671    if(!dmrsDlCfg->choice.setup)
3672    {
3673       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3674       return RFAILED;
3675    }
3676
3677    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3678    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3679    DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3680    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3681    {
3682       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3683       return RFAILED;
3684    }
3685    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3686
3687    dmrsDlCfg->choice.setup->maxLength = NULLP;
3688    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3689    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3690    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3691
3692    return ROK;
3693 }
3694
3695 /*******************************************************************
3696  *
3697  * @brief Builds TCI states to add/modify list
3698  *
3699  * @details
3700  *
3701  *    Function : BuildTCIStatesToAddModList
3702  *
3703  *    Functionality:Builds TCI states to add/modify list
3704  *
3705  * @params[in]
3706  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3707  *
3708  * @return ROK     - success
3709  *         RFAILED - failure
3710  *
3711  * ****************************************************************/
3712 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3713 {
3714    return ROK;
3715 }
3716
3717 /*******************************************************************
3718  *
3719  * @brief Builds PDSCH time domain allocation list
3720  *
3721  * @details
3722  *
3723  *    Function : BuildPdschTimeDomAllocList
3724  *
3725  *    Functionality: Builds PDSCH time domain allocation list
3726  *
3727  * @params[in]
3728  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3729  *
3730  * @return ROK     - success
3731  *         RFAILED - failure
3732  *
3733  * ****************************************************************/
3734    uint8_t BuildPdschTimeDomAllocList
3735 (
3736  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3737  )
3738 {
3739    uint8_t idx;
3740    uint8_t elementCnt;
3741    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3742
3743    timeDomAllocList->present = \
3744                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3745
3746    timeDomAllocList->choice.setup = NULLP;
3747    DU_ALLOC(timeDomAllocList->choice.setup, \
3748          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3749    if(!timeDomAllocList->choice.setup)
3750    {
3751       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3752       return RFAILED;
3753    }
3754
3755    elementCnt = 2;
3756    timeDomAllocList->choice.setup->list.count = elementCnt;
3757    timeDomAllocList->choice.setup->list.size = \
3758                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3759
3760    timeDomAllocList->choice.setup->list.array = NULLP;
3761    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3762          timeDomAllocList->choice.setup->list.size);
3763    if(!timeDomAllocList->choice.setup->list.array)
3764    {
3765       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3766       return RFAILED;
3767    }
3768
3769    for(idx = 0; idx < elementCnt; idx++)
3770    {
3771       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3772       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3773             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3774       if(!timeDomAllocList->choice.setup->list.array[idx])
3775       {
3776          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3777          return RFAILED;
3778       }
3779    }
3780
3781    idx = 0;
3782    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3783    DU_ALLOC(timeDomAlloc->k0, sizeof(long));
3784    if(!timeDomAlloc->k0)
3785    {
3786       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3787       return RFAILED;
3788    }
3789    *(timeDomAlloc->k0) = 0;
3790    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3791    timeDomAlloc->startSymbolAndLength = \
3792                                         calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
3793
3794    idx++;
3795    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3796    DU_ALLOC(timeDomAlloc->k0, sizeof(long));
3797    if(!timeDomAlloc->k0)
3798    {
3799       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3800       return RFAILED;
3801    }
3802    *(timeDomAlloc->k0) = 1;
3803    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3804    timeDomAlloc->startSymbolAndLength = calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
3805
3806    return ROK;
3807 }
3808
3809 /*******************************************************************
3810  *
3811  * @brief Builds PDSCH PRB Bundling type
3812  *
3813  * @details
3814  *
3815  *    Function : BuildPdschPrbBundlingType
3816  *
3817  *    Functionality: Builds PDSCH PRB Bundling type
3818  *
3819  * @params[in]
3820  * struct PDSCH_Config__prb_BundlingType *prbBndlType
3821  *
3822  * @return ROK     - success
3823  *         RFAILED - failure
3824  *
3825  * ****************************************************************/
3826    uint8_t BuildPdschPrbBundlingType
3827 (
3828  struct PDSCH_Config__prb_BundlingType *prbBndlType
3829  )
3830 {
3831    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
3832
3833    prbBndlType->choice.staticBundling = NULLP;
3834    DU_ALLOC(prbBndlType->choice.staticBundling, \
3835          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
3836    if(!prbBndlType->choice.staticBundling)
3837    {
3838       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
3839       return RFAILED;
3840    }
3841    prbBndlType->choice.staticBundling->bundleSize = NULLP;
3842
3843    return ROK;
3844 }
3845
3846 /*******************************************************************
3847  *
3848  * @brief Builds BWP DL dedicated PDSCH config
3849  *
3850  * @details
3851  *
3852  *    Function : BuildBWPDlDedPdschCfg
3853  *
3854  *    Functionality: Builds BWP DL dedicated PDSCH config
3855  *
3856  * @params[in] struct PDSCH_Config *pdschCfg
3857  *
3858  * @return ROK     - success
3859  *         RFAILED - failure
3860  *
3861  * ****************************************************************/
3862 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
3863 {
3864    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
3865
3866    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
3867    DU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
3868          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
3869    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
3870    {
3871       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3872       return RFAILED;
3873    }
3874
3875    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
3876    {
3877       return RFAILED;
3878    }
3879
3880    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
3881    pdschCfg->tci_StatesToAddModList = NULLP;
3882    pdschCfg->tci_StatesToReleaseList = NULLP;
3883    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
3884 #if 0
3885    DU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
3886    if(!pdschCfg->tci_StatesToAddModList)
3887    {
3888       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3889       return RFAILED;
3890    }
3891    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
3892    {
3893       return RFAILED;
3894    }
3895 #endif
3896
3897    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
3898
3899    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
3900    DU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
3901          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
3902    if(!pdschCfg->pdsch_TimeDomainAllocationList)
3903    {
3904       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3905       return RFAILED;
3906    }
3907
3908    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
3909    {
3910       return RFAILED;
3911    }
3912
3913    pdschCfg->pdsch_AggregationFactor = NULLP;
3914    pdschCfg->rateMatchPatternToAddModList = NULLP;
3915    pdschCfg->rateMatchPatternToReleaseList = NULLP;
3916    pdschCfg->rateMatchPatternGroup1 = NULLP;
3917    pdschCfg->rateMatchPatternGroup2 = NULLP;
3918    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
3919    pdschCfg->mcs_Table = NULLP;
3920
3921    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
3922    DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
3923    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
3924    {
3925       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3926       return RFAILED;
3927    }
3928    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
3929
3930    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
3931    {
3932       return RFAILED;
3933    }
3934
3935    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
3936    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
3937    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3938    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3939    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3940    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3941    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
3942
3943    return ROK;
3944 }
3945
3946 /*******************************************************************
3947  *
3948  * @brief Builds intitial DL BWP
3949  * @details
3950  *
3951  *    Function : BuildInitialDlBWP
3952  *
3953  *    Functionality: Builds intitial DL BWP in spCellCfgDed
3954  *
3955  * @params[in] BWP_DownlinkDedicated_t *dlBwp
3956  *
3957  * @return ROK     - success
3958  *         RFAILED - failure
3959  *
3960  * ****************************************************************/
3961 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
3962 {
3963    dlBwp->pdcch_Config = NULLP;
3964    DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
3965    if(!dlBwp->pdcch_Config)
3966    {
3967       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3968       return RFAILED;
3969    }
3970    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
3971
3972    dlBwp->pdcch_Config->choice.setup = NULLP;
3973    DU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
3974    if(!dlBwp->pdcch_Config->choice.setup)
3975    {
3976       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3977       return RFAILED;
3978    }
3979    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
3980    {
3981       return RFAILED;
3982    }
3983
3984    dlBwp->pdsch_Config = NULLP;
3985    DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
3986    if(!dlBwp->pdsch_Config)
3987    {
3988       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3989       return RFAILED;
3990    }
3991    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
3992
3993    dlBwp->pdsch_Config->choice.setup = NULLP;
3994    DU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
3995    if(!dlBwp->pdsch_Config->choice.setup)
3996    {
3997       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3998       return RFAILED;
3999    }
4000
4001    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
4002    {
4003       return RFAILED;
4004    }
4005
4006    dlBwp->sps_Config = NULLP;
4007    dlBwp->radioLinkMonitoringConfig = NULLP;
4008    return ROK;
4009 }
4010
4011 /*******************************************************************
4012  *
4013  * @brief Builds DMRS UL Pusch Mapping type A
4014  *
4015  * @details
4016  *
4017  *    Function : BuildDMRSULPuschMapTypeA
4018  *
4019  *    Functionality: Builds DMRS UL Pusch Mapping type A
4020  *
4021  * @params[in]
4022  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4023  * @return ROK     - success
4024  *         RFAILED - failure
4025  *
4026  * ****************************************************************/
4027    uint8_t BuildDMRSULPuschMapTypeA
4028 (
4029  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4030  )
4031 {
4032    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
4033    dmrsUlCfg->choice.setup= NULLP;
4034    DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
4035    if(!dmrsUlCfg->choice.setup)
4036    {
4037       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4038       return RFAILED;
4039    }
4040
4041    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
4042    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
4043    DU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
4044    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4045    {
4046       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4047       return RFAILED;
4048    }
4049    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
4050
4051    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
4052    dmrsUlCfg->choice.setup->maxLength = NULLP;
4053    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
4054    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
4055          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4056    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4057    {
4058       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4059       return RFAILED;
4060    }
4061
4062    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
4063    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4064          sizeof(long));
4065    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
4066    {
4067       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4068       return RFAILED;
4069    }
4070    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
4071
4072    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
4073    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
4074    return ROK;
4075 }
4076
4077 /*******************************************************************
4078  *
4079  * @brief Build PUSCH time domain allocation list
4080  *
4081  * @details
4082  *
4083  *    Function : BuildPuschTimeDomAllocList
4084  *
4085  *    Functionality: Build PUSCH time domain allocation list
4086  *
4087  * @params[in]
4088  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4089  *
4090  * @return ROK     - success
4091  *         RFAILED - failure
4092  *
4093  * ****************************************************************/
4094    uint8_t BuildPuschTimeDomAllocList
4095 (
4096  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4097  )
4098 {
4099    uint8_t idx;
4100    uint8_t elementCnt;
4101    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
4102
4103    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
4104    timeDomAllocList->choice.setup = NULLP;
4105    DU_ALLOC(timeDomAllocList->choice.setup, \
4106          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4107    if(!timeDomAllocList->choice.setup)
4108    {
4109       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4110       return RFAILED;
4111    }
4112
4113    elementCnt = 1;
4114    timeDomAllocList->choice.setup->list.count = elementCnt;
4115    timeDomAllocList->choice.setup->list.size = \
4116                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
4117    timeDomAllocList->choice.setup->list.array = NULLP;
4118    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
4119          timeDomAllocList->choice.setup->list.size);
4120    if(!timeDomAllocList->choice.setup->list.array)
4121    {
4122       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4123       return RFAILED;
4124    }
4125
4126    for(idx = 0; idx < elementCnt; idx++)
4127    {
4128       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4129       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
4130             sizeof(PUSCH_TimeDomainResourceAllocation_t));
4131       if(!timeDomAllocList->choice.setup->list.array[idx])
4132       {
4133          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4134          return RFAILED;
4135       }
4136    }
4137
4138    idx = 0;
4139    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4140    DU_ALLOC(timeDomAlloc->k2, sizeof(long));
4141    if(!timeDomAlloc->k2)
4142    {
4143       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4144       return RFAILED;
4145    }
4146    *(timeDomAlloc->k2) = PUSCH_K2;
4147    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4148    timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
4149    return ROK;
4150 }
4151
4152 /*******************************************************************
4153  *
4154  * @brief Builds BWP UL dedicated PUSCH Config
4155  *
4156  * @details
4157  *
4158  *    Function : BuildBWPUlDedPuschCfg
4159  *
4160  *    Functionality:
4161  *      Builds BWP UL dedicated PUSCH Config
4162  *
4163  * @params[in] : PUSCH_Config_t *puschCfg
4164  *
4165  * @return ROK     - success
4166  *         RFAILED - failure
4167  *
4168  * ****************************************************************/
4169 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
4170 {
4171    puschCfg->dataScramblingIdentityPUSCH = NULLP;
4172    DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4173    if(!puschCfg->dataScramblingIdentityPUSCH)
4174    {
4175       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4176       return RFAILED;
4177    }
4178    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
4179
4180    puschCfg->txConfig = NULLP;
4181    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4182    DU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4183          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4184    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4185    {
4186       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4187       return RFAILED;
4188    }
4189
4190    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4191    {
4192       return RFAILED;
4193    }
4194
4195    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4196    puschCfg->pusch_PowerControl = NULLP;
4197    puschCfg->frequencyHopping = NULLP;
4198    puschCfg->frequencyHoppingOffsetLists = NULLP;
4199    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4200
4201    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4202    DU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
4203          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4204    if(!puschCfg->pusch_TimeDomainAllocationList)
4205    {
4206       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4207       return RFAILED;
4208    }
4209
4210    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
4211    {
4212       return RFAILED;
4213    }
4214
4215    puschCfg->pusch_AggregationFactor = NULLP;
4216    puschCfg->mcs_Table = NULLP;
4217    puschCfg->mcs_TableTransformPrecoder = NULLP;
4218    puschCfg->transformPrecoder = NULLP;
4219    DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4220    if(!puschCfg->transformPrecoder)
4221    {
4222       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4223       return RFAILED;
4224    }
4225    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4226
4227    puschCfg->codebookSubset = NULLP;
4228    puschCfg->maxRank = NULLP;
4229    puschCfg->rbg_Size = NULLP;
4230    puschCfg->uci_OnPUSCH = NULLP;
4231    puschCfg->tp_pi2BPSK = NULLP;
4232
4233    return ROK;
4234 }
4235
4236 /*******************************************************************
4237  *
4238  * @brief Builds BWP UL dedicated PUCCH Config
4239  *
4240  * @details
4241  *
4242  *    Function : BuildBWPUlDedPucchCfg
4243  *
4244  *    Functionality:
4245  *      Builds BWP UL dedicated PUCCH Config
4246  *
4247  * @params[in] : PUCCH_Config_t *pucchCfg
4248  *
4249  * @return ROK     - success
4250  *         RFAILED - failure
4251  *
4252  * ****************************************************************/
4253 uint8_t BuildBWPUlDedPucchCfg(PUCCH_Config_t *pucchCfg)
4254 {
4255    uint8_t arrIdx, elementCnt;
4256
4257    DU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
4258    if(pucchCfg->dl_DataToUL_ACK == NULLP)
4259    {
4260       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4261       return RFAILED;
4262    }
4263
4264    elementCnt = 2;
4265    pucchCfg->dl_DataToUL_ACK->list.count = elementCnt;
4266    pucchCfg->dl_DataToUL_ACK->list.size = elementCnt * sizeof(long *);
4267    DU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
4268    if(pucchCfg->dl_DataToUL_ACK->list.array == NULLP)
4269    {
4270       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4271       return RFAILED;
4272    }
4273
4274    for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
4275    {
4276       DU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
4277       if(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx] == NULLP)
4278       {
4279           DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4280           return RFAILED;
4281       }
4282    }
4283
4284    arrIdx = 0;
4285    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx++]) = 1;
4286    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx]) = 2;
4287    return ROK;
4288 }
4289
4290 /*******************************************************************
4291  *
4292  * @brief Fills SRS resource to add/modify list
4293  *
4294  * @details
4295  *
4296  *    Function : BuildSrsRsrcAddModList
4297  *
4298  *    Functionality: Fills SRS resource to add/modify list
4299  *
4300  * @params[in]
4301  * @return ROK     - success
4302  *         RFAILED - failure
4303  *
4304  * ****************************************************************/
4305 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
4306 {
4307    uint8_t   elementCnt;
4308    uint8_t   rsrcIdx;
4309
4310    elementCnt = 1;
4311    resourceList->list.count = elementCnt;
4312    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
4313    resourceList->list.array = NULLP;
4314    DU_ALLOC(resourceList->list.array, resourceList->list.size);
4315    if(!resourceList->list.array)
4316    {
4317       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4318       return RFAILED;
4319    }
4320
4321    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4322    {
4323       DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4324       if(!resourceList->list.array[rsrcIdx])
4325       {
4326          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4327          return RFAILED;
4328       }
4329    }
4330
4331    rsrcIdx = 0;
4332    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
4333    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
4334    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
4335
4336    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
4337    DU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
4338          sizeof(struct SRS_Resource__transmissionComb__n2));
4339    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
4340    {
4341       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4342       return RFAILED;
4343    }
4344    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
4345       = SRS_COMB_OFFSET_N2;
4346    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
4347       = SRS_CYCLIC_SHIFT_N2;
4348
4349    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
4350                                                                       PUSCH_START_SYMBOL;
4351    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
4352                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
4353    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
4354                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
4355
4356    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
4357    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
4358    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
4359    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
4360    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
4361    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
4362                                                                SRS_Resource__groupOrSequenceHopping_neither;
4363
4364    /* Setting resource type to aperiodic for intergration purposes */
4365    resourceList->list.array[rsrcIdx]->resourceType.present = \
4366                                                              SRS_Resource__resourceType_PR_aperiodic;
4367    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
4368    DU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
4369          sizeof(struct SRS_Resource__resourceType__aperiodic));
4370    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
4371    {
4372       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4373       return RFAILED;
4374    }
4375    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
4376
4377    return ROK;
4378 }
4379
4380 /*******************************************************************
4381  *
4382  * @brief Build SRS resource set Add/mod list
4383  *
4384  * @details
4385  *
4386  *    Function : BuildSrsRsrcSetAddModList
4387  *
4388  *    Functionality: Build SRS resource set Add/mod list
4389  *
4390  * @params[in]
4391  * @return ROK     - success
4392  *         RFAILED - failure
4393  *
4394  * ****************************************************************/
4395    uint8_t BuildSrsRsrcSetAddModList
4396 (
4397  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
4398  )
4399 {
4400    uint8_t  elementCnt;
4401    uint8_t  rSetIdx;
4402    uint8_t  rsrcIdx;
4403    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
4404
4405    elementCnt = 1;
4406    rsrcSetList->list.count = elementCnt;
4407    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
4408    rsrcSetList->list.array = NULLP;
4409    DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
4410    if(!rsrcSetList->list.array)
4411    {
4412       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4413       return RFAILED;
4414    }
4415
4416    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4417    {
4418       DU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4419       if(!rsrcSetList->list.array[rSetIdx])
4420       {
4421          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4422          return RFAILED;
4423       }
4424    }
4425
4426    rSetIdx = 0;
4427    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
4428
4429    /* Fill Resource Id list in resource set */
4430    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
4431    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4432          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4433    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4434    {
4435       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4436       return RFAILED;
4437    }
4438
4439    elementCnt = 1;
4440    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4441    rsrcIdList->list.count = elementCnt;
4442    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
4443    rsrcIdList->list.array = NULLP;
4444    DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
4445    if(!rsrcIdList->list.array)
4446    {
4447       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4448       return RFAILED;
4449    }
4450
4451    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4452    {
4453       DU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4454       if(!rsrcIdList->list.array[rsrcIdx])
4455       {
4456          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4457          return RFAILED;
4458       }
4459    }
4460
4461    rsrcIdx = 0;
4462    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
4463
4464    /* Fill resource type */
4465    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
4466                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
4467
4468    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
4469    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4470          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4471    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
4472    {
4473       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4474       return RFAILED;
4475    }
4476    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
4477       = APERIODIC_SRS_RESRC_TRIGGER;
4478
4479    /* TODO : Fill values for below IEs as expected by Viavi */
4480    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
4481    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
4482
4483
4484    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
4485    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
4486    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
4487    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
4488    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
4489
4490    return ROK;
4491 }
4492
4493 /*******************************************************************
4494  *
4495  * @brief Builds BWP UL dedicated SRS Config
4496  *
4497  * @details
4498  *
4499  *    Function : BuildBWPUlDedSrsCfg
4500  *
4501  *    Functionality: Builds BWP UL dedicated SRS Config
4502  *
4503  * @params[in] SRS Config
4504  * @return ROK     - success
4505  *         RFAILED - failure
4506  *
4507  * ****************************************************************/
4508 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
4509 {
4510    srsCfg->srs_ResourceSetToReleaseList = NULLP;
4511    srsCfg->srs_ResourceSetToAddModList = NULLP;
4512    DU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
4513          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4514    if(!srsCfg->srs_ResourceSetToAddModList)
4515    {
4516       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4517       return RFAILED;
4518    }
4519    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
4520    {
4521       return RFAILED;
4522    }
4523
4524    srsCfg->srs_ResourceToReleaseList = NULLP;
4525
4526    /* Resource to Add/Modify list */
4527    srsCfg->srs_ResourceToAddModList = NULLP;
4528    DU_ALLOC(srsCfg->srs_ResourceToAddModList, \
4529          sizeof(struct SRS_Config__srs_ResourceToAddModList));
4530    if(!srsCfg->srs_ResourceToAddModList)
4531    {
4532       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4533       return RFAILED;
4534    }
4535
4536    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
4537    {
4538       return RFAILED;
4539    }
4540
4541    srsCfg->tpc_Accumulation = NULLP;
4542
4543    return ROK;
4544 }
4545
4546
4547
4548 /*******************************************************************
4549  *
4550  * @brief Builds Pusch Serving cell Config
4551  *
4552  * @details
4553  *
4554  *    Function : BuildPuschSrvCellCfg
4555  *
4556  *    Functionality: Builds Pusch Serving cell Config
4557  *
4558  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
4559  *
4560  * @return ROK     - success
4561  *         RFAILED - failure
4562  *
4563  * ****************************************************************/
4564 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
4565 {
4566    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
4567    puschCfg->choice.setup = NULLP;
4568    DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4569    if(!puschCfg->choice.setup)
4570    {
4571       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4572       return RFAILED;
4573    }
4574
4575    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4576    puschCfg->choice.setup->rateMatching = NULLP;
4577    puschCfg->choice.setup->xOverhead = NULLP;
4578    puschCfg->choice.setup->ext1 = NULLP;
4579    DU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
4580    if(!puschCfg->choice.setup->ext1)
4581    {
4582       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4583       return RFAILED;
4584    }
4585
4586    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
4587    DU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
4588    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
4589    {
4590       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4591       return RFAILED;
4592    }
4593    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
4594
4595    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
4596    DU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
4597    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
4598    {
4599       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4600       return RFAILED;
4601    }
4602    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
4603    return ROK;
4604 }
4605
4606 /*******************************************************************
4607  *
4608  * @brief Builds inital UL BWP
4609  *
4610  * @details
4611  *
4612  *    Function : BuildInitialUlBWP
4613  *
4614  *    Functionality: Builds initial UL BWP
4615  *
4616  * @params[in] BWP_UplinkDedicated_t *ulBwp
4617  * @return ROK     - success
4618  *         RFAILED - failure
4619  *
4620  * ****************************************************************/
4621 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4622 {
4623    ulBwp->pucch_Config = NULLP;
4624    DU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
4625    if(!ulBwp->pucch_Config)
4626    {
4627       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4628       return RFAILED;
4629    }
4630
4631    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
4632    ulBwp->pucch_Config->choice.setup = NULLP;
4633    DU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
4634    if(!ulBwp->pucch_Config->choice.setup)
4635    {
4636       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4637       return RFAILED;
4638    }
4639
4640    if(BuildBWPUlDedPucchCfg(ulBwp->pucch_Config->choice.setup) != ROK)
4641    {
4642       return RFAILED;
4643    }
4644
4645    /* Fill BWP UL dedicated PUSCH config */
4646    ulBwp->pusch_Config = NULLP;
4647    DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4648    if(!ulBwp->pusch_Config)
4649    {
4650       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4651       return RFAILED;
4652    }
4653
4654    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
4655    ulBwp->pusch_Config->choice.setup = NULLP;
4656    DU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4657    if(!ulBwp->pusch_Config->choice.setup)
4658    {
4659       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4660       return RFAILED;
4661    }
4662
4663    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
4664    {
4665       return RFAILED;
4666    }
4667
4668    ulBwp->configuredGrantConfig = NULLP;
4669
4670    /* Fill BPW UL dedicated SRS config */
4671    ulBwp->srs_Config = NULLP;
4672    DU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4673    if(!ulBwp->srs_Config)
4674    {
4675       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4676       return RFAILED;
4677    }
4678
4679    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
4680    ulBwp->srs_Config->choice.setup = NULLP;
4681    DU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4682    if(!ulBwp->srs_Config->choice.setup)
4683    {
4684       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4685       return RFAILED;
4686    }
4687
4688    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
4689    {
4690       return RFAILED;
4691    }
4692
4693    ulBwp->beamFailureRecoveryConfig = NULLP;
4694
4695    return ROK;
4696 }
4697
4698 /*******************************************************************
4699  *
4700  * @brief Builds UL config
4701  * @details
4702  *
4703  *    Function : BuildUlCfg
4704  *
4705  *    Functionality: Builds UL config in spCellCfgDed
4706  *
4707  * @params[in] UplinkConfig_t *ulCfg
4708  *
4709  * @return ROK     - success
4710  *         RFAILED - failure
4711  *
4712  * ****************************************************************/
4713 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
4714 {
4715    ulCfg->initialUplinkBWP = NULLP;
4716    DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4717    if(!ulCfg->initialUplinkBWP)
4718    {
4719       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4720       return RFAILED;
4721    }
4722
4723    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
4724    {
4725       return RFAILED;
4726    }
4727
4728    ulCfg->uplinkBWP_ToReleaseList = NULLP;
4729    ulCfg->uplinkBWP_ToAddModList = NULLP;
4730    ulCfg->firstActiveUplinkBWP_Id = NULLP;
4731    DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4732    if(!ulCfg->firstActiveUplinkBWP_Id)
4733    {
4734       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4735       return RFAILED;
4736    }
4737    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
4738
4739    ulCfg->pusch_ServingCellConfig = NULLP;
4740    DU_ALLOC(ulCfg->pusch_ServingCellConfig, \
4741          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4742    if(!ulCfg->pusch_ServingCellConfig)
4743    {
4744       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4745       return RFAILED;
4746    }
4747
4748    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
4749    {
4750       return RFAILED;
4751    }
4752
4753    ulCfg->carrierSwitching = NULLP;
4754    ulCfg->ext1 = NULLP;
4755    return ROK;
4756 }
4757
4758 /*******************************************************************
4759  *
4760  * @brief Builds PDSCH serving cell config
4761  * @details
4762  *
4763  *    Function : BuildPdschSrvCellCfg
4764  *
4765  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
4766  *
4767  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
4768  *
4769  * @return ROK     - success
4770  *         RFAILED - failure
4771  *
4772  * ****************************************************************/
4773 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
4774 {
4775    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
4776    pdschCfg->choice.setup = NULLP;
4777    DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
4778    if(!pdschCfg->choice.setup)
4779    {
4780       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4781       return RFAILED;
4782    }
4783
4784    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4785    pdschCfg->choice.setup->xOverhead = NULLP;
4786    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
4787    DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
4788    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
4789    {
4790       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4791       return RFAILED;
4792    }
4793    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
4794    pdschCfg->choice.setup->pucch_Cell = NULLP;
4795    pdschCfg->choice.setup->ext1 = NULLP;
4796
4797    return ROK;
4798 }
4799
4800 /*******************************************************************
4801  *
4802  * @brief Builds CSI Meas config
4803  * @details
4804  *
4805  *    Function : BuildCsiMeasCfg
4806  *
4807  *    Functionality: Builds CSI Meas config in spCellCfgDed
4808  *
4809  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
4810  *
4811  * @return ROK     - success
4812  *         RFAILED - failure
4813  *
4814  * ****************************************************************/
4815 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
4816 {
4817
4818    return ROK;
4819 }
4820
4821 /*******************************************************************
4822  *
4823  * @brief Builds Spcell config dedicated
4824  * @details
4825  *
4826  *    Function : BuildSpCellCfgDed
4827  *
4828  *    Functionality: Builds sp cell config dedicated in spCellCfg
4829  *
4830  * @params[in] ServingCellConfig_t srvCellCfg
4831  *
4832  * @return ROK     - success
4833  *         RFAILED - failure
4834  *
4835  * ****************************************************************/
4836 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
4837 {
4838    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
4839    DU_ALLOC(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
4840    if(!srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
4841    {
4842       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4843       return RFAILED;
4844    }
4845
4846    srvCellCfg->initialDownlinkBWP = NULLP;
4847    DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
4848    if(!srvCellCfg->initialDownlinkBWP)
4849    {
4850       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4851       return RFAILED;
4852    }
4853
4854    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
4855    {
4856       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
4857       return RFAILED;
4858    }
4859    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
4860    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
4861
4862    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
4863    DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
4864    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
4865    {
4866       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4867       return RFAILED;
4868    }
4869    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4870
4871    srvCellCfg->bwp_InactivityTimer = NULLP;
4872
4873    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
4874    DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
4875    if(!srvCellCfg->defaultDownlinkBWP_Id)
4876    {
4877       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4878       return RFAILED;
4879    }
4880    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4881
4882    srvCellCfg->uplinkConfig = NULLP;
4883    DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
4884    if(!srvCellCfg->uplinkConfig)
4885    {
4886       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4887       return RFAILED;
4888    }
4889
4890    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
4891    {
4892       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
4893       return RFAILED;
4894    }
4895    srvCellCfg->supplementaryUplink = NULLP;
4896    srvCellCfg->pdcch_ServingCellConfig = NULLP;
4897
4898    srvCellCfg->pdsch_ServingCellConfig = NULLP;
4899    DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
4900    if(!srvCellCfg->pdsch_ServingCellConfig)
4901    {
4902       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4903       return RFAILED;
4904    }
4905
4906    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
4907    {
4908       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
4909       return RFAILED;
4910    }
4911
4912    srvCellCfg->csi_MeasConfig = NULLP;
4913 #if 0
4914    DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
4915       if(!srvCellCfg->csi_MeasConfig)
4916       {
4917          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4918          return RFAILED;
4919       }
4920
4921    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
4922    {
4923       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
4924       return RFAILED;
4925    }
4926 #endif
4927    srvCellCfg->sCellDeactivationTimer = NULLP;
4928    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
4929    srvCellCfg->tag_Id = TAG_ID;
4930    srvCellCfg->dummy = NULLP;
4931    srvCellCfg->pathlossReferenceLinking = NULLP;
4932    srvCellCfg->servingCellMO = NULLP;
4933    srvCellCfg->ext1 = NULLP;
4934
4935    return ROK;
4936 }
4937 /*******************************************************************
4938  *
4939  * @brief Builds Spcell config
4940  *
4941  * @details
4942  *
4943  *    Function : BuildSpCellCfg
4944  *
4945  *    Functionality: Builds sp cell config in DuToCuRrcContainer
4946  *
4947  * @params[in] SpCellConfig_t spCellCfg
4948  *
4949  * @return ROK     - success
4950  *         RFAILED - failure
4951  *
4952  * ****************************************************************/
4953 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
4954 {
4955
4956    spCellCfg->servCellIndex = NULLP;
4957    DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
4958    if(!spCellCfg->servCellIndex)
4959    {
4960       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4961       return RFAILED;
4962    }
4963    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
4964
4965    spCellCfg->reconfigurationWithSync = NULLP;
4966    spCellCfg->rlf_TimersAndConstants = NULLP;
4967    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
4968    DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
4969    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
4970    {
4971       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4972       return RFAILED;
4973    }
4974    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
4975
4976    spCellCfg->spCellConfigDedicated = NULLP;
4977    DU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
4978    if(!spCellCfg->spCellConfigDedicated)
4979    {
4980       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4981       return RFAILED;
4982    }
4983    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
4984    {
4985       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
4986       return RFAILED;
4987    }
4988    return ROK;
4989 }
4990 /*******************************************************************
4991  *
4992  * @brief Builds Phy cell group config
4993  *
4994  * @details
4995  *
4996  *    Function : BuildPhyCellGrpCfg
4997  *
4998  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
4999  *
5000  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
5001  *
5002  * @return ROK     - success
5003  *         RFAILED - failure
5004  *
5005  * ****************************************************************/
5006 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
5007 {
5008    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
5009    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
5010
5011    phyCellGrpCfg->p_NR_FR1 = NULLP;
5012    DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5013    if(!phyCellGrpCfg->p_NR_FR1)
5014    {
5015       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
5016       return RFAILED;
5017    }
5018    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
5019    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
5020    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
5021    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
5022    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
5023    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
5024    phyCellGrpCfg->cs_RNTI = NULLP;
5025    phyCellGrpCfg->ext1 = NULLP;
5026    phyCellGrpCfg->ext2 = NULLP;
5027
5028    return ROK;
5029 }
5030 /*******************************************************************
5031  *
5032  * @brief Builds Mac cell group config
5033  *
5034  * @details
5035  *
5036  *    Function : BuildMacCellGrpCfg
5037  *
5038  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
5039  *
5040  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
5041  *
5042  * @return ROK     - success
5043  *         RFAILED - failure
5044  *
5045  * ****************************************************************/
5046 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
5047 {
5048    macCellGrpCfg->drx_Config = NULLP;
5049    macCellGrpCfg->schedulingRequestConfig = NULLP;
5050    DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5051    if(!macCellGrpCfg->schedulingRequestConfig)
5052    {
5053       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5054       return RFAILED;
5055    }
5056
5057    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
5058    {
5059       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
5060       return RFAILED;
5061    }
5062
5063    macCellGrpCfg->bsr_Config = NULLP;
5064    DU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5065    if(!macCellGrpCfg->bsr_Config)
5066    {
5067       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5068       return RFAILED;
5069    }
5070
5071    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
5072    {
5073       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
5074       return RFAILED;
5075    }
5076
5077    macCellGrpCfg->tag_Config = NULLP;
5078    DU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
5079    if(!macCellGrpCfg->tag_Config)
5080    {
5081       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5082       return RFAILED;
5083    }
5084
5085    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
5086    {
5087       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
5088       return RFAILED;
5089    }
5090
5091    macCellGrpCfg->phr_Config = NULLP;
5092    DU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
5093    if(!macCellGrpCfg->phr_Config)
5094    {
5095       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5096       return RFAILED;
5097    }
5098
5099    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
5100    {
5101       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
5102       return RFAILED;
5103    }
5104
5105    macCellGrpCfg->skipUplinkTxDynamic = false;
5106    macCellGrpCfg->ext1 = NULLP;
5107
5108    return ROK;
5109 }
5110 /*******************************************************************
5111  *
5112  * @brief Frees memeory allocated for SearchSpcToAddModList
5113  *
5114  * @details
5115  *
5116  *    Function : FreeSearchSpcToAddModList
5117  *
5118  *    Functionality: Deallocating memory of SearchSpcToAddModList
5119  *
5120  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
5121  *
5122  * @return void
5123  *
5124  4221 * ****************************************************************/
5125 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
5126 {
5127    uint8_t idx1=0;
5128    uint8_t idx2=0;
5129    struct  SearchSpace *searchSpc=NULLP;
5130
5131    if(searchSpcList->list.array)
5132    {
5133       if(searchSpcList->list.array[idx2])
5134       {
5135          searchSpc = searchSpcList->list.array[idx2];
5136          if(searchSpc->controlResourceSetId)
5137          {
5138             if(searchSpc->monitoringSlotPeriodicityAndOffset)
5139             {
5140                if(searchSpc->monitoringSymbolsWithinSlot)
5141                {
5142                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
5143                   {
5144                      if(searchSpc->nrofCandidates)
5145                      {
5146                         if(searchSpc->searchSpaceType)
5147                         {
5148                            DU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
5149                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
5150                            DU_FREE(searchSpc->searchSpaceType, sizeof(struct
5151                                     SearchSpace__searchSpaceType));
5152                         }
5153                         DU_FREE(searchSpc->nrofCandidates,
5154                               sizeof(struct SearchSpace__nrofCandidates));
5155                      }
5156                      DU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
5157                            searchSpc->monitoringSymbolsWithinSlot->size);
5158                   }
5159                   DU_FREE(searchSpc->monitoringSymbolsWithinSlot,
5160                         sizeof(BIT_STRING_t));
5161                }
5162                DU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
5163                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
5164             }
5165             DU_FREE(searchSpc->controlResourceSetId,
5166                   sizeof(ControlResourceSetId_t));
5167          }
5168       }
5169       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
5170       {
5171          DU_FREE(searchSpcList->list.array[idx1],
5172                sizeof(struct SearchSpace));
5173       }
5174       DU_FREE(searchSpcList->list.array,searchSpcList->list.size);
5175    }
5176 }
5177 /*******************************************************************
5178  *
5179  * @brief Frees memory allocated for PdschTimeDomAllocList
5180  *
5181  * @details
5182  *
5183  *    Function : FreePdschTimeDomAllocList
5184  *
5185  *    Functionality: Deallocating memory of PdschTimeDomAllocList
5186  *
5187  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
5188  *
5189  * @return void
5190  *
5191  * ****************************************************************/
5192 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
5193 {
5194    uint8_t idx1=0;
5195
5196    if(timeDomAllocList->choice.setup)
5197    {
5198       if(timeDomAllocList->choice.setup->list.array)
5199       {
5200          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
5201          {
5202             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1]->k0, sizeof(long));
5203             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
5204                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
5205          }
5206          DU_FREE(timeDomAllocList->choice.setup->list.array, \
5207                timeDomAllocList->choice.setup->list.size);
5208       }
5209       DU_FREE(timeDomAllocList->choice.setup,\
5210             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
5211    }
5212 }
5213 /*******************************************************************
5214  *
5215  * @brief Frees memory allocated for PuschTimeDomAllocList
5216  *
5217  *@details
5218  *
5219  *    Function : FreePuschTimeDomAllocList
5220  *
5221  *    Functionality: Deallocating memory of PuschTimeDomAllocList
5222  *
5223  * @params[in] PUSCH_Config_t *puschCfg
5224  *
5225  * @return void
5226  *
5227  * ****************************************************************/
5228 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
5229 {
5230    uint8_t idx1=0;
5231    uint8_t idx2=0;
5232    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
5233
5234    if(puschCfg->pusch_TimeDomainAllocationList)
5235    {
5236       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
5237       if(timeDomAllocList_t->choice.setup)
5238       {
5239          if(timeDomAllocList_t->choice.setup->list.array)
5240          {
5241             DU_FREE(timeDomAllocList_t->choice.setup->list.array[idx2]->k2, sizeof(long));
5242             for(idx1 = 0; idx1<timeDomAllocList_t->choice.setup->list.count; idx1++)
5243             {
5244                DU_FREE(timeDomAllocList_t->choice.setup->list.array[idx1],\
5245                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
5246             }
5247             DU_FREE(timeDomAllocList_t->choice.setup->list.array, \
5248                   timeDomAllocList_t->choice.setup->list.size);
5249          }
5250          DU_FREE(timeDomAllocList_t->choice.setup, \
5251                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
5252       }
5253       DU_FREE(puschCfg->transformPrecoder, sizeof(long));
5254       DU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
5255             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
5256    }
5257
5258 }
5259 /*******************************************************************
5260  *
5261  * @brief Frees memory allocated for InitialUlBWP
5262  *
5263  * @details
5264  *
5265  *    Function : FreeInitialUlBWP
5266  *
5267  *    Functionality: Deallocating memory of InitialUlBWP
5268  *
5269  * @params[in] BWP_UplinkDedicated_t *ulBwp
5270  *
5271  * @return void
5272  *
5273  * ****************************************************************/
5274 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5275 {
5276    uint8_t  rSetIdx, rsrcIdx, k1Idx;
5277    SRS_Config_t   *srsCfg = NULLP;
5278    PUSCH_Config_t *puschCfg = NULLP;
5279    PUCCH_Config_t *pucchCfg = NULLP;
5280    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
5281    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
5282    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
5283    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
5284
5285    if(ulBwp->pucch_Config)
5286    {
5287       if(ulBwp->pucch_Config->choice.setup)
5288       {
5289           pucchCfg = ulBwp->pucch_Config->choice.setup;
5290           if(pucchCfg->dl_DataToUL_ACK)
5291           {
5292              if(pucchCfg->dl_DataToUL_ACK->list.array)
5293              {
5294                 for(k1Idx = 0; k1Idx < pucchCfg->dl_DataToUL_ACK->list.count; k1Idx++)
5295                 {
5296                    DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[k1Idx], sizeof(long));
5297                 }
5298                 DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
5299              }
5300              DU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
5301           }
5302           DU_FREE(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
5303       }
5304       DU_FREE(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
5305    }
5306
5307    if(ulBwp->pusch_Config)
5308    {
5309       if(ulBwp->pusch_Config->choice.setup)
5310       {
5311          puschCfg=ulBwp->pusch_Config->choice.setup;
5312          if(puschCfg->dataScramblingIdentityPUSCH)
5313          {
5314             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
5315             {
5316                FreePuschTimeDomAllocList(puschCfg);
5317                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
5318                if(dmrsUlCfg->choice.setup)
5319                {
5320                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
5321                   {
5322                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
5323                      {
5324                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
5325                               sizeof(long));
5326                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
5327                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
5328                      }
5329                      DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
5330                            sizeof(long));
5331                   }
5332                   DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
5333                }
5334                DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
5335                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
5336             }
5337             DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
5338          }
5339          DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5340       }
5341       DU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5342
5343       /* Free SRS-Config */
5344       if(ulBwp->srs_Config)
5345       {
5346          if(ulBwp->srs_Config->choice.setup)
5347          {
5348             srsCfg = ulBwp->srs_Config->choice.setup;
5349
5350             /* Free Resource Set to add/mod list */
5351             if(srsCfg->srs_ResourceSetToAddModList)
5352             {
5353                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
5354                if(rsrcSetList->list.array)
5355                {
5356                   rSetIdx = 0;
5357
5358                   /* Free SRS resource Id list in this SRS resource set */
5359                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5360                   {
5361                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5362
5363                      if(rsrcIdList->list.array)
5364                      {
5365                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5366                         {
5367                            DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5368                         }
5369                         DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
5370                      }
5371                      DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5372                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5373                   }
5374
5375                   /* Free resource type info for this SRS resource set */
5376                   DU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5377                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5378
5379                   /* Free memory for each resource set */
5380                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5381                   {
5382                      DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5383                   }
5384                   DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
5385                }
5386                DU_FREE(srsCfg->srs_ResourceSetToAddModList, \
5387                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5388             }
5389
5390             /* Free resource to add/modd list */
5391             if(srsCfg->srs_ResourceToAddModList)
5392             {
5393                resourceList = srsCfg->srs_ResourceToAddModList;
5394                if(resourceList->list.array)
5395                {
5396                   rsrcIdx = 0;
5397                   DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
5398                         sizeof(struct SRS_Resource__transmissionComb__n2));
5399                   DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
5400                         sizeof(struct SRS_Resource__resourceType__aperiodic));
5401
5402                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5403                   {
5404                      DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5405                   }
5406                   DU_FREE(resourceList->list.array, resourceList->list.size);
5407                }
5408                DU_FREE(srsCfg->srs_ResourceToAddModList, \
5409                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
5410             }
5411
5412             DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5413          }
5414          DU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5415       }
5416    }
5417 }
5418 /*******************************************************************
5419  *
5420  * @brief Frees memory allocated for initialUplinkBWP
5421  *
5422  * @details
5423  *
5424  *    Function : FreeinitialUplinkBWP
5425  *
5426  *    Functionality: Deallocating memory of initialUplinkBWP
5427  *
5428  * @params[in] UplinkConfig_t *ulCfg
5429  *
5430  * @return void
5431  *
5432  *
5433  * ****************************************************************/
5434 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
5435 {
5436    BWP_UplinkDedicated_t *ulBwp=NULLP;
5437    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
5438
5439    if(ulCfg->initialUplinkBWP)
5440    {
5441       ulBwp=ulCfg->initialUplinkBWP;
5442       if(ulCfg->firstActiveUplinkBWP_Id)
5443       {
5444          if(ulCfg->pusch_ServingCellConfig)
5445          {
5446             puschCfg=ulCfg->pusch_ServingCellConfig;
5447             if(puschCfg->choice.setup)
5448             {
5449                if(puschCfg->choice.setup->ext1)
5450                {
5451                   DU_FREE(puschCfg->choice.setup->ext1->\
5452                         processingType2Enabled,sizeof(BOOLEAN_t));
5453                   DU_FREE(puschCfg->choice.setup->ext1->\
5454                         maxMIMO_Layers,sizeof(long));
5455                   DU_FREE(puschCfg->choice.setup->ext1, \
5456                         sizeof(struct PUSCH_ServingCellConfig__ext1));
5457                }
5458                DU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5459             }
5460             DU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5461          }
5462          DU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5463       }
5464       FreeInitialUlBWP(ulBwp);
5465       DU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5466    }
5467 }
5468 /*******************************************************************
5469  *
5470  * @brief Frees emmory allocated for BWPDlDedPdschCfg
5471  *
5472  * @details
5473  *
5474  *    Function : FreeBWPDlDedPdschCfg
5475  *
5476  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
5477  *
5478  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5479  *
5480  * @return void
5481  *
5482  *
5483  * ****************************************************************/
5484 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
5485 {
5486    struct PDSCH_Config *pdschCfg=NULLP;
5487    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
5488    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
5489    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
5490
5491    if(dlBwp->pdsch_Config->choice.setup)
5492    {
5493       pdschCfg=dlBwp->pdsch_Config->choice.setup;
5494       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
5495       {
5496          if(pdschCfg->pdsch_TimeDomainAllocationList)
5497          {
5498             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
5499             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
5500             {
5501                prbBndlType=&pdschCfg->prb_BundlingType;
5502                DU_FREE(prbBndlType->choice.staticBundling,\
5503                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
5504                DU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
5505             }
5506             FreePdschTimeDomAllocList(timeDomAllocList);
5507             DU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
5508                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
5509          }
5510          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
5511          if(dmrsDlCfg->choice.setup)
5512          {
5513             DU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
5514                   sizeof(long));
5515             DU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
5516          }
5517          DU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
5518                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
5519       }
5520       DU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
5521    }
5522 }
5523 /*******************************************************************
5524  *
5525  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
5526  *
5527  * @details
5528  *
5529  *    Function : FreeBWPDlDedPdcchCfg
5530  *
5531  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
5532  *
5533  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5534  *
5535  * @return void
5536  *
5537  *
5538  * ****************************************************************/
5539 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
5540 {
5541    uint8_t idx1=0;
5542    uint8_t idx2=0;
5543    struct PDCCH_Config *pdcchCfg=NULLP;
5544    struct ControlResourceSet *controlRSet=NULLP;
5545    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
5546
5547    if(dlBwp->pdcch_Config->choice.setup)
5548    {
5549       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
5550       if(pdcchCfg->controlResourceSetToAddModList)
5551       {
5552          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
5553          if(controlRSetList->list.array)
5554          {
5555             controlRSet = controlRSetList->list.array[idx2];
5556             if(controlRSet)
5557             {
5558                if(controlRSet->frequencyDomainResources.buf)
5559                {
5560                   if(controlRSet->pdcch_DMRS_ScramblingID)
5561                   {
5562                      if(pdcchCfg->searchSpacesToAddModList)
5563                      {
5564                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
5565                         DU_FREE(pdcchCfg->searchSpacesToAddModList, \
5566                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
5567                      }
5568                      DU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
5569                   }
5570                   DU_FREE(controlRSet->frequencyDomainResources.buf, \
5571                         controlRSet->frequencyDomainResources.size);
5572                }
5573             }
5574             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
5575             {
5576                DU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
5577             }
5578             DU_FREE(controlRSetList->list.array, controlRSetList->list.size);
5579          }
5580          DU_FREE(pdcchCfg->controlResourceSetToAddModList, \
5581                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
5582       }
5583       DU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
5584    }
5585 }
5586
5587 /*******************************************************************
5588  *
5589  * @brief Frees emmory allocated for DUToCURRCContainer
5590  *
5591  * @details
5592  *
5593  *    Function : FreeMemDuToCuRrcCont
5594  *
5595  *    Functionality: Deallocating memory of DuToCuRrcContainer
5596  *
5597  * @params[in] DuToCuRRCContainer, DuToCuRRCContainer
5598  *
5599  * @return ROK     - success
5600  *         RFAILED - failure
5601  *
5602  * ****************************************************************/
5603 uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg)
5604 {
5605    uint8_t idx=0;
5606    SpCellConfig_t *spCellCfg=NULLP;
5607    ServingCellConfig_t *srvCellCfg=NULLP;
5608    BWP_DownlinkDedicated_t *dlBwp=NULLP;
5609    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
5610    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
5611    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
5612    struct RLC_Config *rlcConfig=NULLP;
5613    struct LogicalChannelConfig *macLcConfig=NULLP;
5614    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
5615    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
5616    struct TAG_Config *tagConfig=NULLP;
5617    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
5618    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
5619    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
5620
5621    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
5622    if(rlcBearerList)
5623    {
5624       if(rlcBearerList->list.array)
5625       {
5626          for(idx=0; idx<rlcBearerList->list.count; idx++)
5627          {
5628             if(rlcBearerList->list.array[idx])
5629             {
5630                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
5631                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
5632                if(rlcConfig)
5633                {
5634                   if(rlcConfig->choice.am)
5635                   {
5636                      DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5637                      DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5638                      DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
5639                   }
5640                   DU_FREE(rlcConfig, sizeof(struct RLC_Config));
5641                }
5642                DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
5643                if(macLcConfig)
5644                {
5645                   if(macLcConfig->ul_SpecificParameters)
5646                   {
5647                      DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
5648                      DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
5649                      DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
5650                   }
5651                   DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
5652                }
5653                DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
5654             }
5655          }
5656          DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
5657       }
5658       DU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5659    }
5660
5661    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
5662    if(macCellGrpCfg)
5663    {
5664       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
5665       if(schedulingRequestConfig)
5666       {
5667          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
5668          if(schReqList)
5669          {
5670             if(schReqList->list.array)
5671             {
5672                for(idx=0;idx<schReqList->list.count; idx++)
5673                {
5674                   if(schReqList->list.array[idx])
5675                   {
5676                      DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
5677                      DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
5678                   }
5679                }
5680                DU_FREE(schReqList->list.array, schReqList->list.size);
5681             }
5682             DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
5683                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
5684             DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5685       }
5686       if(macCellGrpCfg->bsr_Config)
5687       {
5688          DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5689       }
5690       tagConfig = macCellGrpCfg->tag_Config;
5691       if(tagConfig)
5692       {
5693          tagList = tagConfig->tag_ToAddModList;
5694          if(tagList)
5695          {
5696             if(tagList->list.array)
5697             {
5698                for(idx=0; idx<tagList->list.count; idx++)
5699                {
5700                   DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
5701                }
5702                DU_FREE(tagList->list.array, tagList->list.size);
5703             }
5704             DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
5705          }
5706          DU_FREE(tagConfig, sizeof(struct TAG_Config));
5707       }
5708
5709       phrConfig = macCellGrpCfg->phr_Config;
5710       if(phrConfig)
5711       {
5712          DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
5713          DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
5714       }
5715
5716       DU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
5717    }
5718
5719    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
5720    if(phyCellGrpCfg)
5721    {
5722       DU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5723       DU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
5724    }
5725
5726    spCellCfg = cellGrpCfg->spCellConfig;
5727    if(spCellCfg)
5728    {
5729       if(spCellCfg->servCellIndex)
5730       {
5731          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
5732          {
5733             if(spCellCfg->spCellConfigDedicated)
5734             {
5735                srvCellCfg = spCellCfg->spCellConfigDedicated;
5736                if(srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
5737                {
5738                   if(srvCellCfg->initialDownlinkBWP)
5739                   {
5740                      dlBwp = srvCellCfg->initialDownlinkBWP;
5741                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
5742                      {
5743                         if(srvCellCfg->defaultDownlinkBWP_Id)
5744                         {
5745                            if(srvCellCfg->uplinkConfig)
5746                            {
5747                               if(srvCellCfg->pdsch_ServingCellConfig)
5748                               {
5749                                  pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
5750                                  if(pdschCfg->choice.setup)
5751                                  {
5752                                     DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
5753                                     DU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5754                                  }
5755                                  DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
5756                                           ServingCellConfig__pdsch_ServingCellConfig));
5757                               }
5758                               FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
5759                               DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
5760                            }
5761                            DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
5762                         }
5763                         DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
5764                      }
5765                      if(dlBwp->pdcch_Config)
5766                      {
5767                         if(dlBwp->pdsch_Config)
5768                         {
5769                            FreeBWPDlDedPdschCfg(dlBwp);
5770                            DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
5771                         }
5772                         FreeBWPDlDedPdcchCfg(dlBwp);
5773                         DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
5774                      }
5775                      DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
5776                   }
5777                   DU_FREE(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
5778                }
5779                DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5780             }
5781             DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5782          }
5783          DU_FREE(spCellCfg->servCellIndex, sizeof(long));
5784       }
5785       DU_FREE(spCellCfg,sizeof(SpCellConfig_t));
5786    }
5787    return ROK;
5788 }
5789 /*******************************************************************
5790  *
5791  * @brief Builds DU To CU RRC Container
5792  *
5793  * @details
5794  *
5795  *    Function : BuildDuToCuRrcContainer
5796  *
5797  *    Functionality: Builds DuToCuRrcContainer
5798  *
5799  * @params[in] idx, index in F1AP msg
5800  *             DuToCuRRCContainer, DuToCuRRCContainer
5801  *
5802  * @return ROK     - success
5803  *         RFAILED - failure
5804  *
5805  * ****************************************************************/
5806 uint8_t BuildDuToCuRrcContainer(DUtoCURRCContainer_t *duToCuRrcContainer)
5807 {
5808    uint8_t  ret = ROK;
5809    CellGroupConfigRrc_t  cellGrpCfg;
5810    asn_enc_rval_t        encRetVal;
5811    memset(&cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
5812    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
5813
5814    while(true)
5815    {
5816       cellGrpCfg.cellGroupId = CELL_GRP_ID;
5817
5818       cellGrpCfg.rlc_BearerToAddModList = NULLP;
5819       DU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5820       if(!cellGrpCfg.rlc_BearerToAddModList)
5821       {
5822          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5823          ret = RFAILED;
5824          break;
5825       }
5826       if(BuildRlcBearerToAddModList(cellGrpCfg.rlc_BearerToAddModList) != ROK)
5827       {
5828          DU_LOG("\nERROR  -->  F1AP : BuildRlcBearerToAddModList failed");
5829          ret = RFAILED;
5830          break;
5831       }
5832
5833       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
5834       cellGrpCfg.mac_CellGroupConfig = NULLP;
5835       DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
5836       if(!cellGrpCfg.mac_CellGroupConfig)
5837       {
5838          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5839          ret = RFAILED;
5840          break;
5841       }
5842       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
5843       {
5844          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
5845          ret = RFAILED;
5846          break;
5847       }
5848
5849       cellGrpCfg.physicalCellGroupConfig = NULLP;
5850       DU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
5851       if(!cellGrpCfg.physicalCellGroupConfig)
5852       {
5853          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5854          ret = RFAILED;
5855          break;
5856       }
5857       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
5858       {
5859          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
5860          ret = RFAILED;
5861          break;
5862       }
5863
5864       cellGrpCfg.spCellConfig = NULLP;
5865       DU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
5866       if(!cellGrpCfg.spCellConfig)
5867       {
5868          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5869          ret = RFAILED;
5870          break;
5871       }
5872       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
5873       {
5874          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
5875          ret = RFAILED;
5876          break;
5877       }
5878
5879       cellGrpCfg.sCellToAddModList = NULLP;
5880       cellGrpCfg.sCellToReleaseList = NULLP;
5881       cellGrpCfg.ext1 = NULLP;
5882
5883       /* encode cellGrpCfg into duToCuRrcContainer */
5884       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
5885       memset(encBuf, 0, ENC_BUF_MAX_LEN);
5886       encBufSize = 0;
5887       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
5888       /* Encode results */
5889       if(encRetVal.encoded == ENCODE_FAIL)
5890       {
5891          DU_LOG( "\nERROR  --> F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
5892                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5893          ret = RFAILED;
5894          break;
5895       }
5896       else
5897       {
5898          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
5899          for(int i=0; i< encBufSize; i++)
5900          {
5901             printf("%x",encBuf[i]);
5902          }
5903       }
5904
5905       duToCuRrcContainer->size = encBufSize;
5906       DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
5907       if(!duToCuRrcContainer->buf)
5908       {
5909          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
5910          ret = RFAILED;
5911          break;
5912       }
5913       if(ret == ROK)
5914       {
5915          memcpy(duToCuRrcContainer->buf, encBuf, duToCuRrcContainer->size);
5916       }
5917       break;
5918    }
5919    FreeMemDuToCuRrcCont(&cellGrpCfg);
5920    return ret;
5921 }
5922
5923 /*******************************************************************
5924  *
5925  * @brief Free memory allocated in InitialULRRCMessage
5926  *
5927  * @details
5928  *
5929  *    Function : freeInitUlRrcMsgTransfer
5930  *
5931  *    Functionality: Free memory allocated in InitialULRRCMessage
5932  *
5933  * @params[in]F1AP_PDU_t  *f1apMsg)
5934  *
5935  * @return ROK     - success
5936  *         RFAILED - failure
5937  *
5938  * ****************************************************************/
5939
5940 uint8_t freeInitUlRrcMsgTransfer(F1AP_PDU_t  *f1apMsg)
5941 {
5942    uint8_t ieIdx, arrIdx;
5943    InitialULRRCMessageTransfer_t *initULRRCMsg=NULLP;
5944
5945    if(f1apMsg)
5946    {
5947       if(f1apMsg->choice.initiatingMessage)
5948       {
5949          initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.\
5950             choice.InitialULRRCMessageTransfer;
5951          if(initULRRCMsg->protocolIEs.list.array)
5952          {
5953             for(ieIdx = 0; ieIdx < initULRRCMsg->protocolIEs.list.count; ieIdx++)
5954             {
5955                switch(initULRRCMsg->protocolIEs.list.array[ieIdx]->id)
5956                {
5957                   case ProtocolIE_ID_id_NRCGI:
5958                   {
5959                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf)
5960                      {
5961                         if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf)
5962                         {
5963                            DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf,\
5964                            initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.size);
5965                         }
5966                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf,\
5967                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.size);
5968                      }
5969                      break;
5970                   }
5971                   case ProtocolIE_ID_id_RRCContainer:
5972                   {
5973                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
5974                      {
5975                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,\
5976                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
5977                      }
5978                      break;
5979                   }
5980                   case ProtocolIE_ID_id_DUtoCURRCContainer:
5981                   {
5982                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf)
5983                      {
5984                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf,
5985                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.size);
5986                      }
5987                      break;
5988                   }
5989                   default:
5990                      break;
5991                }
5992              }
5993              for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
5994              {
5995                 if(initULRRCMsg->protocolIEs.list.array[arrIdx])
5996                 {
5997                    DU_FREE(initULRRCMsg->protocolIEs.list.array[arrIdx],\
5998                       sizeof(InitialULRRCMessageTransferIEs_t));
5999                 }
6000              }
6001              DU_FREE(initULRRCMsg->protocolIEs.list.array, initULRRCMsg->protocolIEs.list.size);
6002           }
6003          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
6004       }
6005       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
6006    }
6007    else
6008    {
6009       DU_LOG("\nERROR  -->  DU_APP : Recevied F1ap Pdu is null at freeInitUlRrcMsgTransfer()");
6010       return RFAILED;
6011    }
6012    return ROK;
6013 }
6014
6015 /*******************************************************************
6016  *
6017  * @brief Builds and sends the InitialULRRCMessage
6018  *
6019  * @details
6020  *
6021  *    Function : BuildAndSendInitialRrcMsgTransfer
6022  *
6023  *    Functionality: Constructs the Initial UL RRC Message Transfer and sends
6024  *                   it to the CU through SCTP.
6025  *
6026  * @params[in]
6027  *
6028  * @return ROK     - success
6029  *         RFAILED - failure
6030  *
6031  * ****************************************************************/
6032 uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti,
6033       uint16_t rrcContSize, uint8_t *rrcContainer)
6034 {
6035    uint8_t   ret;
6036    uint8_t   elementCnt;
6037    uint8_t   ieIdx;
6038    asn_enc_rval_t  encRetVal;
6039    F1AP_PDU_t  *f1apMsg = NULLP;
6040    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
6041    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
6042
6043    while(true)
6044    {
6045       DU_LOG("\n INFO   -->  F1AP : Building RRC Setup Request\n");
6046       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
6047       if(f1apMsg == NULLP)
6048       {
6049          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
6050          break;
6051       }
6052       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
6053       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
6054       if(f1apMsg->choice.initiatingMessage == NULLP)
6055       {
6056          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
6057          break;
6058       }
6059       f1apMsg->choice.initiatingMessage->procedureCode =\
6060                                                         ProcedureCode_id_InitialULRRCMessageTransfer;
6061       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
6062       f1apMsg->choice.initiatingMessage->value.present = \
6063                                                          InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
6064       initULRRCMsg =\
6065                     &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
6066       elementCnt = 5;
6067       initULRRCMsg->protocolIEs.list.count = elementCnt;
6068       initULRRCMsg->protocolIEs.list.size = \
6069                                             elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *);
6070       /* Initialize the F1Setup members */
6071       DU_ALLOC(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
6072       if(initULRRCMsg->protocolIEs.list.array == NULLP)
6073       {
6074          DU_LOG(" ERROR  -->  F1AP : Memory allocation for\
6075                RRCSetupRequestMessageTransferIEs failed");
6076          break;
6077       }
6078       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
6079       {
6080          DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx],\
6081                sizeof(InitialULRRCMessageTransferIEs_t));
6082          if(initULRRCMsg->protocolIEs.list.array[ieIdx] == NULLP)
6083          {
6084             break;
6085          }
6086       }
6087       ieIdx = 0;
6088       /*GNB DU UE F1AP ID*/
6089       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6090                                                         ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
6091       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  = Criticality_reject;
6092       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
6093                                                                   InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
6094       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
6095
6096
6097       /*NRCGI*/
6098       ieIdx++;
6099       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6100                                                         ProtocolIE_ID_id_NRCGI;
6101       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  =Criticality_reject;
6102       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
6103                                                                   InitialULRRCMessageTransferIEs__value_PR_NRCGI;
6104
6105       ret =\
6106            BuildNrcgi(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
6107       if(ret!=ROK)
6108       {
6109          break;
6110       }
6111
6112       /*CRNTI*/
6113       ieIdx++;
6114       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6115                                                         ProtocolIE_ID_id_C_RNTI;
6116       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6117       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6118                                                                  InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
6119       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.C_RNTI = crnti;
6120
6121       /*RRCContainer*/
6122       ieIdx++;
6123       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6124                                                         ProtocolIE_ID_id_RRCContainer;
6125       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6126       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6127                                                                  InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
6128
6129       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = rrcContSize;
6130       DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
6131             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size)
6132       if(!initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
6133       {
6134          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
6135          break;
6136
6137       }
6138       memcpy(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, rrcContainer,
6139             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
6140
6141
6142       /*DUtoCURRCContainer*/
6143       ieIdx++;
6144       initULRRCMsg->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCContainer;
6145       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6146       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6147                                                                  InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
6148
6149       ret = BuildDuToCuRrcContainer(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer);
6150       if(ret != ROK)
6151       {
6152          break;
6153       }
6154
6155       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
6156
6157       /* Encode the F1SetupRequest type as APER */
6158       memset(encBuf, 0, ENC_BUF_MAX_LEN);
6159       encBufSize = 0;
6160       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
6161       /* Encode results */
6162       if(encRetVal.encoded == ENCODE_FAIL)
6163       {
6164          DU_LOG( "\nERROR  --> F1AP : Could not encode Initial UL RRC Message Transfer\
6165                structure (at %s)\n",encRetVal.failed_type ? \
6166                encRetVal.failed_type->name : "unknown");
6167          ret = RFAILED;
6168          break;
6169       }
6170       else
6171       {
6172
6173          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for Initial UL RRC\
6174                Message transfer\n");
6175          for(int i=0; i< encBufSize; i++)
6176          {
6177             printf("%x",encBuf[i]);
6178          }
6179       }
6180       /* Sending  msg  */
6181       if(sendF1APMsg() != ROK)
6182       {
6183          DU_LOG("\nERROR  -->  F1AP : Sending Initial UL RRC Message Transfer Failed");
6184          ret = RFAILED;
6185          break;
6186       }
6187       break;
6188    }
6189    freeInitUlRrcMsgTransfer(f1apMsg);
6190    return ret;
6191 }/* End of BuildAndSendInitialRrcMsgTransfer*/
6192
6193 /*****  UE SETUP REQUEST *****/
6194
6195 /*******************************************************************
6196  *
6197  * @brief Free Qos And Snssai Drb Info
6198  *
6199  * @details
6200  *
6201  *    Function : freeDrbQosAndSnssaiInfo
6202  *
6203  *    Functionality: Free Qos And Snssai Drb Info
6204  *
6205  * @params[in] LcCfg *lcCfg,
6206  * @return void
6207  *
6208  * ****************************************************************/
6209 void freeDrbQosAndSnssaiInfo(LcCfg *lcCfg)
6210 {
6211    if(lcCfg->snssai)
6212    {
6213       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6214    }
6215    if(lcCfg->drbQos)
6216    {
6217       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
6218    }
6219 }
6220
6221 /******************************************************************
6222 *
6223 * @brief Function to delete the RLC Lc cfg from UE APP DB
6224 *
6225 * @details
6226 *
6227 *  Function : freeRlcLcCfg
6228 *
6229 *  Functionality: Function to delete the RLC Lc cfg from UE APP DB
6230 *
6231 *
6232  *****************************************************************/
6233
6234 void freeRlcLcCfg(RlcBearerCfg *lcCfg)
6235 {
6236    switch(lcCfg->rlcMode)
6237    {
6238       case RLC_AM :
6239          {
6240             if(lcCfg->u.amCfg)
6241             {
6242                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.amCfg, sizeof(AmBearerCfg));
6243             }
6244             break;
6245          }
6246       case RLC_UM_BI_DIRECTIONAL :
6247          {
6248             if(lcCfg->u.umBiDirCfg)
6249             {
6250                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
6251             }
6252             break;
6253          }
6254       case RLC_UM_UNI_DIRECTIONAL_UL :
6255          {
6256             if(lcCfg->u.umUniDirUlCfg)
6257             {
6258                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
6259             }
6260             break;
6261
6262          }
6263       case RLC_UM_UNI_DIRECTIONAL_DL :
6264          {
6265             if(lcCfg->u.umUniDirDlCfg)
6266             {
6267                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
6268             }
6269             break;
6270          }
6271       default:
6272          DU_LOG("\nERROR  -->  DU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
6273          break;
6274    }
6275 }
6276
6277 /*******************************************************************
6278  *
6279  * @brief Function to free MacLcCfg
6280  *
6281  * @details
6282  *
6283  *    Function : freeMacLcCfg
6284  *
6285  *    Functionality: Function to free MacLcCfg
6286  *
6287  * @params[in] LcCfg *lcCfg,
6288  * @return void
6289  *
6290  * ****************************************************************/
6291
6292 void  freeMacLcCfg(LcCfg *lcCfg)
6293 {
6294     /* Deleting DRBQOS */
6295    if(lcCfg->drbQos)
6296    {
6297       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
6298    }
6299    /* Deleting SNSSAI */
6300    if(lcCfg->snssai)
6301    {
6302       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6303    }
6304 }
6305 /*******************************************************************
6306  *
6307  * @brief Free UE NR Capability received in UE Context setup request
6308  *
6309  * @details
6310  *
6311  *    Function : freeAperDecodeUeNrCapability
6312  *
6313  *    Functionality:
6314  *       Free UE NR Capability received in UE Context setup request
6315  *
6316  * @params[in]
6317  * @return ROK     - success
6318  *         RFAILED - failure
6319  *
6320  * ****************************************************************/
6321 void freeAperDecodeUeNrCapability(void *ueNrCapability)
6322 {
6323    uint8_t arrIdx =0;
6324    FeatureSets_t *featureSets =NULLP;
6325    UE_NR_Capability_t *ueNrCap = (UE_NR_Capability_t *)ueNrCapability;
6326
6327    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
6328    {
6329       for(arrIdx = 0; arrIdx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; arrIdx++)
6330       {
6331          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx])
6332             free(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx]);
6333       }
6334       free(ueNrCap->rf_Parameters.supportedBandListNR.list.array);
6335    }
6336
6337    if(ueNrCap->featureSets)
6338    {
6339       featureSets = ueNrCap->featureSets;
6340       if(featureSets->featureSetsDownlinkPerCC)
6341       {
6342          if(featureSets->featureSetsDownlinkPerCC->list.array)
6343          {
6344             for(arrIdx = 0; arrIdx < featureSets->featureSetsDownlinkPerCC->list.count; arrIdx++)
6345             {
6346                if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx])
6347                {
6348                   if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL)
6349                      free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL);
6350                   free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]);
6351                }
6352             }
6353             free(featureSets->featureSetsDownlinkPerCC->list.array);
6354          }
6355          free(featureSets->featureSetsDownlinkPerCC);
6356       }
6357       if(featureSets->featureSetsUplinkPerCC)
6358       {
6359          if(featureSets->featureSetsUplinkPerCC->list.array)
6360          {
6361             for(arrIdx = 0; arrIdx < featureSets->featureSetsUplinkPerCC->list.count; arrIdx++)
6362             {
6363                if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx])
6364                {
6365                   if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL)
6366                      free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL);
6367                   free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]);
6368                }
6369             }
6370             free(featureSets->featureSetsUplinkPerCC->list.array);
6371          }
6372          free(featureSets->featureSetsUplinkPerCC);
6373       }
6374       free(ueNrCap->featureSets);
6375    }
6376 }
6377
6378 /*******************************************************************
6379 *
6380 * @brief Function to free PdcchSearchSpcToAddModList
6381          where memory allocated by aper_decoder
6382 *
6383 * @details
6384 *
6385 *    Function : freeAperDecodePdcchSearchSpcToAddModList
6386 *
6387 *    Functionality: Function to free PdcchSearchSpcToAddModList
6388 *
6389 * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
6390 * @return void
6391 *
6392 * ****************************************************************/
6393
6394 void freeAperDecodePdcchSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
6395 {
6396    uint8_t searchSpcArrIdx=0;
6397    uint8_t searchSpcArrIdx1=0;
6398    struct  SearchSpace *searchSpc=NULLP;
6399
6400
6401    if(searchSpcList->list.array)
6402    {
6403       if(searchSpcList->list.array[searchSpcArrIdx1])
6404       {
6405          searchSpc = searchSpcList->list.array[searchSpcArrIdx1];
6406          if(searchSpc->controlResourceSetId)
6407          {
6408             if(searchSpc->monitoringSlotPeriodicityAndOffset)
6409             {
6410                if(searchSpc->monitoringSymbolsWithinSlot)
6411                {
6412                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
6413                   {
6414                      if(searchSpc->nrofCandidates)
6415                      {
6416                         if(searchSpc->searchSpaceType)
6417                         {
6418                            free(searchSpc->searchSpaceType->choice.ue_Specific);
6419                            free(searchSpc->searchSpaceType);
6420                         }
6421                         free(searchSpc->nrofCandidates);
6422                      }
6423                      free(searchSpc->monitoringSymbolsWithinSlot->buf);
6424                   }
6425                   free(searchSpc->monitoringSymbolsWithinSlot);
6426                }
6427                free(searchSpc->monitoringSlotPeriodicityAndOffset);
6428             }
6429             free(searchSpc->controlResourceSetId);
6430          }
6431       }
6432       for(searchSpcArrIdx = 0; searchSpcArrIdx < searchSpcList->list.count; searchSpcArrIdx++)
6433       {
6434          free(searchSpcList->list.array[searchSpcArrIdx]);
6435       }
6436       free(searchSpcList->list.array);
6437    }
6438 }
6439 /*******************************************************************
6440 *
6441 * @brief Function for free part for the memory allocated by aper_decoder
6442 *
6443 * @details
6444 *
6445 *    Function : freeAperDecodeBWPDlDedPdcchConfig
6446 *
6447 *    Functionality: Function to free BWPDlDedPdcchConfig
6448 *
6449 * @params[in]
6450 * @return void
6451 *
6452 * ****************************************************************/
6453
6454
6455 void freeAperDecodeBWPDlDedPdcchConfig(BWP_DownlinkDedicated_t *dlBwp)
6456 {
6457    uint8_t arrIdx1=0;
6458    uint8_t arrIdx2=0;
6459    struct PDCCH_Config *pdcchCfg=NULLP;
6460    struct ControlResourceSet *controlRSet=NULLP;
6461    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
6462
6463    if(dlBwp->pdcch_Config->choice.setup)
6464    {
6465       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
6466       if(pdcchCfg->controlResourceSetToAddModList)
6467       {
6468          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
6469          if(controlRSetList->list.array)
6470          {
6471             controlRSet = controlRSetList->list.array[arrIdx2];
6472             if(controlRSet)
6473             {
6474                if(controlRSet->frequencyDomainResources.buf)
6475                {
6476                   if(controlRSet->pdcch_DMRS_ScramblingID)
6477                   {
6478                      if(pdcchCfg->searchSpacesToAddModList)
6479                      {
6480                         freeAperDecodePdcchSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
6481                         free(pdcchCfg->searchSpacesToAddModList);
6482                      }
6483                      free(controlRSet->pdcch_DMRS_ScramblingID);
6484                   }
6485                   free(controlRSet->frequencyDomainResources.buf);
6486                }
6487             }
6488             for(arrIdx1 = 0; arrIdx1 <controlRSetList->list.count; arrIdx1++)
6489             {
6490                free(controlRSetList->list.array[arrIdx1]);
6491             }
6492             free(controlRSetList->list.array);
6493          }
6494          free(pdcchCfg->controlResourceSetToAddModList);
6495       }
6496       free(dlBwp->pdcch_Config->choice.setup);
6497    }
6498 }
6499 /*******************************************************************
6500 *
6501 * @brief Function to free PdschTimeDomAllocationList
6502 *     where the memory allocated by aper_decoder
6503 *
6504 * @details
6505 *
6506 *    Function : freeAperDecodePdschTimeDomAllocationList
6507 *
6508 *    Functionality: Function to free PdschTimeDomAllocationList
6509 *
6510 * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
6511 * @return void
6512 *
6513 * ****************************************************************/
6514
6515
6516 void freeAperDecodePdschTimeDomAllocationList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
6517 {
6518    uint8_t arrIdx=0;
6519
6520    if(timeDomAllocList->choice.setup)
6521    {
6522       if(timeDomAllocList->choice.setup->list.array)
6523       {
6524          for(arrIdx = 0; arrIdx <timeDomAllocList->choice.setup->list.count ; arrIdx++)
6525          {
6526             free(timeDomAllocList->choice.setup->list.array[arrIdx]);
6527          }
6528          free(timeDomAllocList->choice.setup->list.array);
6529       }
6530       free(timeDomAllocList->choice.setup);
6531    }
6532 }
6533
6534 /*******************************************************************
6535 *
6536 * @brief Function to free BWPDlDedPdschConfig
6537 *        where the memory allocated by aper_decoder
6538 *
6539 * @details
6540 *
6541 *    Function : freeAperDecodeBWPDlDedPdschConfig
6542 *
6543 *    Functionality: Function to free BWPDlDedPdschConfig
6544 *
6545 * @params[in] BWP_DownlinkDedicated_t *dlBwp
6546 * @return void
6547 *
6548 * ****************************************************************/
6549
6550
6551 void freeAperDecodeBWPDlDedPdschConfig(BWP_DownlinkDedicated_t *dlBwp)
6552 {
6553    struct PDSCH_Config *pdschCfg=NULLP;
6554    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
6555    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
6556    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
6557
6558    if(dlBwp->pdsch_Config->choice.setup)
6559    {
6560       pdschCfg=dlBwp->pdsch_Config->choice.setup;
6561       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
6562       {
6563          if(pdschCfg->pdsch_TimeDomainAllocationList)
6564          {
6565             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
6566             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
6567             {
6568                prbBndlType=&pdschCfg->prb_BundlingType;
6569                free(prbBndlType->choice.staticBundling);
6570                free(pdschCfg->maxNrofCodeWordsScheduledByDCI);
6571             }
6572             freeAperDecodePdschTimeDomAllocationList(timeDomAllocList);
6573             free(pdschCfg->pdsch_TimeDomainAllocationList);
6574          }
6575          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
6576          if(dmrsDlCfg->choice.setup)
6577          {
6578             free(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition);
6579             free(dmrsDlCfg->choice.setup);
6580          }
6581          free(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA);
6582       }
6583       free(dlBwp->pdsch_Config->choice.setup);
6584    }
6585 }
6586 /*******************************************************************
6587 *
6588 * @brief Function to free PuschTimeDomAllocListCfg
6589                  where the memory allocated by aper_decoder
6590 *
6591 * @details
6592 *
6593 *    Function : freeAperDecodePuschTimeDomAllocListCfg
6594 *
6595 *    Functionality: Function to free PuschTimeDomAllocListCfg
6596 *
6597 * @params[in] PUSCH_Config_t *puschCfg
6598 * @return void
6599 *
6600 * ****************************************************************/
6601
6602
6603 void freeAperDecodePuschTimeDomAllocListCfg(PUSCH_Config_t *puschCfg)
6604 {
6605    uint8_t arrIdx=0;
6606    uint8_t arrIdx1=0;
6607    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
6608
6609    if(puschCfg->pusch_TimeDomainAllocationList)
6610    {
6611       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
6612       if(timeDomAllocList_t->choice.setup)
6613       {
6614          if(timeDomAllocList_t->choice.setup->list.array)
6615          {
6616             free(timeDomAllocList_t->choice.setup->list.array[arrIdx1]->k2);
6617             for(arrIdx = 0; arrIdx<timeDomAllocList_t->choice.setup->list.count; arrIdx++)
6618             {
6619                free(timeDomAllocList_t->choice.setup->list.array[arrIdx]);
6620             }
6621             free(timeDomAllocList_t->choice.setup->list.array);
6622          }
6623          free(timeDomAllocList_t->choice.setup);
6624       }
6625       free(puschCfg->transformPrecoder);
6626       free(puschCfg->pusch_TimeDomainAllocationList);
6627    }
6628 }
6629 /*******************************************************************
6630 *
6631 * @brief Function to free InitialUlBWPConfig where memory allocated by aper_decoder
6632 *
6633 * @details
6634 *
6635 *    Function : freeAperDecodeInitialUlBWPConfig
6636 *
6637 *    Functionality: Function to free InitialUlBWPConfig
6638 *
6639 * @params[in]  BWP_UplinkDedicated_t *ulBwp
6640 * @return void
6641 *
6642 * ****************************************************************/
6643
6644
6645 void freeAperDecodeInitialUlBWPConfig(BWP_UplinkDedicated_t *ulBwp)
6646 {
6647    uint8_t  rSetIdx =0;
6648    uint8_t  rsrcIdx =0;
6649    SRS_Config_t   *srsCfg = NULLP;
6650    PUSCH_Config_t *puschCfg = NULLP;
6651    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
6652    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
6653    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
6654    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
6655
6656    if(ulBwp->pusch_Config)
6657    {
6658       if(ulBwp->pusch_Config->choice.setup)
6659       {
6660          puschCfg=ulBwp->pusch_Config->choice.setup;
6661          if(puschCfg->dataScramblingIdentityPUSCH)
6662          {
6663             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
6664             {
6665                freeAperDecodePuschTimeDomAllocListCfg(puschCfg);
6666                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
6667                if(dmrsUlCfg->choice.setup)
6668                {
6669                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
6670                   {
6671                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
6672                      {
6673                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0);
6674                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled);
6675                      }
6676                      free(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition);
6677                   }
6678                   free(dmrsUlCfg->choice.setup);
6679                }
6680                free(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA);
6681             }
6682             free(puschCfg->dataScramblingIdentityPUSCH);
6683          }
6684          free(ulBwp->pusch_Config->choice.setup);
6685       }
6686       free(ulBwp->pusch_Config);
6687
6688       /* Free SRS-Config */
6689       if(ulBwp->srs_Config)
6690       {
6691          if(ulBwp->srs_Config->choice.setup)
6692          {
6693             srsCfg = ulBwp->srs_Config->choice.setup;
6694
6695             /* Free Resource Set to add/mod list */
6696             if(srsCfg->srs_ResourceSetToAddModList)
6697             {
6698                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
6699                if(rsrcSetList->list.array)
6700                {
6701                   rSetIdx = 0;
6702
6703                   /* Free SRS resource Id list in this SRS resource set */
6704                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
6705                   {
6706                      rsrcIdList =
6707                         rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
6708
6709                      if(rsrcIdList->list.array)
6710                      {
6711                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count;
6712                               rsrcIdx++)
6713                         {
6714                            free(rsrcIdList->list.array[rsrcIdx]);
6715                         }
6716                         free(rsrcIdList->list.array);
6717                      }
6718                      free(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList);
6719                   }
6720
6721                   /* Free resource type info for this SRS resource set */
6722
6723                   free(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic);
6724
6725                   /* Free memory for each resource set */
6726                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
6727                   {
6728                      free(rsrcSetList->list.array[rSetIdx]);
6729                   }
6730                   free(rsrcSetList->list.array);
6731                }
6732                free(srsCfg->srs_ResourceSetToAddModList);
6733             }
6734
6735             /* Free resource to add/modd list */
6736             if(srsCfg->srs_ResourceToAddModList)
6737             {
6738                resourceList = srsCfg->srs_ResourceToAddModList;
6739                if(resourceList->list.array)
6740                {
6741                   rsrcIdx = 0;
6742
6743                   free(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2);
6744                   free(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic);
6745
6746                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
6747                   {
6748                      free(resourceList->list.array[rsrcIdx]);
6749                   }
6750                   free(resourceList->list.array);
6751                }
6752                free(srsCfg->srs_ResourceToAddModList);
6753             }
6754
6755             free(ulBwp->srs_Config->choice.setup);
6756          }
6757          free(ulBwp->srs_Config);
6758       }
6759    }
6760 }
6761 /*******************************************************************
6762 *
6763 * @brief Function to free initialUplinkBWPConfig where memory allocated by aper_decoder
6764 *
6765 * @details
6766 *
6767 *    Function : freeAperDecodeinitialUplinkBWPConfig
6768 *
6769 *    Functionality: Function to free initialUplinkBWPConfig
6770 *
6771 * @params[in] UplinkConfig_t *ulCfg
6772 * @return void
6773 *
6774 * ****************************************************************/
6775
6776
6777 void freeAperDecodeinitialUplinkBWPConfig(UplinkConfig_t *ulCfg)
6778 {
6779    BWP_UplinkDedicated_t *ulBwp=NULLP;
6780    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
6781
6782    if(ulCfg->initialUplinkBWP)
6783    {
6784       ulBwp=ulCfg->initialUplinkBWP;
6785       if(ulCfg->firstActiveUplinkBWP_Id)
6786       {
6787          if(ulCfg->pusch_ServingCellConfig)
6788          {
6789             puschCfg=ulCfg->pusch_ServingCellConfig;
6790             if(puschCfg->choice.setup)
6791             {
6792                if(puschCfg->choice.setup->ext1)
6793                {
6794                   free(puschCfg->choice.setup->ext1->processingType2Enabled);
6795                   free(puschCfg->choice.setup->ext1->maxMIMO_Layers);
6796                   free(puschCfg->choice.setup->ext1);
6797                }
6798                free(puschCfg->choice.setup);
6799             }
6800             free(ulCfg->pusch_ServingCellConfig);
6801          }
6802          free(ulCfg->firstActiveUplinkBWP_Id);
6803       }
6804       freeAperDecodeInitialUlBWPConfig(ulBwp);
6805       free(ulCfg->initialUplinkBWP);
6806    }
6807 }
6808
6809 /*******************************************************************
6810  *
6811  * @brief Function to free DuUeCfg
6812  *
6813  * @details
6814  *
6815  *    Function : freeDuUeCfg
6816  *
6817  *    Functionality: Function to free DuUeCfg
6818  *
6819  * @params[in] DuUeCfg *ueCfg
6820  * @return void
6821  *
6822  * ****************************************************************/
6823 void freeDuUeCfg(DuUeCfg *ueCfg)
6824 {
6825    uint8_t lcIdx = 0;
6826    uint8_t arrIdx = 0;
6827    SpCellConfig_t *spCellCfg = NULLP;
6828    ServingCellConfig_t *srvCellCfg = NULLP;
6829    BWP_DownlinkDedicated_t *dlBwp = NULLP;
6830    MAC_CellGroupConfig_t *macCellGrpCfg = NULLP;
6831    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
6832    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList = NULLP;
6833    struct RLC_Config *rlcConfig = NULLP;
6834    struct LogicalChannelConfig *macLcConfig = NULLP;
6835    struct SchedulingRequestConfig *schedulingRequestConfig = NULLP;
6836    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList = NULLP;
6837    struct TAG_Config *tagConfig = NULLP;
6838    struct TAG_Config__tag_ToAddModList *tagList = NULLP;
6839    struct MAC_CellGroupConfig__phr_Config *phrConfig = NULLP;
6840    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg = NULLP;
6841    CellGroupConfigRrc_t *cellGrpCfg = ueCfg->cellGrpCfg;
6842
6843    if(ueCfg->ueNrCapability)
6844    {
6845       freeAperDecodeUeNrCapability(ueCfg->ueNrCapability);
6846       DU_FREE(ueCfg->ueNrCapability, sizeof(UE_NR_Capability_t));
6847       ueCfg->ueNrCapability = NULLP;
6848    }
6849
6850    if(ueCfg->cellGrpCfg)
6851    {
6852
6853       rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6854       if(rlcBearerList)
6855       {
6856          if(rlcBearerList->list.array)
6857          {
6858             for(arrIdx=0; arrIdx<rlcBearerList->list.count; arrIdx++)
6859             {
6860                if(rlcBearerList->list.array[arrIdx])
6861                {
6862                   rlcConfig   = rlcBearerList->list.array[arrIdx]->rlc_Config;
6863                   macLcConfig = rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig;
6864
6865                   if(rlcBearerList->list.array[arrIdx]->servedRadioBearer)
6866                   {
6867                      free(rlcBearerList->list.array[arrIdx]->servedRadioBearer);
6868                   }
6869                   if(rlcConfig)
6870                   {
6871                      if(rlcConfig->choice.am)
6872                      {
6873                         free(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength);
6874                         free(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength);
6875                         free(rlcConfig->choice.am);
6876                      }
6877                      free(rlcBearerList->list.array[arrIdx]->rlc_Config);
6878                   }
6879                   if(macLcConfig)
6880                   {
6881                      if(macLcConfig->ul_SpecificParameters)
6882                      {
6883                         free(macLcConfig->ul_SpecificParameters->schedulingRequestID);
6884                         free(macLcConfig->ul_SpecificParameters->logicalChannelGroup);
6885                         free(macLcConfig->ul_SpecificParameters);
6886                      }
6887                      free(rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig);
6888                   }
6889                   free(rlcBearerList->list.array[arrIdx]);
6890                }
6891             }
6892             free(rlcBearerList->list.array);
6893          }
6894          free(cellGrpCfg->rlc_BearerToAddModList);
6895       }
6896
6897       macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
6898       if(macCellGrpCfg)
6899       {
6900          schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
6901          if(schedulingRequestConfig)
6902          {
6903             schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
6904             if(schReqList)
6905             {
6906                if(schReqList->list.array)
6907                {
6908                   for(arrIdx=0;arrIdx<schReqList->list.count; arrIdx++)
6909                   {
6910                      if(schReqList->list.array[arrIdx])
6911                      {
6912                         free(schReqList->list.array[arrIdx]->sr_ProhibitTimer);
6913                         free(schReqList->list.array[arrIdx]);
6914                      }
6915                   }
6916                   free(schReqList->list.array);
6917                }
6918                free(schedulingRequestConfig->schedulingRequestToAddModList);
6919             }
6920             free(macCellGrpCfg->schedulingRequestConfig);
6921          }
6922          if(macCellGrpCfg->bsr_Config)
6923          {
6924             free(macCellGrpCfg->bsr_Config);
6925          }
6926          tagConfig = macCellGrpCfg->tag_Config;
6927          if(tagConfig)
6928          {
6929             tagList = tagConfig->tag_ToAddModList;
6930             if(tagList)
6931             {
6932                if(tagList->list.array)
6933                {
6934                   for(arrIdx=0; arrIdx<tagList->list.count; arrIdx++)
6935                   {
6936                      free(tagList->list.array[arrIdx]);
6937                   }
6938                   free(tagList->list.array);
6939                }
6940                free(tagConfig->tag_ToAddModList);
6941             }
6942             free(tagConfig);
6943          }
6944
6945          phrConfig = macCellGrpCfg->phr_Config;
6946          if(phrConfig)
6947          {
6948             free(phrConfig->choice.setup);
6949             free(phrConfig);
6950          }
6951
6952          free(macCellGrpCfg);
6953       }
6954
6955       phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
6956       if(phyCellGrpCfg)
6957       {
6958          free(phyCellGrpCfg->p_NR_FR1);
6959          free(phyCellGrpCfg);
6960       }
6961
6962       spCellCfg = cellGrpCfg->spCellConfig;
6963       if(spCellCfg)
6964       {
6965          if(spCellCfg->servCellIndex)
6966          {
6967             if(spCellCfg->rlmInSyncOutOfSyncThreshold)
6968             {
6969                if(spCellCfg->spCellConfigDedicated)
6970                {
6971                   srvCellCfg = spCellCfg->spCellConfigDedicated;
6972                   if(srvCellCfg->initialDownlinkBWP)
6973                   {
6974                      dlBwp = srvCellCfg->initialDownlinkBWP;
6975                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
6976                      {
6977                         if(srvCellCfg->defaultDownlinkBWP_Id)
6978                         {
6979                            if(srvCellCfg->uplinkConfig)
6980                            {
6981
6982                               if(srvCellCfg->pdsch_ServingCellConfig)
6983                               {
6984                                  pdschCfg=
6985                                     srvCellCfg->pdsch_ServingCellConfig;
6986                                  if(pdschCfg->choice.setup)
6987                                  {
6988
6989                                     free(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH);
6990                                     free(pdschCfg->choice.setup);
6991                                  }
6992
6993                                  free(srvCellCfg->pdsch_ServingCellConfig);
6994                               }
6995
6996                               freeAperDecodeinitialUplinkBWPConfig(srvCellCfg->uplinkConfig);
6997                               free(srvCellCfg->uplinkConfig);
6998                            }
6999                            free(srvCellCfg->defaultDownlinkBWP_Id);
7000                         }
7001
7002                         free(srvCellCfg->firstActiveDownlinkBWP_Id);
7003                      }
7004                      if(dlBwp->pdcch_Config)
7005                      {
7006                         if(dlBwp->pdsch_Config)
7007                         {
7008                            freeAperDecodeBWPDlDedPdschConfig(dlBwp);
7009                            free(dlBwp->pdsch_Config);
7010                         }
7011                         freeAperDecodeBWPDlDedPdcchConfig(dlBwp);
7012                         free(dlBwp->pdcch_Config);
7013                      }
7014                      free(srvCellCfg->initialDownlinkBWP);
7015                   }
7016
7017                   free(spCellCfg->spCellConfigDedicated);
7018                }
7019                free(spCellCfg->rlmInSyncOutOfSyncThreshold);
7020             }
7021             free(spCellCfg->servCellIndex);
7022          }
7023          free(spCellCfg);
7024       }
7025       DU_FREE(ueCfg->cellGrpCfg, sizeof(CellGroupConfigRrc_t));
7026       ueCfg->cellGrpCfg = NULLP;
7027    }
7028    if(ueCfg->ambrCfg)
7029    {
7030       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->ambrCfg, sizeof(AmbrCfg));
7031    }
7032    for(lcIdx = 0; lcIdx < ueCfg->numRlcLcs; lcIdx++)
7033    {
7034       freeRlcLcCfg(&ueCfg->rlcLcCfg[lcIdx]);
7035    }
7036    for(lcIdx = 0; lcIdx < ueCfg->numMacLcs; lcIdx++)
7037    {
7038       freeMacLcCfg(&ueCfg->macLcCfg[lcIdx]);
7039    }
7040    for(lcIdx = 0; lcIdx < ueCfg->numDrb; lcIdx++)
7041    {
7042       DU_FREE(ueCfg->upTnlInfo[lcIdx].tnlCfg1, sizeof(GtpTnlCfg));
7043    }
7044 }
7045
7046 /*******************************************************************
7047  *
7048  * @brief Function to free UecontextSetupDb
7049  *
7050  * @details
7051  *
7052  *    Function : freeF1UeDb
7053  *
7054  *    Functionality: Function to free UecontextSetupDb
7055  *
7056  * @params[in] UecontextSetupDb *
7057  * @return void
7058  *
7059  * ****************************************************************/
7060
7061 void freeF1UeDb(F1UeContextSetupDb *f1UeDb)
7062 {
7063
7064    if(f1UeDb->dlRrcMsg)
7065    {
7066       if(f1UeDb->dlRrcMsg->rrcMsgPdu)
7067       {
7068         //DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,\
7069                f1UeDb->dlRrcMsg->rrcMsgPdu, f1UeDb->dlRrcMsg->rrcMsgSize);
7070       }
7071       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
7072    }
7073    freeDuUeCfg(&f1UeDb->duUeCfg);
7074    memset(f1UeDb, 0, sizeof(F1UeContextSetupDb));
7075    DU_FREE(f1UeDb, sizeof(F1UeContextSetupDb));
7076 }
7077
7078 /*******************************************************************
7079  *
7080  * @brief Function to build Am cfg Info
7081  *
7082  * @details
7083  *
7084  *    Function : extractRlcAmCfg
7085  *
7086  *    Functionality: Function to build Am cfg Info
7087  *
7088  * @params[in] AmBearerCfg *
7089  *             void *
7090  *
7091  * @return ROK/RFAILED
7092  *
7093  * ****************************************************************/
7094
7095 void extractRlcAmCfg(AmBearerCfg *amCfgToSet, struct RLC_Config__am *rlcAmCfg)
7096 {
7097    if(rlcAmCfg)
7098    {
7099       /* UL AM */
7100       if(rlcAmCfg->dl_AM_RLC.sn_FieldLength)
7101       {
7102          amCfgToSet->ulAmCfg.snLenUl = *(rlcAmCfg->dl_AM_RLC.sn_FieldLength);
7103          /*TODO: Check the timer value when sent by real CU */
7104          amCfgToSet->ulAmCfg.reAssemTmr = rlcAmCfg->dl_AM_RLC.t_Reassembly;
7105          amCfgToSet->ulAmCfg.statProhTmr = rlcAmCfg->dl_AM_RLC.t_StatusProhibit;
7106       }
7107
7108       /* DL AM */
7109       if(rlcAmCfg->ul_AM_RLC.sn_FieldLength)
7110       {
7111          amCfgToSet->dlAmCfg.snLenDl = *(rlcAmCfg->ul_AM_RLC.sn_FieldLength);
7112          amCfgToSet->dlAmCfg.pollRetxTmr = rlcAmCfg->ul_AM_RLC.t_PollRetransmit;
7113          amCfgToSet->dlAmCfg.pollPdu   = rlcAmCfg->ul_AM_RLC.pollPDU;
7114          amCfgToSet->dlAmCfg.pollByte  = rlcAmCfg->ul_AM_RLC.pollByte;
7115          amCfgToSet->dlAmCfg.maxRetxTh = rlcAmCfg->ul_AM_RLC.maxRetxThreshold;
7116       }
7117    }
7118 }
7119
7120 /*******************************************************************
7121  *
7122  * @brief Function to build Um Bi Info
7123  *
7124  * @details
7125  *
7126  *    Function : extractRlcUmBiCfg
7127  *
7128  *    Functionality: Function to build Um Bi Info
7129  *
7130  * @params[in] UmBiDirBearerCfg *
7131  *             void *
7132  *
7133  * @return ROK/RFAILED
7134  *
7135  * ****************************************************************/
7136
7137 void extractRlcUmBiCfg(UmBiDirBearerCfg *umBiCfgToSet, struct RLC_Config__um_Bi_Directional *rlcBiCfg)
7138 {
7139    if(rlcBiCfg)
7140    {
7141       /* UL UM BI DIR Cfg */
7142       if(rlcBiCfg->dl_UM_RLC.sn_FieldLength)
7143       {
7144          umBiCfgToSet->ulUmCfg.snLenUlUm  = *(rlcBiCfg->dl_UM_RLC.sn_FieldLength);
7145          umBiCfgToSet->ulUmCfg.reAssemTmr = rlcBiCfg->dl_UM_RLC.t_Reassembly;
7146       }
7147
7148       /* DL UM BI DIR Cfg */
7149       if(rlcBiCfg->ul_UM_RLC.sn_FieldLength)
7150          umBiCfgToSet->dlUmCfg.snLenDlUm  = *(rlcBiCfg->ul_UM_RLC.sn_FieldLength);
7151    }
7152 }
7153
7154 /*******************************************************************
7155  *
7156  * @brief Function to build Um Ul Info
7157  *
7158  * @details
7159  *
7160  *    Function : extractRlcUmUlCfg
7161  *
7162  *    Functionality: Function to build Um Ul Info
7163  *
7164  * @params[in] UmUniDirUlBearerCfg *
7165  *             void *
7166  *
7167  * @return ROK/RFAILED
7168  *
7169  * ****************************************************************/
7170
7171 void extractRlcUmUlCfg(UmUniDirUlBearerCfg *umUlCfgToSet, struct RLC_Config__um_Uni_Directional_DL *umUlCfg)
7172 {
7173    if(umUlCfg)
7174    {
7175       if(umUlCfg->dl_UM_RLC.sn_FieldLength)
7176       {
7177          umUlCfgToSet->ulUmCfg.snLenUlUm  = *(umUlCfg->dl_UM_RLC.sn_FieldLength);
7178          umUlCfgToSet->ulUmCfg.reAssemTmr = umUlCfg->dl_UM_RLC.t_Reassembly;
7179       }
7180    }
7181 }
7182
7183 /*******************************************************************
7184  *
7185  * @brief Function to build Um Uni Dl Info
7186  *
7187  * @details
7188  *
7189  *    Function : extractRlcUmDlCfg
7190  *
7191  *    Functionality: Function to build Um Uni Dl Info
7192  *
7193  * @params[in] UmUniDirDlBearerCfg *
7194  *             void *
7195  *
7196  * @return ROK/RFAILED
7197  *
7198  * ****************************************************************/
7199 void extractRlcUmDlCfg(UmUniDirDlBearerCfg *umDlCfgToSet, struct RLC_Config__um_Uni_Directional_UL *umDlCfg)
7200 {
7201    if(umDlCfg)
7202    {
7203       if(umDlCfg->ul_UM_RLC.sn_FieldLength)
7204          umDlCfgToSet->dlUmCfg.snLenDlUm  = *(umDlCfg->ul_UM_RLC.sn_FieldLength);
7205    }
7206 }
7207
7208 /*******************************************************************
7209  *
7210  * @brief Function to extractRlcModeCfg
7211  *
7212  * @details
7213  *
7214  *    Function : extractRlcModeCfg
7215  *
7216  *    Functionality: Function to extractRlcModeCfg
7217  *
7218  * @params[in] RLC_Config_t *
7219  *             RlcBearerCfg *
7220  *             void  *
7221  * @return ROK/RFAILED
7222  *
7223  * ****************************************************************/
7224 void extractRlcModeCfg(uint8_t rlcMode, RlcBearerCfg *rlcDbCfg, RLC_Config_t *lcCfg)
7225 {
7226    if(lcCfg)
7227    {
7228       switch(rlcMode)
7229       {
7230          case RLC_AM :
7231             {
7232                if(lcCfg->choice.am)
7233                {
7234                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.amCfg, sizeof(AmBearerCfg));
7235                   if(rlcDbCfg->u.amCfg)
7236                      extractRlcAmCfg(rlcDbCfg->u.amCfg, lcCfg->choice.am);
7237                }
7238                break;
7239             }
7240          case RLC_UM_BI_DIRECTIONAL :
7241             {
7242                if(lcCfg->choice.um_Bi_Directional)
7243                {
7244                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
7245                   if(rlcDbCfg->u.umBiDirCfg)
7246                      extractRlcUmBiCfg(rlcDbCfg->u.umBiDirCfg, lcCfg->choice.um_Bi_Directional);
7247                }
7248                break;
7249             }
7250          case RLC_UM_UNI_DIRECTIONAL_UL :
7251             {
7252                if(lcCfg->choice.um_Uni_Directional_DL)
7253                {
7254                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
7255                   if(rlcDbCfg->u.umUniDirUlCfg)
7256                      extractRlcUmUlCfg(rlcDbCfg->u.umUniDirUlCfg, lcCfg->choice.um_Uni_Directional_DL);
7257                }
7258                break;
7259             }
7260          case RLC_UM_UNI_DIRECTIONAL_DL :
7261             {
7262                if(lcCfg->choice.um_Uni_Directional_UL)
7263                {
7264                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
7265                   if(rlcDbCfg->u.umUniDirDlCfg)
7266                      extractRlcUmDlCfg(rlcDbCfg->u.umUniDirDlCfg, lcCfg->choice.um_Uni_Directional_UL);
7267                }
7268                break;
7269             }
7270          default:
7271             DU_LOG("\nERROR  -->  DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
7272             break;
7273       }
7274    }
7275 }
7276
7277 /*******************************************************************
7278  *
7279  * @brief Function to extract extractUlLcCfg
7280  *
7281  * @details
7282  *
7283  *    Function : extractUlLcCfg
7284  *
7285  *    Functionality: Function to extract extractUlLcCfg
7286  *
7287  * @params[in] UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg
7288  * @return void
7289  *
7290  * ****************************************************************/
7291
7292 void extractUlLcCfg(UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg)
7293 {
7294    if(ulLcCfg)
7295    {
7296       if(ulLcCfg->ul_SpecificParameters)
7297       {
7298          f1UlLcCfg->priority = \
7299             ulLcCfg->ul_SpecificParameters->priority;
7300       if(ulLcCfg->ul_SpecificParameters->logicalChannelGroup)
7301       {
7302          f1UlLcCfg->lcGroup = \
7303            *(ulLcCfg->ul_SpecificParameters->logicalChannelGroup);
7304       }
7305       if(ulLcCfg->ul_SpecificParameters->schedulingRequestID)
7306       {
7307          f1UlLcCfg->schReqId = \
7308            *(ulLcCfg->ul_SpecificParameters->schedulingRequestID);
7309       }
7310       f1UlLcCfg->pbr = \
7311          ulLcCfg->ul_SpecificParameters->prioritisedBitRate;
7312       f1UlLcCfg->bsd = \
7313          ulLcCfg->ul_SpecificParameters->bucketSizeDuration;
7314       }
7315    }
7316 }
7317
7318 /*******************************************************************
7319  *
7320  * @brief Function to procRlcLcCfg
7321  *
7322  * @details
7323  *
7324  *    Function : procRlcLcCfg
7325  *
7326  *    Functionality: Function to procRlcLcCfg
7327  *
7328  * @params[in] rbId, lcId, rbType, rlcMod
7329  *             RLC_Config_t *, RlcBearerCfg * ,
7330  * @return void
7331  *
7332  * ****************************************************************/
7333
7334 void procRlcLcCfg(uint8_t rbId, uint8_t lcId, uint8_t rbType, uint8_t rlcMode,\
7335    uint8_t configType, RLC_Config_t *f1RlcCfg, RlcBearerCfg *lcCfg)
7336 {
7337
7338    lcCfg->rbId   = rbId;
7339    lcCfg->configType = configType;
7340
7341    if(rbType == RB_TYPE_SRB)
7342    {
7343       lcCfg->rbType = RB_TYPE_SRB;
7344       lcCfg->lcId   = rbId;
7345       lcCfg->lcType = LCH_DCCH;
7346       lcCfg->rlcMode = RLC_AM;
7347    }
7348    else if(rbType == RB_TYPE_DRB)
7349    {
7350       lcCfg->rbType = RB_TYPE_DRB;
7351       lcCfg->lcId   = lcId;
7352       lcCfg->lcType = LCH_DTCH;
7353       lcCfg->rlcMode = rlcMode;
7354    }
7355    if(f1RlcCfg) /* rlc mode config recived */
7356    {
7357       extractRlcModeCfg(lcCfg->rlcMode, lcCfg, f1RlcCfg);
7358    }
7359 }
7360
7361
7362
7363 /*******************************************************************
7364  *
7365  * @brief Fills DrbQos Info received by CU
7366  *
7367  * @details
7368  *
7369  *    Function : extractQosInfo
7370  *
7371  *    Functionality: Fills DrbQos Info received  by CU
7372  *
7373  * @params[in] DrbQosInfo *qosToAdd,
7374  *             QoSFlowLevelQoSParameters_t *qosFlowCfg
7375  * @return void
7376  *
7377  * ****************************************************************/
7378
7379 void extractQosInfo(DrbQosInfo *qosToAdd, QoSFlowLevelQoSParameters_t *qosFlowCfg)
7380 {
7381    qosToAdd->fiveQiType = qosFlowCfg->qoS_Characteristics.present;
7382    qosToAdd->u.nonDyn5Qi.fiveQi     =\
7383          qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
7384    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow)
7385    {
7386       qosToAdd->u.nonDyn5Qi.avgWindow = \
7387         *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
7388    }
7389    qosToAdd->u.nonDyn5Qi.maxDataBurstVol = \
7390       *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
7391    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel)
7392    {
7393       qosToAdd->u.nonDyn5Qi.priorLevel = \
7394          *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel);
7395    }
7396    qosToAdd->ngRanRetPri.priorityLevel = \
7397       qosFlowCfg->nGRANallocationRetentionPriority.priorityLevel;
7398    qosToAdd->ngRanRetPri.preEmptionCap = \
7399       qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionCapability;
7400    qosToAdd->ngRanRetPri.preEmptionVul = \
7401       qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionVulnerability;
7402    if(qosFlowCfg->gBR_QoS_Flow_Information)
7403    {
7404       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateDl, \
7405          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.buf, \
7406          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.size);
7407       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateUl, \
7408          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.buf, \
7409          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.size);
7410       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateDl,\
7411          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.buf, \
7412          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.size);
7413       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateUl,\
7414          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.buf, \
7415          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.size);
7416    }
7417    qosToAdd->pduSessionId = 0;
7418    qosToAdd->ulPduSessAggMaxBitRate = 0;
7419 }
7420
7421 /*******************************************************************
7422  *
7423  * @brief Function to extract GTP Tunnel Info from CU
7424  *
7425  * @details
7426  *
7427  *    Function : extractUpTnlInfo
7428  *
7429  *    Functionality: Function to extract GTP Tunnel Info from CU
7430  *
7431  * @params[in] F1AP message
7432  * @return ROK/RFAILED
7433  *
7434  * ****************************************************************/
7435
7436 uint8_t extractUpTnlInfo(uint8_t drbId, uint8_t configType,\
7437    ULUPTNLInformation_ToBeSetup_List_t *tnlInfo, UpTnlCfg *upTnlInfo)
7438 {
7439    uint8_t tnlIdx;
7440    uint32_t ipv4_du = 0;
7441    GTPTunnel_t *gtpTunnel = NULLP;
7442
7443    upTnlInfo->drbId = drbId;
7444    upTnlInfo->configType = configType;
7445 #ifdef O1_ENABLE
7446    cmInetAddr((S8*)g_cfg.DU_IPV4_Addr, &ipv4_du);
7447 #else
7448    cmInetAddr((char *)DU_IP_V4_ADDR, &ipv4_du);
7449 #endif
7450
7451    for(tnlIdx=0; tnlIdx < tnlInfo->list.count; tnlIdx++)
7452    {
7453       if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
7454       {
7455          if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel)
7456          {
7457             gtpTunnel = tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel;
7458             DU_ALLOC(upTnlInfo->tnlCfg1, sizeof(GtpTnlCfg));
7459             if(upTnlInfo->tnlCfg1 == NULLP)
7460             {
7461                DU_LOG("\nERROR  -->  F1AP : extractUpTnlInfo: Failed to allocate mmeory for tunnel cfg 1");
7462                return RFAILED;
7463             }
7464             bitStringToInt(&gtpTunnel->transportLayerAddress, &upTnlInfo->tnlCfg1->ulTnlAddress);
7465             upTnlInfo->tnlCfg1->dlTnlAddress = ipv4_du;
7466             if(gtpTunnel->gTP_TEID.size > 0)
7467             {
7468                teIdStringToInt(gtpTunnel->gTP_TEID.buf, &upTnlInfo->tnlCfg1->teId);
7469             }
7470          }
7471          break;
7472       }
7473    }
7474    return ROK;
7475 }
7476 /*******************************************************************
7477 *
7478 * @brief Function to extract Drb Qos Cfg Info from CU
7479 *
7480 * @details
7481 *
7482 *    Function : extractDrbQosCfg
7483 *
7484 *    Functionality: Function to extract Drb Qos Cfg Info from CU
7485 *
7486 * @params[in] DRB_Information_t *drbInfo, LcCfg *macLcToAdd
7487 * @return ROK/RFAILED
7488 *
7489 * ****************************************************************/
7490
7491 uint8_t extractDrbQosCfg(DRB_Information_t *drbInfo, LcCfg *macLcToAdd )
7492 {
7493    if(!macLcToAdd->drbQos)
7494    {
7495       DU_ALLOC_SHRABL_BUF(macLcToAdd->drbQos, sizeof(DrbQosInfo));
7496       if(macLcToAdd->drbQos == NULLP)
7497       {
7498          DU_LOG("\nERROR  -->  DUAPP:Memory failed at allocating DrbQos at extractDrbCfg()");
7499          return RFAILED;
7500       }
7501
7502    }
7503    if(drbInfo->dRB_QoS.qoS_Characteristics.present == QoS_Characteristics_PR_non_Dynamic_5QI)
7504    {
7505       extractQosInfo(macLcToAdd->drbQos, &drbInfo->dRB_QoS);
7506       macLcToAdd->dlLcCfg.lcp = macLcToAdd->drbQos->ngRanRetPri.priorityLevel;
7507    }
7508    if(!macLcToAdd->snssai)
7509    {
7510       DU_ALLOC_SHRABL_BUF(macLcToAdd->snssai, sizeof(Snssai));
7511       if(macLcToAdd->snssai == NULLP)
7512       {
7513          DU_LOG("\nERROR  -->  DUAPP : Memory failed at allocating SNSSAI at extractDrbCfg()");
7514          return RFAILED;
7515       }
7516    }
7517    memcpy(&macLcToAdd->snssai->sst, drbInfo->sNSSAI.sST.buf, \
7518          drbInfo->sNSSAI.sST.size);
7519    if(drbInfo->sNSSAI.sD)
7520    {
7521       memcpy(macLcToAdd->snssai->sd, drbInfo->sNSSAI.sD->buf, \
7522             drbInfo->sNSSAI.sD->size);
7523    }
7524    return ROK;
7525 }
7526 /*******************************************************************
7527  *
7528  * @brief Function to extract DRB info received from CU
7529  *
7530  * @details
7531  *
7532  *    Function : extractDrbCfg
7533  *
7534  *    Functionality: Function to extract DRB info received from CU
7535  *
7536  * @params[in] F1AP message
7537  * @return void
7538  *
7539  * ****************************************************************/
7540 uint8_t extractDrbCfg(DRBs_ToBeSetup_Item_t *drbItem,DRBs_ToBeSetupMod_Item_t *drbSetupModItem,\
7541 LcCfg *macLcToAdd, UpTnlCfg *upTnlInfo)
7542 {
7543    DRB_Information_t *drbInfo = NULLP;
7544
7545    if(drbItem != NULLP)
7546    {
7547       if(extractUpTnlInfo(drbItem->dRBID, CONFIG_ADD, &drbItem->uLUPTNLInformation_ToBeSetup_List, upTnlInfo) != ROK)
7548       {
7549          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7550          return RFAILED;
7551       }
7552       if(drbItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7553       {
7554          if(drbItem->qoSInformation.choice.choice_extension->value.present == QoSInformation_ExtIEs__value_PR_DRB_Information)
7555          {
7556             drbInfo = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7557             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7558             {
7559                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7560                return RFAILED;
7561             }
7562          }
7563       }
7564    }
7565    else if(drbSetupModItem != NULLP)
7566    {
7567       if(extractUpTnlInfo(drbSetupModItem->dRBID, CONFIG_ADD, &drbSetupModItem->uLUPTNLInformation_ToBeSetup_List,\
7568       upTnlInfo) != ROK)
7569       {
7570          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7571          return RFAILED;
7572       }
7573       if(drbSetupModItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7574       {
7575          if(drbSetupModItem->qoSInformation.choice.choice_extension->value.present ==\
7576          QoSInformation_ExtIEs__value_PR_DRB_Information)
7577          {
7578             drbInfo = &drbSetupModItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7579             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7580             {
7581                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7582                return RFAILED;
7583             }
7584
7585          }
7586       }
7587    }
7588
7589    return ROK;
7590 }
7591
7592 /*******************************************************************
7593  *
7594  * @brief Function to extract RB info received from CU
7595  *
7596  * @details
7597  *
7598  *    Function : extractMacRbCfg
7599  *
7600  *    Functionality: Function to extract RB info received from CU
7601  *
7602  * @params[in] F1AP message
7603  * @return ROK/RFAILED
7604  *
7605  * ****************************************************************/
7606
7607 uint8_t extractMacRbCfg(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbCfg,\
7608 DRBs_ToBeSetupMod_Item_t *drbSetupModCfg,  LogicalChannelConfig_t *ulLcCfg, LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7609 {
7610    if(drbCfg != NULLP)
7611    {
7612       if(extractDrbCfg(drbCfg, NULL, lcCfg, upTnlInfo) != ROK)
7613       {
7614          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7615          return RFAILED;
7616       }
7617    }
7618    else if(drbSetupModCfg != NULLP)
7619    {
7620       if(extractDrbCfg(NULL, drbSetupModCfg, lcCfg, upTnlInfo) != ROK)
7621       {
7622          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7623          return RFAILED;
7624       }
7625    }
7626    else
7627    {
7628       lcCfg->drbQos = NULLP;
7629       lcCfg->snssai = NULLP;
7630       if(lcCfg->lcId == SRB2_LCID)
7631          lcCfg->dlLcCfg.lcp = LC_PRIORITY_3;
7632       else
7633          lcCfg->dlLcCfg.lcp = LC_PRIORITY_1;
7634    }
7635    if(ulLcCfg)
7636    {
7637       lcCfg->ulLcCfgPres = true;
7638       extractUlLcCfg(&lcCfg->ulLcCfg, ulLcCfg);
7639    }
7640    else
7641       lcCfg->ulLcCfgPres = false;
7642    return ROK;
7643 }
7644
7645 /*******************************************************************
7646  *
7647  * @brief Function processing LC config info received from CU
7648  *
7649  * @details
7650  *
7651  *    Function : procMacLcCfg
7652  *
7653  *    Functionality: Function processing LC config info received from CU
7654  *
7655  * @params[in] F1AP message
7656  * @return ROK/RFAILED
7657  *
7658  * ****************************************************************/
7659
7660 uint8_t procMacLcCfg(uint8_t lcId, uint8_t rbType, uint8_t configType,\
7661 DRBs_ToBeSetup_Item_t *drbItem, DRBs_ToBeSetupMod_Item_t *drbSetupModItem, LogicalChannelConfig_t *ulLcCfg,\
7662 LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7663 {
7664    uint8_t ret = ROK;
7665
7666    lcCfg->lcId = lcId;
7667    lcCfg->configType = configType;
7668    if(rbType == RB_TYPE_SRB)
7669    {
7670       ret = extractMacRbCfg(lcId, NULL,NULL, ulLcCfg, lcCfg, NULL);
7671    }
7672    else if(rbType == RB_TYPE_DRB)
7673    {
7674       if(drbItem != NULL)
7675         ret = extractMacRbCfg(lcId, drbItem, NULL, ulLcCfg, lcCfg, upTnlInfo);
7676       else if(drbSetupModItem != NULL)
7677         ret = extractMacRbCfg(lcId, NULL, drbSetupModItem, ulLcCfg, lcCfg, upTnlInfo);
7678    }
7679    return ret;
7680 }
7681
7682 /*******************************************************************
7683  *
7684  * @brief Function to extract Rlc cfg To Add/Mod in CellGrp Info
7685  *
7686  * @details
7687  *
7688  *    Function : extractRlcCfgToAddMod
7689  *
7690  *    Functionality: Function to extract Rlc cfg To Add/Mod in CellGrp Info
7691  *
7692  * @params[in] CellGroupConfigRrc__rlc_BearerTo pointer
7693  *             DuUeCfg Pointer
7694  * @return ROK/RFAILED
7695  *
7696  * ****************************************************************/
7697
7698 uint8_t extractRlcCfgToAddMod(struct CellGroupConfigRrc__rlc_BearerToAddModList *lcCfg, DuUeCfg *ueCfgDb)
7699 {
7700   uint8_t idx, rbId, lcId, rlcMode, rbType;
7701   RLC_Config_t *f1RlcCfg = NULLP;
7702   LogicalChannelConfig_t *macUlLcCfg = NULLP;
7703
7704   for(idx = 0; idx < lcCfg->list.count; idx++)
7705   {
7706      lcId = lcCfg->list.array[idx]->logicalChannelIdentity;
7707      if(lcCfg->list.array[idx]->servedRadioBearer)
7708      {
7709         /* RadioBearer for SRB/DRB */
7710         if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7711         RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
7712         {
7713            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.srb_Identity;
7714            rbType = RB_TYPE_SRB;
7715         }
7716         else if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7717         RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
7718         {
7719            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.drb_Identity;
7720            rbType = RB_TYPE_DRB;
7721         }
7722         else
7723         {
7724            DU_LOG("\nERROR  -->  No components present in Bearer config to ADD/MOD");
7725            return RFAILED;
7726         }
7727         /* MAC UL LC Config */
7728         if(lcCfg->list.array[idx]->mac_LogicalChannelConfig)
7729         {
7730            macUlLcCfg = lcCfg->list.array[idx]->mac_LogicalChannelConfig;
7731         }
7732      }
7733      else
7734      {
7735         DU_LOG("\nERROR  -->  DUAPP: Received RadioBearer config is NULL");
7736         return RFAILED;
7737      }
7738      /* RLC Mode Config */
7739      if(lcCfg->list.array[idx]->rlc_Config)
7740      {
7741         rlcMode  = lcCfg->list.array[idx]->rlc_Config->present;
7742         f1RlcCfg = lcCfg->list.array[idx]->rlc_Config;
7743      }
7744
7745      /* Filling RLC/MAC Config*/
7746      memset(&ueCfgDb->macLcCfg[idx], 0, sizeof(LcCfg));
7747      memset(&ueCfgDb->rlcLcCfg[idx], 0, sizeof(RlcBearerCfg));
7748      procRlcLcCfg(rbId, lcId, rbType, rlcMode, CONFIG_UNKNOWN, f1RlcCfg, &(ueCfgDb->rlcLcCfg[idx]));
7749      if(procMacLcCfg(lcId, rbType, CONFIG_UNKNOWN, NULL, NULL, macUlLcCfg, &ueCfgDb->macLcCfg[idx], NULL) != ROK)
7750      {
7751         DU_LOG("\nERROR  -->  DU APP : Failed while filling MAC LC config at extractRlcCfgToAddMod()");
7752         return RFAILED;
7753      }
7754      (ueCfgDb->numRlcLcs)++;
7755      (ueCfgDb->numMacLcs)++;
7756   }
7757   //TODO: To send the failure cause in UeContextSetupRsp
7758   return ROK;
7759 }
7760
7761 /*******************************************************************
7762  *
7763  * @brief DeAlloc pdsch serv cell config info
7764  *
7765  * @details
7766  *
7767  *    Function : freeMacPdschServCellInfo
7768  *
7769  *    Functionality: DeAlloc pdsch serv cell config info
7770  *
7771  * @params[in] PdschServCellCfg pointer
7772  * @return void
7773  *
7774  * ****************************************************************/
7775
7776 void freeMacPdschServCellInfo(PdschServCellCfg *pdsch)
7777 {
7778    if(pdsch->xOverhead)
7779    {
7780       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->xOverhead, sizeof(PdschXOverhead));
7781    }
7782    if(pdsch->codeBlkGrpFlushInd)
7783    {
7784       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->codeBlkGrpFlushInd, sizeof(bool));
7785    }
7786    if(pdsch->maxCodeBlkGrpPerTb)
7787    {
7788       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
7789    }
7790    if(pdsch->maxMimoLayers)
7791    {
7792       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxMimoLayers, sizeof(uint8_t));
7793    }
7794 }
7795
7796 /*******************************************************************
7797  *
7798  * @brief Free Serving cell Info
7799  *
7800  * @details
7801  *
7802  *    Function : freeMacServingCellInfo
7803  *
7804  *    Functionality: Free Serving cell Info
7805  *
7806  * @params[in] ServCellCfgInfo *srvCellCfg
7807  * @return void
7808  *
7809  * ****************************************************************/
7810 void freeMacServingCellInfo(ServCellCfgInfo *srvCellCfg)
7811 {
7812    uint8_t timeDomRsrcIdx;
7813
7814    if(srvCellCfg->initDlBwp.pdschPresent)
7815    {
7816       for(timeDomRsrcIdx = 0; timeDomRsrcIdx < srvCellCfg->initDlBwp.pdschCfg.numTimeDomRsrcAlloc; timeDomRsrcIdx++)
7817       {
7818          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, \
7819             srvCellCfg->initDlBwp.pdschCfg.timeDomRsrcAllociList[timeDomRsrcIdx].k0, sizeof(uint8_t));
7820       }
7821    }
7822
7823    freeMacPdschServCellInfo(&srvCellCfg->pdschServCellCfg);
7824    if(srvCellCfg->bwpInactivityTmr)
7825    {
7826       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
7827    }
7828
7829    if(srvCellCfg->initUlBwp.pucchPresent)
7830    {
7831       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->initUlBwp.pucchCfg.dlDataToUlAck, sizeof(PucchDlDataToUlAck));
7832    }
7833 }
7834
7835 /*******************************************************************
7836  *
7837  * @brief Free cell Grp Cfg Info
7838  *
7839  * @details
7840  *
7841  *    Function : freeUeReCfgCellGrpInfo
7842  *
7843  *    Functionality: Free cell Grp Cfg Info
7844  *
7845  * @params[in] MacUeCfg*  duUeCfg
7846  * @return void
7847  *
7848  * ****************************************************************/
7849
7850 void freeUeReCfgCellGrpInfo(MacUeCfg *macUeCfg)
7851 {
7852    freeMacServingCellInfo(&macUeCfg->spCellCfg.servCellCfg);
7853 }
7854
7855 /*******************************************************************
7856  *
7857  * @brief Fills Reconfig SchReqReConfig
7858  *
7859  * @details
7860  *
7861  *    Function : extractSchReqReConfig
7862  *
7863  *    Functionality: Fills Reconfig SchReqReConfig
7864  *
7865  * @params[in] SchedulingRequestConfig_t *cuSchedReq
7866  *             SchedReqCfg*  macSchedReq
7867  * @return void
7868  *
7869  * ****************************************************************/
7870 void extractSchReqReConfig(SchedulingRequestConfig_t *cuSchedReq, SchedReqCfg *macSchedReq)
7871 {
7872    uint8_t schReqIdx = 0;
7873    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqListToAdd = NULLP;
7874    struct SchedulingRequestConfig__schedulingRequestToReleaseList *schReqListToRel = NULLP;
7875
7876    if(cuSchedReq->schedulingRequestToAddModList)
7877    {
7878       schReqListToAdd = cuSchedReq->schedulingRequestToAddModList;
7879       if(schReqListToAdd->list.count)
7880       {
7881          macSchedReq->addModListCount = schReqListToAdd->list.count;
7882          for(schReqIdx = 0; schReqIdx < schReqListToAdd->list.count; schReqIdx++)
7883          {
7884             macSchedReq->addModList[schReqIdx].schedReqId = \
7885                schReqListToAdd->list.array[schReqIdx]->schedulingRequestId;
7886             macSchedReq->addModList[schReqIdx].srProhibitTmr = \
7887                *(schReqListToAdd->list.array[schReqIdx]->sr_ProhibitTimer);
7888             macSchedReq->addModList[schReqIdx].srTransMax    =\
7889                schReqListToAdd->list.array[schReqIdx]->sr_TransMax;
7890          }
7891       }
7892    }
7893    /* Scheduling Req To release */
7894    if(cuSchedReq->schedulingRequestToReleaseList)
7895    {
7896       schReqListToRel = cuSchedReq->schedulingRequestToReleaseList;
7897       if(schReqListToRel->list.count)
7898       {
7899          macSchedReq->relListCount = schReqListToRel->list.count;
7900          for(schReqIdx = 0; schReqIdx < schReqListToRel->list.count; schReqIdx++)
7901          {
7902             macSchedReq->relList[schReqIdx] = \
7903                *schReqListToRel->list.array[schReqIdx];
7904          }
7905       }
7906    }
7907 }
7908
7909 /*******************************************************************
7910  *
7911  * @brief Fills TagReconfig
7912  *
7913  * @details
7914  *
7915  *    Function : extractTagReconfig
7916  *
7917  *    Functionality: Fills extractTagReconfig
7918  *
7919  * @params[in] TAG_Config_t *cuTagCfg
7920  *             TagCfg *macTagCfg
7921  * @return void
7922  *
7923  * ****************************************************************/
7924
7925 void extractTagReconfig(TAG_Config_t *cuTagCfg, TagCfg *macTagCfg)
7926 {
7927   uint8_t tagIdx = 0;
7928   struct TAG_Config__tag_ToAddModList  *tagListToAddMod = NULLP;
7929   struct TAG_Config__tag_ToReleaseList *tagListToRel = NULLP;
7930
7931   /* Tag config to AddMod */
7932   if(cuTagCfg->tag_ToAddModList)
7933   {
7934      tagListToAddMod = cuTagCfg->tag_ToAddModList;
7935      if(tagListToAddMod->list.count)
7936      {
7937         macTagCfg->addModListCount = tagListToAddMod->list.count;
7938         for(tagIdx = 0; tagIdx < tagListToAddMod->list.count; tagIdx++)
7939         {
7940            macTagCfg->addModList[tagIdx].tagId =\
7941               tagListToAddMod->list.array[tagIdx]->tag_Id;
7942            macTagCfg->addModList[tagIdx].timeAlignTimer = \
7943
7944               tagListToAddMod->list.array[tagIdx]->timeAlignmentTimer;
7945         }
7946      }
7947   }
7948   /* Tag config to release */
7949   if(cuTagCfg->tag_ToReleaseList)
7950   {
7951      tagListToRel = cuTagCfg->tag_ToReleaseList;
7952      if(tagListToRel->list.count)
7953      {
7954         macTagCfg->relListCount = tagListToRel->list.count;
7955         for(tagIdx = 0; tagIdx < tagListToRel->list.count; tagIdx++)
7956         {
7957            macTagCfg->relList[tagIdx] = *tagListToRel->list.array[tagIdx];
7958         }
7959      }
7960   }
7961 }
7962
7963 /*******************************************************************
7964  *
7965  * @brief Fills PdcchCfg received by CU
7966  *
7967  * @details
7968  *
7969  *    Function : extractPdcchCfg
7970  *
7971  *    Functionality: Fills PdcchCfg received  by CU
7972  *
7973  * @params[in] PDCCH_Config_t *cuPdcchCfg,
7974  *             PdcchConfig *duPdcchCfg
7975  * @return void
7976  *
7977  * ****************************************************************/
7978
7979 void extractPdcchCfg(PDCCH_Config_t *cuPdcchCfg, PdcchConfig *macPdcchCfg)
7980 {
7981    uint8_t cRsetIdx = 0;
7982    uint8_t srchSpcIdx = 0;
7983
7984    struct PDCCH_Config__controlResourceSetToAddModList *cRsetToAddModList = NULLP;
7985    struct PDCCH_Config__controlResourceSetToReleaseList *cRsetToRelList = NULLP;
7986    struct PDCCH_Config__searchSpacesToAddModList *srchSpcToAddModList = NULLP;
7987    struct PDCCH_Config__searchSpacesToReleaseList *srchSpcToRelList = NULLP;
7988
7989
7990    /* Control Resource Set To Add/Mod List */
7991    if(cuPdcchCfg->controlResourceSetToAddModList)
7992    {
7993       cRsetToAddModList = cuPdcchCfg->controlResourceSetToAddModList;
7994       if(cRsetToAddModList->list.count)
7995       {
7996          macPdcchCfg->numCRsetToAddMod = cRsetToAddModList->list.count;
7997          for(cRsetIdx = 0; cRsetIdx < cRsetToAddModList->list.count; cRsetIdx++)
7998          {
7999             macPdcchCfg->cRSetToAddModList[cRsetIdx].cRSetId = \
8000               cRsetToAddModList->list.array[cRsetIdx]->controlResourceSetId;
8001             bitStringToInt(&cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources,\
8002                macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc);
8003             macPdcchCfg->cRSetToAddModList[cRsetIdx].duration = \
8004               cRsetToAddModList->list.array[cRsetIdx]->duration;
8005
8006             macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType = \
8007               cRsetToAddModList->list.array[cRsetIdx]->cce_REG_MappingType.present;
8008             if(macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType == CCE_REG_MAPPINGTYPE_PR_INTERLEAVED)
8009             {
8010                //TODO: handle the case for Interleaved
8011             }
8012             macPdcchCfg->cRSetToAddModList[cRsetIdx].precoderGranularity = \
8013               cRsetToAddModList->list.array[cRsetIdx]->precoderGranularity;
8014             if(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID)
8015             {
8016                macPdcchCfg->cRSetToAddModList[cRsetIdx].dmrsScramblingId= \
8017                   *(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID);
8018             }
8019          }
8020       }
8021
8022    }
8023    /* Control Resource Set To Release List */
8024    if(cuPdcchCfg->controlResourceSetToReleaseList)
8025    {
8026       cRsetToRelList = cuPdcchCfg->controlResourceSetToReleaseList;
8027       if(cRsetToRelList->list.count)
8028       {
8029          macPdcchCfg->numCRsetToRel = cRsetToRelList->list.count;
8030          for(cRsetIdx = 0; cRsetIdx < cRsetToRelList->list.count; cRsetIdx++)
8031          {
8032             macPdcchCfg->cRSetToRelList[cRsetIdx] = *(cRsetToRelList->list.array[cRsetIdx]);
8033          }
8034       }
8035    }
8036
8037    /* Search space To Add/Mod List */
8038    if(cuPdcchCfg->searchSpacesToAddModList)
8039    {
8040       srchSpcToAddModList = cuPdcchCfg->searchSpacesToAddModList;
8041       if(srchSpcToAddModList->list.count)
8042       {
8043          macPdcchCfg->numSearchSpcToAddMod = srchSpcToAddModList->list.count;
8044          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToAddModList->list.count; srchSpcIdx++)
8045          {
8046             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceId =\
8047                srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceId;
8048             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].cRSetId =\
8049                *(srchSpcToAddModList->list.array[srchSpcIdx]->controlResourceSetId);
8050             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset)
8051             {
8052                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset =\
8053                   srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset->present;
8054             }
8055             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot)
8056             {
8057                bitStringToInt(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot,\
8058                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSymbolsWithinSlot);
8059             }
8060             if(srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates)
8061             {
8062               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel1 = \
8063                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel1;
8064               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel2 = \
8065                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel2;
8066               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel4 = \
8067                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel4;
8068
8069               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel8 = \
8070                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel8;
8071
8072               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel16 = \
8073                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel16;
8074             }
8075             if(srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType)
8076             {
8077                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType =\
8078                   srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->present;
8079                if(macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType == SEARCHSPACETYPE_PR_UE_SPECIFIC)
8080                {
8081                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].ueSpecificDciFormat =\
8082                      srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->choice.ue_Specific->dci_Formats;
8083                }
8084
8085             }
8086          }
8087       }
8088    }
8089    /* Search space To Rel List */
8090    if(cuPdcchCfg->searchSpacesToReleaseList)
8091    {
8092       srchSpcToRelList = cuPdcchCfg->searchSpacesToReleaseList;
8093       if(srchSpcToRelList->list.count)
8094       {
8095          macPdcchCfg->numSearchSpcToRel = srchSpcToRelList->list.count;
8096          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToRelList->list.count; srchSpcIdx++)
8097          {
8098             macPdcchCfg->searchSpcToRelList[srchSpcIdx] =\
8099                *(srchSpcToRelList->list.array[srchSpcIdx]);
8100          }
8101       }
8102    }
8103 }
8104
8105 /*******************************************************************
8106  *
8107  * @brief Fills PdschCfg received by CU
8108  *
8109  * @details
8110  *
8111  *    Function : extractPdschCfg
8112  *
8113  *    Functionality: Fills PdschCfg received  by CU
8114  *
8115  * @params[in] PDSCH_Config_t *cuPdschCfg,
8116  *             PdschConfig *macPdschCfg
8117  * @return void
8118  *
8119  * ****************************************************************/
8120
8121 void extractPdschCfg(PDSCH_Config_t *cuPdschCfg, PdschConfig *macPdschCfg)
8122 {
8123    uint8_t timeDomIdx;
8124    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAlloc = NULLP;
8125
8126    if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
8127    {
8128       if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->present == \
8129             PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup)
8130       {
8131          if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup)
8132          {
8133             macPdschCfg->dmrsDlCfgForPdschMapTypeA.addPos = \
8134                *(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_AdditionalPosition);
8135          }
8136       }
8137    }
8138    macPdschCfg->resourceAllocType = cuPdschCfg->resourceAllocation;
8139    if(cuPdschCfg->pdsch_TimeDomainAllocationList)
8140    {
8141       timeDomAlloc = cuPdschCfg->pdsch_TimeDomainAllocationList;
8142       if(timeDomAlloc->present ==\
8143             PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup)
8144       {
8145          if(timeDomAlloc->choice.setup)
8146          {
8147             macPdschCfg->numTimeDomRsrcAlloc  = timeDomAlloc->choice.setup->list.count;
8148             for(timeDomIdx = 0; timeDomIdx < timeDomAlloc->choice.setup->list.count; timeDomIdx++)
8149             {
8150                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 = NULLP;
8151                if(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0)
8152                {
8153                   if(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 == NULL)
8154                   {
8155                      DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
8156                      if(!macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
8157                      {
8158                         DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for k0 at extractPdschCfg()");
8159                         return RFAILED;
8160                      }
8161                   }
8162                   *(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0) = \
8163                        *(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0);
8164                }
8165                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
8166                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
8167                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
8168                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8169             }
8170          }
8171       }
8172    }
8173    macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
8174    if(cuPdschCfg->maxNrofCodeWordsScheduledByDCI)
8175       macPdschCfg->numCodeWordsSchByDci = *(cuPdschCfg->maxNrofCodeWordsScheduledByDCI);
8176    if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_staticBundling)
8177    {
8178       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
8179       if(cuPdschCfg->prb_BundlingType.choice.staticBundling)
8180       {
8181          if(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize)
8182          {
8183             macPdschCfg->bundlingInfo.StaticBundling.size = \
8184                *(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize);
8185          }
8186       }
8187    }
8188    else if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_dynamicBundling)
8189    {
8190       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
8191    }
8192
8193 }
8194
8195 /*******************************************************************
8196  *
8197  * @brief Fills PdschServingCellCfg received by CU
8198  *
8199  * @details
8200  *
8201  *    Function : extractPdschServingCellCfg
8202  *
8203  *    Functionality: Fills PdschCfg received  by CU
8204  *
8205  * @params[in] PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg,
8206  *             PdschServCellCfg *macUePdschSrvCellCfg
8207  * @return ROK/RFAILED
8208  *
8209  * ****************************************************************/
8210
8211 uint8_t extractPdschServingCellCfg(PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg, PdschServCellCfg *macUePdschSrvCellCfg)
8212 {
8213    if(cuPdschSrvCellCfg->codeBlockGroupTransmission)
8214    {
8215       if(cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup)
8216       {
8217          if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
8218          {
8219             *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
8220                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
8221          }
8222          else
8223          {
8224             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
8225             if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
8226             {
8227                *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
8228                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
8229             }
8230             else
8231             {
8232                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
8233                return RFAILED;
8234             }
8235          }
8236          if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
8237          {
8238             *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
8239                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
8240          }
8241          else
8242          {
8243             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->codeBlkGrpFlushInd , sizeof(bool));
8244             if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
8245             {
8246                *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
8247                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
8248             }
8249             else
8250             {
8251                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
8252                return RFAILED;
8253             }
8254          }
8255       }
8256    }
8257    if(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH)
8258    {
8259       macUePdschSrvCellCfg->numHarqProcForPdsch = *(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH);
8260    }
8261    if(cuPdschSrvCellCfg->ext1)
8262    {
8263       if(cuPdschSrvCellCfg->ext1->maxMIMO_Layers)
8264       {
8265         if(macUePdschSrvCellCfg->maxMimoLayers)
8266         {
8267            *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
8268         }
8269         else
8270         {
8271            DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxMimoLayers, sizeof(uint8_t));
8272            if(macUePdschSrvCellCfg->maxMimoLayers)
8273            {
8274               *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
8275            }
8276            else
8277            {
8278               DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
8279               return RFAILED;
8280            }
8281         }
8282       }
8283    }
8284    if(cuPdschSrvCellCfg->xOverhead)
8285    {
8286       if(macUePdschSrvCellCfg->xOverhead)
8287       {
8288          *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
8289       }
8290       else
8291       {
8292          DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->xOverhead, sizeof(PdschXOverhead));
8293          if(macUePdschSrvCellCfg->xOverhead)
8294          {
8295             *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
8296          }
8297          else
8298          {
8299             DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
8300             return RFAILED;
8301          }
8302       }
8303    }
8304    return ROK;
8305 }
8306
8307 /*******************************************************************
8308  *
8309  * @brief Fills PuschCfg received by CU
8310  *
8311  * @details
8312  *
8313  *    Function : extractPuschCfg
8314  *
8315  *    Functionality: Fills PuschCfg received  by CU
8316  *
8317  * @params[in] BWP_UplinkDedicated__pusch_Config *cuPuschCfg,
8318  *             PuschCfg *macPuschCfg
8319  * @return void
8320  *
8321  * ****************************************************************/
8322
8323 void extractPuschCfg(struct BWP_UplinkDedicated__pusch_Config *cuPuschCfg, PuschCfg *macPuschCfg)
8324 {
8325    uint8_t timeDomIdx = 0;
8326    DMRS_UplinkConfig_t *dmrsUlCfg = NULLP;
8327    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList = NULLP;
8328
8329    if(cuPuschCfg->present == BWP_UplinkDedicated__pusch_Config_PR_setup)
8330    {
8331       if(cuPuschCfg->choice.setup)
8332       {
8333          if(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH)
8334          {
8335              macPuschCfg->dataScramblingId = \
8336                 *(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH);
8337          }
8338          if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA)
8339          {
8340             if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->present == PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup)
8341             {
8342                if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup)
8343                {
8344                   dmrsUlCfg = (cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup);
8345                   if(dmrsUlCfg->dmrs_AdditionalPosition)
8346                   {
8347                      macPuschCfg->dmrsUlCfgForPuschMapTypeA.addPos =\
8348                         *(dmrsUlCfg->dmrs_AdditionalPosition);
8349                   }
8350                   if(dmrsUlCfg->transformPrecodingDisabled)
8351                   {
8352                      if(dmrsUlCfg->transformPrecodingDisabled->scramblingID0)
8353                      {
8354                         macPuschCfg->dmrsUlCfgForPuschMapTypeA.transPrecodDisabled.scramblingId0 = \
8355                            *(dmrsUlCfg->transformPrecodingDisabled->scramblingID0);
8356                      }
8357                   }
8358                }
8359             }
8360          }
8361          /*Res Alloc Type for UL */
8362          if(cuPuschCfg->choice.setup->resourceAllocation)
8363          {
8364             macPuschCfg->resourceAllocType = \
8365                cuPuschCfg->choice.setup->resourceAllocation;
8366          }
8367          if(cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList)
8368          {
8369             timeDomAllocList = cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList;
8370             if(timeDomAllocList->present == PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup)
8371             {
8372                if(timeDomAllocList->choice.setup)
8373                {
8374                   macPuschCfg->numTimeDomRsrcAlloc = timeDomAllocList->choice.setup->list.count;
8375                   for(timeDomIdx = 0; timeDomIdx <timeDomAllocList->choice.setup->list.count; timeDomIdx++)
8376                   {
8377                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].k2 = \
8378                         *(timeDomAllocList->choice.setup->list.array[timeDomIdx]->k2);
8379                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].mappingType = \
8380                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->mappingType;
8381                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbolAndLength = \
8382                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8383                   }
8384                }
8385             }
8386          }
8387          if(cuPuschCfg->choice.setup->transformPrecoder)
8388             macPuschCfg->transformPrecoder = *(cuPuschCfg->choice.setup->transformPrecoder);
8389       }
8390    }
8391 }
8392
8393 /*******************************************************************
8394  *
8395  * @brief Function to fill pucch Power Control
8396  *
8397  * @details
8398  *
8399  *    Function : extractPucchPowerControl
8400  *
8401  *    Functionality: Function to fill pucch Power Control
8402  *
8403  * @params[in] PucchPowerControl *pwrCtrl,
8404  *             struct PUCCH_PowerControl *cuPwrCtrlCfg
8405  * @return void
8406  *
8407  * ****************************************************************/
8408
8409 void extractPucchPowerControl(PucchPowerControl *pwrCtrl, struct PUCCH_PowerControl *cuPwrCtrlCfg)
8410 {
8411    uint8_t arrIdx;
8412
8413    if(cuPwrCtrlCfg->deltaF_PUCCH_f0)
8414       pwrCtrl->deltaF_Format0 = *cuPwrCtrlCfg->deltaF_PUCCH_f0;
8415    if(cuPwrCtrlCfg->deltaF_PUCCH_f1)
8416       pwrCtrl->deltaF_Format1 = *cuPwrCtrlCfg->deltaF_PUCCH_f1;
8417    if(cuPwrCtrlCfg->deltaF_PUCCH_f2)
8418       pwrCtrl->deltaF_Format2 = *cuPwrCtrlCfg->deltaF_PUCCH_f2;
8419    if(cuPwrCtrlCfg->deltaF_PUCCH_f3)
8420       pwrCtrl->deltaF_Format3 = *cuPwrCtrlCfg->deltaF_PUCCH_f3;
8421    if(cuPwrCtrlCfg->deltaF_PUCCH_f4)
8422       pwrCtrl->deltaF_Format4 = *cuPwrCtrlCfg->deltaF_PUCCH_f4;
8423    if(cuPwrCtrlCfg->p0_Set)
8424    {
8425       pwrCtrl->p0SetCount = cuPwrCtrlCfg->p0_Set->list.count;
8426       for(arrIdx=0; arrIdx < pwrCtrl->p0SetCount; arrIdx++)
8427       {
8428          pwrCtrl->p0Set[arrIdx].p0PucchId =\
8429             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Id;
8430          pwrCtrl->p0Set[arrIdx].p0PucchVal =\
8431             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Value;
8432       }
8433    }
8434    if(cuPwrCtrlCfg->pathlossReferenceRSs)
8435    {
8436       pwrCtrl->pathLossRefRSListCount = cuPwrCtrlCfg->pathlossReferenceRSs->list.count;
8437       for(arrIdx = 0; arrIdx < pwrCtrl->pathLossRefRSListCount; arrIdx++)
8438       {
8439          pwrCtrl->pathLossRefRSList[arrIdx].pathLossRefRSId =\
8440             cuPwrCtrlCfg->pathlossReferenceRSs->list.array[arrIdx]->pucch_PathlossReferenceRS_Id;
8441       }
8442    }
8443 }
8444
8445  /*******************************************************************
8446  *
8447  * @brief Function to extractResrcSetToAddModList sent by CU
8448  *
8449  * @details
8450  *
8451  *    Function : extractResrcSetToAddModList
8452  *
8453  *    Functionality: Fucntion to extractResrcSetToAddModList
8454  *
8455  * @params[in] PucchResrcSetCfg pointer,
8456  *             struct PUCCH_Config__resourceSetToAddModList pointer
8457  * @return void
8458  *
8459  * ****************************************************************/
8460
8461 void extractResrcSetToAddModList(PucchResrcSetCfg *macRsrcSetList, struct PUCCH_Config__resourceSetToAddModList *cuRsrcSetList)
8462 {
8463    uint8_t arrIdx, rsrcListIdx;
8464
8465    macRsrcSetList->resrcSetToAddModListCount = cuRsrcSetList->list.count;
8466    for(arrIdx = 0; arrIdx < macRsrcSetList->resrcSetToAddModListCount; arrIdx++)
8467    {
8468       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcSetId     =\
8469          cuRsrcSetList->list.array[arrIdx]->pucch_ResourceSetId;
8470       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount =\
8471          cuRsrcSetList->list.array[arrIdx]->resourceList.list.count;
8472       for(rsrcListIdx = 0; rsrcListIdx < macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount; rsrcListIdx++)
8473       {
8474          macRsrcSetList->resrcSetToAddModList[arrIdx].resrcList[rsrcListIdx] =\
8475             *cuRsrcSetList->list.array[arrIdx]->resourceList.list.array[rsrcListIdx];
8476       }
8477       macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize =\
8478          *cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1;
8479    }
8480 }/* End of extractResrcSetToAddModList */
8481
8482 /*******************************************************************
8483  *
8484  * @brief Fills extractResrcToAddModList sent by CU
8485  *
8486  * @details
8487  *
8488  *    Function : extractResrcToAddModList
8489  *
8490  *    Functionality: Fills extractResrcToAddModList
8491  *
8492  * @params[in] PucchResrcCfg pointer,
8493  *             struct PUCCH_Config__resourceToAddModList pointer
8494  * @return ROk/RFAILED
8495  *
8496  * ****************************************************************/
8497
8498 uint8_t extractResrcToAddModList(PucchResrcCfg *macResrcList, struct PUCCH_Config__resourceToAddModList *cuResrcList)
8499 {
8500    uint8_t arrIdx;
8501
8502    macResrcList->resrcToAddModListCount = cuResrcList->list.count;
8503    for(arrIdx = 0; arrIdx < macResrcList->resrcToAddModListCount; arrIdx++)
8504    {
8505       macResrcList->resrcToAddModList[arrIdx].resrcId      =\
8506         cuResrcList->list.array[arrIdx]->pucch_ResourceId;
8507       macResrcList->resrcToAddModList[arrIdx].startPrb     =\
8508         cuResrcList->list.array[arrIdx]->startingPRB;
8509       if(cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping)
8510       {
8511          macResrcList->resrcToAddModList[arrIdx].intraFreqHop =\
8512            *cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping;
8513       }
8514       if(cuResrcList->list.array[arrIdx]->secondHopPRB)
8515       {
8516          macResrcList->resrcToAddModList[arrIdx].secondPrbHop =\
8517            *cuResrcList->list.array[arrIdx]->secondHopPRB;
8518       }
8519       /* PUCCH RSRC FORMAT */
8520       if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format0)
8521       {
8522          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_0;
8523          if(cuResrcList->list.array[arrIdx]->format.choice.format0)
8524          {
8525             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0, sizeof(PucchFormat0));
8526             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0 == NULLP)
8527             {
8528                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
8529                return RFAILED;
8530             }
8531             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->initialCyclicShift =\
8532                cuResrcList->list.array[arrIdx]->format.choice.format0->initialCyclicShift;
8533             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->numSymbols =\
8534                cuResrcList->list.array[arrIdx]->format.choice.format0->nrofSymbols;
8535             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->startSymbolIdx =\
8536                cuResrcList->list.array[arrIdx]->format.choice.format0->startingSymbolIndex;
8537          }
8538       }
8539       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format1)
8540       {
8541          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_1;
8542          if(cuResrcList->list.array[arrIdx]->format.choice.format1)
8543          {
8544             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1, sizeof(PucchFormat1));
8545             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1 == NULLP)
8546             {
8547                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
8548                return RFAILED;
8549             }
8550             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->initialCyclicShift =\
8551                 cuResrcList->list.array[arrIdx]->format.choice.format1->initialCyclicShift;
8552             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->numSymbols =\
8553                 cuResrcList->list.array[arrIdx]->format.choice.format1->nrofSymbols;
8554             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->startSymbolIdx =\
8555                 cuResrcList->list.array[arrIdx]->format.choice.format1->startingSymbolIndex;
8556             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->timeDomOCC =\
8557                 cuResrcList->list.array[arrIdx]->format.choice.format1->timeDomainOCC;
8558          }
8559       }
8560       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format2)
8561       {
8562          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_2;
8563          if(cuResrcList->list.array[arrIdx]->format.choice.format2)
8564          {
8565             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
8566             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2 == NULLP)
8567             {
8568                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
8569                return RFAILED;
8570             }
8571             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numPrbs =\
8572                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofPRBs;
8573             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numSymbols =\
8574                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofSymbols;
8575             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->startSymbolIdx =\
8576                 cuResrcList->list.array[arrIdx]->format.choice.format2->startingSymbolIndex;
8577          }
8578       }
8579       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format3)
8580       {
8581          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_3;
8582          if(cuResrcList->list.array[arrIdx]->format.choice.format3)
8583          {
8584             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
8585             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3 == NULLP)
8586             {
8587                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
8588                return RFAILED;
8589             }
8590             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numPrbs =\
8591                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofPRBs;
8592             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numSymbols =\
8593                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofSymbols;
8594             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->startSymbolIdx =\
8595                 cuResrcList->list.array[arrIdx]->format.choice.format3->startingSymbolIndex;
8596          }
8597       }
8598       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format4)
8599       {
8600          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_4;
8601          if(cuResrcList->list.array[arrIdx]->format.choice.format4)
8602          {
8603             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4, sizeof(PucchFormat4));
8604             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4 == NULLP)
8605             {
8606                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
8607                return RFAILED;
8608             }
8609             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->numSymbols =\
8610                 cuResrcList->list.array[arrIdx]->format.choice.format4->nrofSymbols;
8611             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occLen =\
8612                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Length;
8613             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occIdx =\
8614                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Index;
8615             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->startSymbolIdx =\
8616                 cuResrcList->list.array[arrIdx]->format.choice.format4->startingSymbolIndex;
8617          }
8618       }
8619    }
8620    return ROK;
8621
8622 }/* End of extractResrcToAddModList */
8623
8624 /*******************************************************************
8625  *
8626  * @brief Fills fillPucchSchedReqPeriodAndOffset sent by CU
8627  *
8628  * @details
8629  *
8630  *    Function : fillPucchSchedReqPeriodAndOffset
8631  *
8632  *    Functionality: To fillPucchSchedReqPeriodAndOffset
8633  *
8634  * @params[in] macPeriodicty,
8635  *     SchedulingRequestResourceConfig__periodicityAndOffset pointer
8636  * @return void
8637  *
8638  * ****************************************************************/
8639
8640 void fillPucchSchedReqPeriodAndOffset(uint8_t macPeriodicty, uint16_t  macOffset,\
8641    struct SchedulingRequestResourceConfig__periodicityAndOffset *cuPeriodicty)
8642 {
8643    macPeriodicty = cuPeriodicty->present;
8644    switch(macPeriodicty)
8645    {
8646       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
8647          {
8648             macOffset     = cuPeriodicty->choice.sym2;
8649             break;
8650          }
8651       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
8652          {
8653             macOffset     = cuPeriodicty->choice.sym6or7;
8654             break;
8655          }
8656       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
8657          {
8658             macOffset     = cuPeriodicty->choice.sl1;
8659             break;
8660          }
8661       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
8662          {
8663             macOffset = cuPeriodicty->choice.sl2;
8664             break;
8665          }
8666       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
8667          {
8668             macOffset = cuPeriodicty->choice.sl4;
8669             break;
8670          }
8671       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
8672          {
8673             macOffset = cuPeriodicty->choice.sl5;
8674             break;
8675          }
8676       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
8677          {
8678             macOffset = cuPeriodicty->choice.sl8;
8679             break;
8680          }
8681       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
8682          {
8683             macOffset = cuPeriodicty->choice.sl10;
8684             break;
8685          }
8686       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
8687          {
8688             macOffset = cuPeriodicty->choice.sl16;
8689             break;
8690          }
8691       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
8692          {
8693             macOffset = cuPeriodicty->choice.sl20;
8694             break;
8695          }
8696       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
8697          {
8698             macOffset = cuPeriodicty->choice.sl40;
8699             break;
8700          }
8701       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
8702          {
8703             macOffset = cuPeriodicty->choice.sl80;
8704             break;
8705          }
8706       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
8707          {
8708             macOffset = cuPeriodicty->choice.sl160;
8709             break;
8710          }
8711       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
8712          {
8713             macOffset = cuPeriodicty->choice.sl320;
8714             break;
8715          }
8716       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
8717          {
8718             macOffset = cuPeriodicty->choice.sl640;
8719             break;
8720          }
8721       default :
8722          DU_LOG("\nERROR  -->  F1AP : Invalid periodicity %d", macPeriodicty);
8723    }
8724 }
8725
8726 /*******************************************************************
8727  *
8728  * @brief Function to extractPucchFormatCfg sent by CU
8729  *
8730  * @details
8731  *
8732  *    Function : extractPucchFormatCfg
8733  *
8734  *    Functionality: Function to extractPucchFormatCfg
8735  *
8736  * @params[in] PucchFormatCfg pointer,
8737  *             PUCCH_FormatConfig_t pointer
8738  * @return void
8739  *
8740  * ****************************************************************/
8741
8742 void extractPucchFormatCfg(PucchFormatCfg *macFormatCfg, PUCCH_FormatConfig_t *cuFormatCfg)
8743  {
8744     if(cuFormatCfg->interslotFrequencyHopping)
8745        macFormatCfg->interSlotFreqHop = *cuFormatCfg->interslotFrequencyHopping;
8746     if(cuFormatCfg->additionalDMRS)
8747        macFormatCfg->addDmrs = *cuFormatCfg->additionalDMRS;
8748     if(cuFormatCfg->maxCodeRate)
8749        macFormatCfg->maxCodeRate = *cuFormatCfg->maxCodeRate;
8750     if(cuFormatCfg->nrofSlots)
8751        macFormatCfg->numSlots = *cuFormatCfg->nrofSlots;
8752     if(cuFormatCfg->pi2BPSK)
8753        macFormatCfg->pi2BPSK = *cuFormatCfg->pi2BPSK;
8754     if(cuFormatCfg->simultaneousHARQ_ACK_CSI)
8755        macFormatCfg->harqAckCSI = *cuFormatCfg->simultaneousHARQ_ACK_CSI;
8756  }/* End of extractPucchFormatCfg */
8757
8758 /*******************************************************************
8759  *
8760  * @brief Function to extractSchedReqCfgToAddMod sent by CU
8761  *
8762  * @details
8763  *
8764  *    Function : extractSchedReqCfgToAddMod
8765  *
8766  *    Functionality: Function to extractSchedReqCfgToAddMod
8767  *
8768  * @params[in] PucchSchedReqCfg pointer,
8769  *      PUCCH_Config__schedulingRequestResourceToAddModList pointer
8770  * @return void
8771  *
8772  * ****************************************************************/
8773
8774 void extractSchedReqCfgToAddMod(PucchSchedReqCfg *macSchedReqCfg, struct PUCCH_Config__schedulingRequestResourceToAddModList *cuSchedReqList)
8775 {
8776    uint8_t arrIdx;
8777
8778    macSchedReqCfg->schedAddModListCount = cuSchedReqList->list.count;
8779    for(arrIdx = 0; arrIdx <  macSchedReqCfg->schedAddModListCount; arrIdx++)
8780    {
8781       macSchedReqCfg->schedAddModList[arrIdx].resrcId =\
8782          cuSchedReqList->list.array[arrIdx]->schedulingRequestResourceId;
8783       macSchedReqCfg->schedAddModList[arrIdx].requestId =\
8784          cuSchedReqList->list.array[arrIdx]->schedulingRequestID;
8785       if(cuSchedReqList->list.array[arrIdx]->periodicityAndOffset)
8786       {
8787          fillPucchSchedReqPeriodAndOffset(macSchedReqCfg->schedAddModList[arrIdx].periodicity,\
8788             macSchedReqCfg->schedAddModList[arrIdx].offset, cuSchedReqList->list.array[arrIdx]->periodicityAndOffset);
8789       }
8790       if(cuSchedReqList->list.array[arrIdx]->resource)
8791       {
8792          macSchedReqCfg->schedAddModList[arrIdx].resrc =\
8793             *cuSchedReqList->list.array[arrIdx]->resource;
8794       }
8795    }
8796
8797 }/* End of extractSchedReqCfgToAddMod */
8798
8799  /*******************************************************************
8800  *
8801  * @brief Fills PucchCfg received by CU
8802  *
8803  * @details
8804  *
8805  *    Function : extractPucchCfg
8806  *
8807  *    Functionality: Fills PucchCfg received  by CU
8808  *
8809  * @params[in] BWP_UplinkDedicated__pucch_Config *cuPucchCfg,
8810  *             PucchCfg *macPucchCfg
8811  * @return ROK/RFAILED
8812  *
8813  * ****************************************************************/
8814
8815 uint8_t extractPucchCfg(struct BWP_UplinkDedicated__pucch_Config *cuPucchCfg, PucchCfg *macPucchCfg)
8816 {
8817    uint8_t arrIdx;
8818
8819    if(cuPucchCfg->present == BWP_UplinkDedicated__pucch_Config_PR_setup)
8820    {
8821       if(cuPucchCfg->choice.setup)
8822       {
8823          /* Resource Set Cfg */
8824          if(cuPucchCfg->choice.setup->resourceSetToAddModList)
8825          {
8826             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrcSet, sizeof(PucchResrcSetCfg));
8827             if(macPucchCfg->resrcSet == NULLP)
8828             {
8829                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
8830                return RFAILED;
8831             }
8832             memset(macPucchCfg->resrcSet, 0, sizeof(PucchResrcSetCfg));
8833             extractResrcSetToAddModList(macPucchCfg->resrcSet, cuPucchCfg->choice.setup->resourceSetToAddModList);
8834          }
8835
8836          /* Resource Cfg */
8837          if(cuPucchCfg->choice.setup->resourceToAddModList)
8838          {
8839             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrc, sizeof(PucchResrcCfg));
8840             if(macPucchCfg->resrc == NULLP)
8841             {
8842                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
8843                return RFAILED;
8844             }
8845             memset(macPucchCfg->resrc, 0, sizeof(PucchResrcCfg));
8846             extractResrcToAddModList(macPucchCfg->resrc, cuPucchCfg->choice.setup->resourceToAddModList);
8847          }
8848
8849          /* Format 1 Cfg */
8850          if(cuPucchCfg->choice.setup->format1)
8851          {
8852             DU_ALLOC_SHRABL_BUF(macPucchCfg->format1, sizeof(PucchFormatCfg));
8853             if(macPucchCfg->format1 == NULLP)
8854             {
8855                DU_LOG("\nERROR --> F1AP : Failed to extract format 1 Cfg in  extractPucchCfg()");
8856                return RFAILED;
8857             }
8858             memset(macPucchCfg->format1, 0, sizeof(PucchFormatCfg));
8859             extractPucchFormatCfg(macPucchCfg->format1,\
8860                cuPucchCfg->choice.setup->format1->choice.setup);
8861          }
8862
8863          /* Format 2 Cfg */
8864          if(cuPucchCfg->choice.setup->format2)
8865          {
8866             DU_ALLOC_SHRABL_BUF(macPucchCfg->format2, sizeof(PucchFormatCfg));
8867             if(macPucchCfg->format2 == NULLP)
8868             {
8869                DU_LOG("\nERROR --> F1AP : Failed to extract format 2 Cfg in  extractPucchCfg()");
8870                return RFAILED;
8871             }
8872             memset(macPucchCfg->format2, 0, sizeof(PucchFormatCfg));
8873             extractPucchFormatCfg(macPucchCfg->format2,\
8874                cuPucchCfg->choice.setup->format2->choice.setup);
8875          }
8876
8877          /* Format 3 Cfg */
8878          if(cuPucchCfg->choice.setup->format3)
8879          {
8880             DU_ALLOC_SHRABL_BUF(macPucchCfg->format3, sizeof(PucchFormatCfg));
8881             if(macPucchCfg->format3 == NULLP)
8882             {
8883                DU_LOG("\nERROR --> F1AP : Failed to extract format 3 Cfg in  extractPucchCfg()");
8884                return RFAILED;
8885             }
8886             memset(macPucchCfg->format3, 0, sizeof(PucchFormatCfg));
8887             extractPucchFormatCfg(macPucchCfg->format3,\
8888                cuPucchCfg->choice.setup->format3->choice.setup);
8889          }
8890
8891          /* Format 4 Cfg */
8892          if(cuPucchCfg->choice.setup->format4)
8893          {
8894             DU_ALLOC_SHRABL_BUF(macPucchCfg->format4, sizeof(PucchFormatCfg));
8895             if(macPucchCfg->format4 == NULLP)
8896             {
8897                DU_LOG("\nERROR --> F1AP : Failed to extract format 4 Cfg in  extractPucchCfg()");
8898                return RFAILED;
8899             }
8900             memset(macPucchCfg->format4, 0, sizeof(PucchFormatCfg));
8901             extractPucchFormatCfg(macPucchCfg->format4,\
8902                cuPucchCfg->choice.setup->format4->choice.setup);
8903          }
8904
8905          /* Sched Req List */
8906          if(cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList)
8907          {
8908             DU_ALLOC_SHRABL_BUF(macPucchCfg->schedReq, sizeof(PucchSchedReqCfg));
8909             if(macPucchCfg->schedReq == NULLP)
8910             {
8911                DU_LOG("\nERROR --> F1AP : Failed to extract schedReqCfg in  extractPucchCfg()");
8912                return RFAILED;
8913             }
8914             memset(macPucchCfg->schedReq, 0, sizeof(PucchSchedReqCfg));
8915             extractSchedReqCfgToAddMod(macPucchCfg->schedReq,\
8916             cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList);
8917          }
8918
8919          /*TODO: Add support for  Spatial Info */
8920
8921          /* MultiCsiCfg */
8922          if(cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList)
8923          {
8924             DU_ALLOC_SHRABL_BUF(macPucchCfg->multiCsiCfg, sizeof(PucchMultiCsiCfg));
8925             if(macPucchCfg->multiCsiCfg == NULLP)
8926             {
8927                DU_LOG("\nERROR --> F1AP : Failed to extract multiCsiCfg in  extractPucchCfg()");
8928                return RFAILED;
8929             }
8930             memset(macPucchCfg->multiCsiCfg, 0, sizeof(PucchMultiCsiCfg));
8931             macPucchCfg->multiCsiCfg->multiCsiResrcListCount = cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.count;
8932             for(arrIdx =0; arrIdx < macPucchCfg->multiCsiCfg->multiCsiResrcListCount; arrIdx++)
8933             {
8934                macPucchCfg->multiCsiCfg->multiCsiResrcList[arrIdx] =\
8935                  *cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.array[arrIdx];
8936             }
8937          }
8938
8939          /* Dl_DataToUL_ACK */
8940          if(cuPucchCfg->choice.setup->dl_DataToUL_ACK)
8941          {
8942             DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
8943             if(macPucchCfg->dlDataToUlAck == NULLP)
8944             {
8945                DU_LOG("\nERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
8946                return RFAILED;
8947             }
8948             memset(macPucchCfg->dlDataToUlAck, 0, sizeof(PucchDlDataToUlAck));
8949             macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount = cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.count;
8950             for(arrIdx = 0; arrIdx < macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount; arrIdx++)
8951             {
8952                macPucchCfg->dlDataToUlAck->dlDataToUlAckList[arrIdx] =\
8953                   *cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.array[arrIdx];
8954             }
8955          }
8956
8957          /* Power Control */
8958          if(cuPucchCfg->choice.setup->pucch_PowerControl)
8959          {
8960             DU_ALLOC_SHRABL_BUF(macPucchCfg->powerControl, sizeof(PucchPowerControl));
8961             if(macPucchCfg->powerControl == NULLP)
8962             {
8963                DU_LOG("\nERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
8964                return RFAILED;
8965             }
8966             extractPucchPowerControl(macPucchCfg->powerControl,\
8967                cuPucchCfg->choice.setup->pucch_PowerControl);
8968          }
8969       }
8970    }
8971    return ROK;
8972 }
8973
8974 /*******************************************************************
8975  *
8976  * @brief Fills ServingCellReconfig received by CU
8977  *
8978  * @details
8979  *
8980  *    Function : extractSpCellDedicatedCfg
8981  *
8982  *    Functionality: Fills ServingCellReconfig received  by CU
8983  *
8984  * @params[in] ServingCellConfig_t *cuSrvCellCfg
8985  *             ServCellCfgInfo *macSrvCellCfg
8986  * @return ROK/RFAILD
8987  *
8988  * ****************************************************************/
8989 uint8_t extractSpCellDedicatedCfg(ServingCellConfig_t *cuSrvCellCfg, ServCellCfgInfo *macSrvCellCfg)
8990 {
8991    uint8_t ret = ROK;
8992    BWP_DownlinkDedicated_t *dlBwp = NULLP;
8993    BWP_UplinkDedicated_t   *ulBwp = NULLP;
8994
8995    if(cuSrvCellCfg->initialDownlinkBWP)
8996    {
8997       dlBwp = ((BWP_DownlinkDedicated_t *)(cuSrvCellCfg->initialDownlinkBWP));
8998       if(dlBwp->pdcch_Config)
8999       {
9000          if(dlBwp->pdcch_Config->choice.setup)
9001          {
9002             macSrvCellCfg->initDlBwp.pdcchPresent = true;
9003             extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
9004          }
9005       }
9006       if(dlBwp->pdsch_Config)
9007       {
9008          if(dlBwp->pdsch_Config->choice.setup)
9009          {
9010             macSrvCellCfg->initDlBwp.pdschPresent = true;
9011             extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg);
9012          }
9013       }
9014    }
9015    if(cuSrvCellCfg->firstActiveDownlinkBWP_Id)
9016       macSrvCellCfg->firstActvDlBwpId = *(cuSrvCellCfg->firstActiveDownlinkBWP_Id);
9017    if(cuSrvCellCfg->defaultDownlinkBWP_Id)
9018       macSrvCellCfg->defaultDlBwpId = *(cuSrvCellCfg->defaultDownlinkBWP_Id);
9019    if(cuSrvCellCfg->bwp_InactivityTimer)
9020    {
9021       if(macSrvCellCfg->bwpInactivityTmr)
9022       {
9023          memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
9024       }
9025       else
9026       {
9027          macSrvCellCfg->bwpInactivityTmr = NULLP;
9028          DU_ALLOC_SHRABL_BUF(macSrvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
9029          if(macSrvCellCfg->bwpInactivityTmr)
9030          {
9031             memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
9032          }
9033          else
9034          {
9035             DU_LOG("\nERROR  --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
9036             return RFAILED;
9037          }
9038       }
9039    }
9040    if(cuSrvCellCfg->pdsch_ServingCellConfig)
9041    {
9042       if(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup)
9043       {
9044          ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
9045          if(ret == RFAILED)
9046          {
9047             DU_LOG("\nERROR --> F1AP : Failed at extractPdschServingCellCfg()");
9048             return RFAILED;
9049          }
9050       }
9051    }
9052    if(cuSrvCellCfg->uplinkConfig)
9053    {
9054      if(cuSrvCellCfg->uplinkConfig->initialUplinkBWP)
9055      {
9056         ulBwp = ((BWP_UplinkDedicated_t *)(cuSrvCellCfg->uplinkConfig->initialUplinkBWP));
9057         if(ulBwp->pusch_Config)
9058         {
9059            macSrvCellCfg->initUlBwp.puschPresent = true;
9060            extractPuschCfg(ulBwp->pusch_Config, &macSrvCellCfg->initUlBwp.puschCfg);
9061         }
9062         if(ulBwp->pucch_Config)
9063         {
9064            macSrvCellCfg->initUlBwp.pucchPresent = true;
9065            memset(&macSrvCellCfg->initUlBwp.pucchCfg, 0, sizeof(PucchCfg));
9066            extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg);
9067         }
9068      }
9069      if(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id)
9070         macSrvCellCfg->firstActvUlBwpId = *(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id);
9071    }
9072    return ret;
9073 }
9074 /*******************************************************************
9075  *
9076  * @brief Fills Reconfig Cell group Info received by CU
9077  *
9078  * @details
9079  *
9080  *    Function : extractUeReCfgCellInfo
9081  *
9082  *    Functionality: Fills Reconfig Cell group Info received by CU
9083  *
9084  * @params[in] CellGroupConfigRrc_t *macCellGrpCfg
9085  *             MacUeCfg*  macUeCfg
9086  * @return ROK/RFAILED
9087  *
9088  * ****************************************************************/
9089 uint8_t extractUeReCfgCellInfo(CellGroupConfigRrc_t *cellGrp, MacUeCfg *macUeCfg)
9090 {
9091    uint8_t ret = ROK;
9092    MAC_CellGroupConfig_t     *macCellGroup = NULLP;
9093    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
9094    SpCellConfig_t            *spcellCfg = NULLP;
9095    ServingCellConfig_t       *servCellCfg = NULLP;
9096
9097    if(cellGrp)
9098    {
9099       /* Fill MacCell Group Reconfig  */
9100       if(cellGrp->mac_CellGroupConfig)
9101       {
9102          macUeCfg->macCellGrpCfgPres = true;
9103          macCellGroup = ((MAC_CellGroupConfig_t *)(cellGrp->mac_CellGroupConfig));
9104          if(macCellGroup->schedulingRequestConfig)
9105          {
9106             extractSchReqReConfig(macCellGroup->schedulingRequestConfig, &macUeCfg->macCellGrpCfg.schReqCfg);
9107          }
9108          if(macCellGroup->tag_Config)
9109          {
9110             extractTagReconfig(macCellGroup->tag_Config, &macUeCfg->macCellGrpCfg.tagCfg);
9111          }
9112          if(macCellGroup->bsr_Config)
9113          {
9114             macUeCfg->macCellGrpCfg.bsrTmrCfg.periodicTimer = macCellGroup->bsr_Config->periodicBSR_Timer;
9115             macUeCfg->macCellGrpCfg.bsrTmrCfg.retxTimer     = macCellGroup->bsr_Config->retxBSR_Timer;
9116             if(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer)
9117             {
9118                macUeCfg->macCellGrpCfg.bsrTmrCfg.srDelayTimer  =\
9119                *(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer);
9120             }
9121          }
9122          if(macCellGroup->phr_Config)
9123          {
9124             if(macCellGroup->phr_Config->present == MAC_CellGroupConfig__phr_Config_PR_setup)
9125             {
9126                macUeCfg->macCellGrpCfg.phrCfgSetupPres = true;
9127                if(macCellGroup->phr_Config->choice.setup)
9128                {
9129                   macUeCfg->macCellGrpCfg.phrCfg.periodicTimer     = \
9130                   macCellGroup->phr_Config->choice.setup->phr_PeriodicTimer;
9131                   macUeCfg->macCellGrpCfg.phrCfg.prohibitTimer     = \
9132                   macCellGroup->phr_Config->choice.setup->phr_ProhibitTimer;
9133                   macUeCfg->macCellGrpCfg.phrCfg.txPowerFactor     = \
9134                   macCellGroup->phr_Config->choice.setup->phr_Tx_PowerFactorChange;
9135                   macUeCfg->macCellGrpCfg.phrCfg.multiplePHR       = \
9136                   macCellGroup->phr_Config->choice.setup->multiplePHR;
9137                   macUeCfg->macCellGrpCfg.phrCfg.dummy             = \
9138                   macCellGroup->phr_Config->choice.setup->dummy;
9139                   macUeCfg->macCellGrpCfg.phrCfg.phrType2OtherCell = \
9140                   macCellGroup->phr_Config->choice.setup->phr_Type2OtherCell;
9141                   macUeCfg->macCellGrpCfg.phrCfg.phrOtherCG        = \
9142                   macCellGroup->phr_Config->choice.setup->phr_ModeOtherCG;
9143                }
9144             }
9145          }
9146       }
9147       /* Fill Physical Cell Group Reconfig */
9148       if(cellGrp->physicalCellGroupConfig)
9149       {
9150          macUeCfg->phyCellGrpCfgPres = true;
9151          phyCellGrpCfg = ((PhysicalCellGroupConfig_t *)(cellGrp->physicalCellGroupConfig));
9152          if(phyCellGrpCfg->p_NR_FR1)
9153          {
9154             if(*(phyCellGrpCfg->p_NR_FR1) != macUeCfg->phyCellGrpCfg.pNrFr1)
9155                macUeCfg->phyCellGrpCfg.pNrFr1 = *(phyCellGrpCfg->p_NR_FR1);
9156          }
9157          macUeCfg->phyCellGrpCfg.pdschHarqAckCodebook = phyCellGrpCfg->pdsch_HARQ_ACK_Codebook;
9158       }
9159       /* Fill SpCell Reconfig */
9160       if(cellGrp->spCellConfig)
9161       {
9162          macUeCfg->spCellCfgPres = true;
9163          spcellCfg = ((SpCellConfig_t *)(cellGrp->spCellConfig));
9164          if(spcellCfg->servCellIndex)
9165          {
9166             macUeCfg->spCellCfg.servCellIdx = *(spcellCfg->servCellIndex);
9167          }
9168          /* Fill Serving cell Reconfig info */
9169          if(cellGrp->spCellConfig->spCellConfigDedicated)
9170          {
9171             servCellCfg = ((ServingCellConfig_t *)(cellGrp->spCellConfig->spCellConfigDedicated));
9172             ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg);
9173             if(ret == RFAILED)
9174             {
9175                DU_LOG("\nERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
9176             }
9177          }
9178       }
9179    }
9180    return ret;
9181 }
9182 /*******************************************************************
9183 *
9184 * @brief free the memory allocated by decoder
9185 *
9186 * @details
9187 *
9188 *    Function : freeAperDecodeNrcgi
9189 *
9190 *    Functionality: Free Nrcgi values
9191 *
9192 * @params[in] NRCGI_t *nrcgi
9193 * @return void
9194 *
9195 * ****************************************************************/
9196
9197
9198 void freeAperDecodeNrcgi(NRCGI_t *nrcgi)
9199 {
9200     if(nrcgi->pLMN_Identity.buf != NULLP)
9201     {
9202        free(nrcgi->pLMN_Identity.buf);
9203     }
9204     if(nrcgi->nRCellIdentity.buf != NULLP)
9205     {
9206        free(nrcgi->nRCellIdentity.buf);
9207     }
9208 }
9209 /*******************************************************************
9210 *
9211 * @brief free the memory allocated by decoder
9212 *
9213 * @details
9214 *
9215 *    Function : freeAperDecodeCuToDuInfo
9216 *
9217 *    Functionality:  Free Cu To Du Information
9218 *
9219 * @params[in] CUtoDURRCInformation_t *rrcMsg
9220 * @return void
9221 *
9222 * ****************************************************************/
9223
9224
9225 void freeAperDecodeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
9226 {
9227    uint8_t ieIdx =0;
9228    uint8_t arrIdx =0;
9229
9230    if(rrcMsg->uE_CapabilityRAT_ContainerList)
9231    {
9232       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
9233          free(rrcMsg->uE_CapabilityRAT_ContainerList->buf);
9234       free(rrcMsg->uE_CapabilityRAT_ContainerList);
9235    }
9236
9237    if(rrcMsg->iE_Extensions)
9238    {
9239       if(rrcMsg->iE_Extensions->list.array)
9240       {
9241          for(ieIdx= 0; ieIdx < rrcMsg->iE_Extensions->list.count; ieIdx++)
9242          {
9243             if(rrcMsg->iE_Extensions->list.array[ieIdx])
9244             {
9245                switch(rrcMsg->iE_Extensions->list.array[ieIdx]->id)
9246                {
9247                   case ProtocolIE_ID_id_CellGroupConfig:
9248                      if(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
9249                      {
9250                         free(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf);
9251                      }
9252                      break;
9253                   default:
9254                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
9255                            rrcMsg->iE_Extensions->list.array[ieIdx]->id);
9256                      break;
9257                }
9258             }
9259          }
9260          for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
9261          {
9262             free(rrcMsg->iE_Extensions->list.array[arrIdx]);
9263          }
9264          free(rrcMsg->iE_Extensions->list.array);
9265
9266       }
9267
9268       free(rrcMsg->iE_Extensions);
9269    }
9270 }
9271 /*******************************************************************
9272 *
9273 * @brief free the memory allocated by decoder
9274 *
9275 * @details
9276 *
9277 *    Function : freeAperDecodeSplCellList
9278 *
9279 *    Functionality: Free Spl Cell List
9280                     where memory allocated by aper_decoder
9281 *
9282 * @params[in]  SCell_ToBeSetup_List_t *spCellLst
9283 * @return void
9284 *
9285 * ****************************************************************/
9286
9287
9288 void freeAperDecodeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
9289 {
9290     uint8_t  cellIdx =0;
9291
9292     if(spCellLst->list.array != NULLP)
9293     {
9294        for(cellIdx=0; cellIdx<spCellLst->list.count; cellIdx++)
9295        {
9296           if(cellIdx==0&&spCellLst->list.array[cellIdx]!=NULLP)
9297           {
9298              freeAperDecodeNrcgi(&spCellLst->list.array[cellIdx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
9299           }
9300           if(spCellLst->list.array[cellIdx]!=NULLP)
9301           {
9302              free(spCellLst->list.array[cellIdx]);
9303           }
9304        }
9305        free(spCellLst->list.array);
9306     }
9307 }
9308 /*******************************************************************
9309 *
9310 * @brief free the memory allocated by decoder
9311 *
9312 * @details
9313 *
9314 *    Function : freeAperDecodeSRBSetup
9315 *
9316 *    Functionality: added free part for the memory allocated by aper_decoder
9317 *
9318 * @params[in] SRBs_ToBeSetup_List_t *srbSet
9319 * @return void
9320 *
9321 ****************************************************************/
9322
9323
9324 void freeAperDecodeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
9325 {
9326     uint8_t srbIdx =0;
9327     if(srbSet->list.array != NULLP)
9328     {
9329        for(srbIdx=0; srbIdx<srbSet->list.count; srbIdx++)
9330        {
9331           if(srbSet->list.array[srbIdx]!=NULLP)
9332           {
9333              free(srbSet->list.array[srbIdx]);
9334           }
9335        }
9336        free(srbSet->list.array);
9337     }
9338 }
9339
9340 /*******************************************************************
9341 *
9342 * @brief free the memory allocated by decoder
9343 *
9344 * @details
9345 *
9346 *    Function : freeAperDecodeULTnlInfo
9347 *
9348 *    Functionality: added free part for the memory allocated by aper_decoder
9349 *
9350 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
9351 * @return void
9352 *
9353 * ****************************************************************/
9354
9355
9356 void freeAperDecodeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
9357 {
9358    uint8_t ulIdx=0;
9359    if(ulInfo->list.array != NULLP)
9360    {
9361       for(ulIdx=0; ulIdx<ulInfo->list.count; ulIdx++)
9362       {
9363          if(ulIdx==0&&ulInfo->list.array[ulIdx]!=NULLP)
9364          {
9365             if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
9366             {
9367                if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9368                      transportLayerAddress.buf != NULLP)
9369                {
9370                   if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
9371                         !=NULLP)
9372                   {
9373                      free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf);
9374                   }
9375                   free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9376                         transportLayerAddress.buf);
9377                }
9378                free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel);
9379             }
9380          }
9381          if(ulInfo->list.array[ulIdx]!=NULLP)
9382          {
9383             free(ulInfo->list.array[ulIdx]);
9384          }
9385       }
9386       free(ulInfo->list.array);
9387    }
9388 }
9389 /*******************************************************************
9390 *
9391 * @brief free the memory allocated by decoder
9392 *
9393 * @details
9394 *
9395 *    Function : freeAperDecodeDRBSetup
9396 *
9397 *    Functionality: free DRBSetup which is allocated by decoder
9398 *
9399 * @params[in]  DRBs_ToBeSetup_List_t *drbSet
9400 * @return void
9401 *
9402 * ****************************************************************/
9403
9404 void freeAperDecodeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
9405 {
9406    DRBs_ToBeSetup_Item_t *drbSetItem = NULLP;
9407    uint8_t  flowIdx =0;
9408    uint8_t  drbIdx =0;
9409
9410    if(drbSet->list.array != NULLP)
9411    {
9412       for(drbIdx=0; drbIdx<drbSet->list.count; drbIdx++)
9413       {
9414          if(drbIdx==0&&drbSet->list.array[drbIdx] != NULLP)
9415          {
9416             drbSetItem =&drbSet->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
9417             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
9418             {
9419                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9420                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
9421                {
9422                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9423                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9424                   {
9425                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9426                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9427                      {
9428
9429                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
9430                         {
9431
9432                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
9433                            {
9434
9435                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->\
9436                                     buf!=NULLP)
9437                               {
9438
9439                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
9440                                        flows_Mapped_To_DRB_List.list.array != NULLP)
9441                                  {
9442
9443                                     for(flowIdx=0;flowIdx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9444                                           DRB_Information.flows_Mapped_To_DRB_List.list.count; flowIdx++)
9445                                     {
9446
9447                                        if(flowIdx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9448                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9449                                        {
9450                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9451                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9452                                                 qoSFlowLevelQoSParameters.\
9453                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
9454                                           {
9455                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9456                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9457                                                    qoSFlowLevelQoSParameters.\
9458                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9459                                              {
9460
9461                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9462                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9463                                                       qoSFlowLevelQoSParameters.\
9464                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9465                                                 {
9466
9467
9468                                                    free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9469                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9470                                                          qoSFlowLevelQoSParameters.\
9471                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9472                                                 }
9473
9474                                                 free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9475                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9476                                                       qoSFlowLevelQoSParameters.\
9477                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9478                                              }
9479
9480                                              free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9481
9482                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9483                                                    qoSFlowLevelQoSParameters.\
9484                                                    qoS_Characteristics.choice.non_Dynamic_5QI);
9485                                           }
9486                                        }
9487                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9488                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9489                                        {
9490
9491                                           free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9492                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]);
9493                                        }
9494                                     }
9495
9496                                     free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9497                                           DRB_Information.flows_Mapped_To_DRB_List.list.array);
9498                                  }
9499
9500                                  free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9501                                        DRB_Information.sNSSAI.sD->buf);
9502                               }
9503
9504                               free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD);
9505                            }
9506
9507                            free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf);
9508
9509                         }
9510
9511                         free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9512
9513                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9514                      }
9515
9516                      free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9517                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9518                   }
9519
9520                   free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9521                         qoS_Characteristics.choice.non_Dynamic_5QI);
9522                }
9523                free(drbSetItem->qoSInformation.choice.choice_extension);
9524             }
9525             freeAperDecodeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
9526             if(drbSetItem->uLConfiguration)
9527             {
9528                free(drbSetItem->uLConfiguration);
9529             }
9530          }
9531          if(drbSet->list.array[drbIdx]!=NULLP)
9532          {
9533             free(drbSet->list.array[drbIdx]);
9534          }
9535       }
9536       free(drbSet->list.array);
9537    }
9538 }
9539
9540
9541 /*******************************************************************
9542  *
9543  * @brief builds Mac Cell Cfg
9544  *
9545  * @details
9546  *
9547  *    Function : procUeReCfgCellInfo
9548  *
9549  *    Functionality: builds Mac Cell Cfg
9550  *
9551  * @params[in] MacUeCfg pointer
9552  *             void pointer
9553  *
9554  * @return void
9555  *
9556  * ****************************************************************/
9557 uint8_t procUeReCfgCellInfo(MacUeCfg *macUeCfgToSend, void *cellInfo)
9558 {
9559    uint8_t ret = ROK;
9560    CellGroupConfigRrc_t *cellGrp = NULLP;
9561
9562    if(cellInfo)
9563    {
9564       cellGrp = (CellGroupConfigRrc_t *)cellInfo;
9565       ret = extractUeReCfgCellInfo(cellGrp, macUeCfgToSend);
9566       if(ret == RFAILED)
9567          DU_LOG("\nERROR  -->  F1AP : Failed at procUeReCfgCellInfo()");
9568    }
9569    if(ret == RFAILED)
9570    {
9571       freeUeReCfgCellGrpInfo(macUeCfgToSend);
9572    }
9573    return ret;
9574 }
9575
9576 /*******************************************************************
9577  *
9578  * @brief Filling modulation info in mac ue cfg
9579  *
9580  * @details
9581  *
9582  *    Function : duFillModulationDetails
9583  *
9584  *    Functionality: Filling modulation info in mac ue cfg
9585  *
9586  * @params[in] MAC UE Config to be updated
9587  *             Current UE configuration
9588  *             UE NR capability from CU
9589  * @return ROK     - success
9590  *         RFAILED - failure
9591  *
9592  * ****************************************************************/
9593 void duFillModulationDetails(MacUeCfg *ueCfg, MacUeCfg *oldUeCfg, void *ueCap)
9594 {
9595    UE_NR_Capability_t *ueNrCap=NULLP;
9596
9597    if(!ueCap)
9598    {
9599       memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9600       memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9601    }
9602    else
9603    {
9604       ueNrCap = (UE_NR_Capability_t *)ueCap;
9605
9606       /* Filling DL modulation info */
9607       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsDownlinkPerCC && \
9608          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0] && \
9609          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL)
9610       {
9611          switch(*(ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL))
9612          {
9613             case ModulationOrder_qpsk:
9614                {
9615                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
9616                   break;
9617                }
9618             case ModulationOrder_qam16:
9619                {
9620                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM16;
9621                   break;
9622                }
9623             case ModulationOrder_qam64:
9624                {
9625                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM64;
9626                   ueCfg->dlModInfo.mcsIndex = PDSCH_MCS_INDEX;
9627                   ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64;
9628                   break;
9629                }
9630             case ModulationOrder_qam256:
9631                {
9632                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM256;
9633                   break;
9634                }
9635             default:
9636                {
9637                   DU_LOG("\nERROR  -->  DU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
9638                   memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9639                   break;
9640                }
9641          }
9642       }
9643       else
9644       {
9645          memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9646       }
9647
9648       /* Filling UL modulation info */
9649       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsUplinkPerCC && \
9650          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0] && \
9651          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL)
9652       {
9653          switch(*(ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL))
9654          {
9655             case ModulationOrder_qpsk:
9656                {
9657                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
9658                   break;
9659                }
9660             case ModulationOrder_qam16:
9661                {
9662                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM16;
9663                   ueCfg->ulModInfo.mcsIndex = PUSCH_MCS_INDEX;
9664                   ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64;
9665                   break;
9666                }
9667             case ModulationOrder_qam64:
9668                {
9669                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM64;
9670                   break;
9671                }
9672             case ModulationOrder_qam256:
9673                {
9674                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM256;
9675                   break;
9676                }
9677             default:
9678                {
9679                   DU_LOG("\nERROR  -->  DU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
9680                   memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9681                   break;
9682                }
9683          }
9684       }
9685       else
9686       {
9687          memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9688       }
9689    }
9690 }
9691
9692 /*******************************************************************
9693  *
9694  * @brief Function to extract cellGrp Info present in cutoDu cont
9695  *
9696  * @details
9697  *
9698  *    Function : extractCellGrpInfo
9699  *
9700  *    Functionality: Function to extract cellGrp Info present
9701  *                   in cutoDu cont
9702  *
9703  * @params[in] ProtocolExtensionContainer_4624P16_t pointer
9704  *
9705  * @return CellGroupConfigRrc_t *
9706  *
9707  * ****************************************************************/
9708
9709 CellGroupConfigRrc_t *extractCellGrpInfo(ProtocolExtensionContainer_4624P16_t *protocolIeExtn,\
9710       DuUeCfg *ueCfgDb)
9711 {
9712    uint8_t idx2 =0;
9713    uint16_t id =0;
9714    uint16_t recvBufLen =0;
9715    CellGroupConfigRrc_t *cellGrpCfg = NULLP;
9716    CUtoDURRCInformation_ExtIEs_t *extIeInfo = NULLP;
9717    asn_dec_rval_t rval; /* Decoder return value */
9718    memset(&rval, 0, sizeof(asn_dec_rval_t));
9719
9720    if(protocolIeExtn)
9721    {
9722       for(idx2 = 0; idx2 < protocolIeExtn->list.count; idx2++)
9723       {
9724          extIeInfo = ((CUtoDURRCInformation_ExtIEs_t *)(protocolIeExtn->list.array[idx2]));
9725          id = extIeInfo->id;
9726          switch(id)
9727          {
9728             case ProtocolIE_ID_id_CellGroupConfig:
9729             {
9730                recvBufLen = extIeInfo->extensionValue.choice.CellGroupConfig.size;
9731                /* decoding the CellGroup Buf received */
9732                DU_ALLOC(cellGrpCfg, sizeof(CellGroupConfigRrc_t));
9733                if(cellGrpCfg)
9734                {
9735                   memset(cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
9736                   rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfg,
9737                      extIeInfo->extensionValue.choice.CellGroupConfig.buf, recvBufLen, 0, 0);
9738                   if(rval.code == RC_FAIL || rval.code == RC_WMORE)
9739                   {
9740                      DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
9741                      return NULLP;
9742                   }
9743                   xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfg);
9744                   if(extractRlcCfgToAddMod(cellGrpCfg->rlc_BearerToAddModList, ueCfgDb))
9745                      return NULLP;
9746                }
9747                break;
9748             }
9749             default:
9750                DU_LOG("\nERROR  -->  F1AP : Invalid IE received CUtoDURRCInformation:%d at decodeCellGrpCfg()", id);
9751                break;
9752          }
9753       }
9754    }
9755    return cellGrpCfg;
9756 }
9757
9758 /*******************************************************************
9759  *
9760  * @brief Fills Srb List received by CU
9761  *
9762  * @details
9763  *
9764  *    Function : procSrbListToSetup
9765  *
9766  *    Functionality: Fills Srb List received  by CU
9767  *
9768  * @params[in] SRBs_ToBeSetup_Item_t *cuSrbItem
9769  *             LcCfg pointer
9770  *             RlcBearerCfg pointer
9771  * @return void
9772  *
9773  * ****************************************************************/
9774 uint8_t procSrbListToSetup(SRBs_ToBeSetup_Item_t * srbItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd)
9775 {
9776    uint8_t ret = ROK;
9777
9778    /* Filling RLC INFO */
9779    procRlcLcCfg(srbItem->sRBID, srbItem->sRBID, RB_TYPE_SRB, RLC_AM, CONFIG_ADD, NULL, rlcLcToAdd);
9780
9781    /* Filling MAC INFO */
9782    ret = procMacLcCfg(srbItem->sRBID, RB_TYPE_SRB, CONFIG_ADD, NULL,NULL, NULL, macLcToAdd, NULL);
9783    if(ret == RFAILED)
9784    {
9785       DU_LOG("\nERROR  -->  F1AP : Failed at MAC LC Cfg in procSrbListToSetup()");
9786       return ret;
9787    }
9788    return ret;
9789 }
9790
9791
9792
9793 /*******************************************************************
9794  *
9795  * @brief extract Srb List received by CU
9796  *
9797  * @details
9798  *
9799  *    Function : extractSrbListToSetup
9800  *
9801  *    Functionality: extract Srb List received by CU
9802  *                   for both MAC and RLC
9803  *
9804  * @params[in] SRBs_ToBeSetup_Item_t pointer
9805  *             DuUeCfg pointer
9806  * @return ROK/RFAIED
9807  *
9808  * ****************************************************************/
9809
9810 uint8_t extractSrbListToSetup(SRBs_ToBeSetup_List_t *srbCfg, DuUeCfg *ueCfgDb)
9811 {
9812    uint8_t ret, srbIdx;
9813    SRBs_ToBeSetup_Item_t *srbItem = NULLP;
9814
9815    if(srbCfg)
9816    {
9817       for(srbIdx = 0; srbIdx < srbCfg->list.count; srbIdx++)
9818       {
9819          srbItem = &srbCfg->list.array[srbIdx]->value.choice.SRBs_ToBeSetup_Item;
9820          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
9821          {
9822             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in MAC");
9823             ret = RFAILED;
9824             break;
9825          }
9826          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
9827          {
9828             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in RLC");
9829             ret = RFAILED;
9830             break;
9831          }
9832          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
9833          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
9834          ret = procSrbListToSetup(srbItem, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
9835             &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs]);
9836          ueCfgDb->numRlcLcs++;
9837          ueCfgDb->numMacLcs++;
9838          if(ret == RFAILED)
9839          {
9840             DU_LOG("\nERROR  -->  F1AP:  Failed at extractSrbListToSetup()");
9841             break;
9842          }
9843       }
9844    }
9845    else
9846       ret = RFAILED;
9847
9848    return ret;
9849 }
9850
9851 /*******************************************************************
9852  *
9853  * @brief Fills Drb List received by CU
9854  *
9855  * @details
9856  *
9857  *    Function : procDrbListToSetup
9858  *
9859  *    Functionality: Fills Drb List received by CU
9860  *                   for both MAC and RLC
9861  *
9862  * @params[in] SRBs_ToBeSetup_Item_t pointer
9863  *             LcCfg pointer,
9864  *             RlcBearerCfg pointer
9865  * @return void
9866  *
9867  * ****************************************************************/
9868
9869 uint8_t procDrbListToSetup(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbItem,\
9870 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd, UpTnlCfg *upTnlInfo)
9871 {
9872
9873    if(drbItem != NULLP)
9874    {
9875       /* Filling RLC INFO */
9876       procRlcLcCfg(drbItem->dRBID, lcId, RB_TYPE_DRB, drbItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd);
9877
9878       /* Filling MAC INFO */
9879       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, drbItem, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
9880       {
9881          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetup()");
9882          return RFAILED;
9883       }
9884    }
9885    else if(drbSetupModItem != NULLP)
9886    {
9887       procRlcLcCfg(drbSetupModItem->dRBID, lcId, RB_TYPE_DRB, drbSetupModItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd);
9888
9889       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, NULL, drbSetupModItem, NULL, macLcToAdd, upTnlInfo) != ROK)
9890       {
9891          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetup()");
9892          return RFAILED;
9893       }
9894    }
9895    return ROK;
9896 }
9897
9898 /*******************************************************************
9899  *
9900  * @brief extract Drb List received by CU
9901  *
9902  * @details
9903  *
9904  *    Function : extractDrbListToSetup
9905  *
9906  *    Functionality: extract Drb List received by CU
9907  *                   for both MAC and RLC
9908  *
9909  * @params[in] DRBs_ToBeSetup_Item_t pointer
9910  *             DuUeCfg pointer
9911  * @return ROK/RFAIED
9912  *
9913  * ****************************************************************/
9914
9915 uint8_t extractDrbListToSetup(uint8_t lcId, DRBs_ToBeSetup_List_t *drbCfg,DRBs_ToBeSetupMod_List_t *drbSetupModCfg,\
9916 uint8_t drbCount, DuUeCfg *ueCfgDb)
9917 {
9918    uint8_t ret, drbIdx;
9919    DRBs_ToBeSetup_Item_t *drbItem = NULLP;
9920    DRBs_ToBeSetupMod_ItemIEs_t *drbSetupModItem = NULLP;
9921
9922    ret = ROK;
9923    if(drbCount > 0)
9924    {
9925       for(drbIdx = 0; drbIdx < drbCount; drbIdx++)
9926       {
9927          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
9928          {
9929             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in MAC at extractDrbListToSetup()");
9930             ret = RFAILED;
9931             break;
9932          }
9933          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
9934          {
9935             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in RLC at extractDrbListToSetup()");
9936             ret = RFAILED;
9937             break;
9938          }
9939          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
9940          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
9941
9942          if(drbCfg != NULL)
9943          {
9944             drbItem = &drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
9945             ret = procDrbListToSetup(lcId, drbItem, NULL, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
9946                &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], &ueCfgDb->upTnlInfo[ueCfgDb->numDrb]);
9947             if(ret == RFAILED)
9948             {
9949                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetup()");
9950                break;
9951             }
9952          }
9953          else if(drbSetupModCfg != NULL)
9954          {
9955             drbSetupModItem = (DRBs_ToBeSetupMod_ItemIEs_t *) drbSetupModCfg->list.array[drbIdx];
9956             ret = procDrbListToSetup(lcId, NULL, &(drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item) ,\
9957             &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs],\
9958             &ueCfgDb->upTnlInfo[ueCfgDb->numDrb]);
9959             if(ret == RFAILED)
9960             {
9961                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetup()");
9962                break;
9963             }
9964          }
9965          ueCfgDb->numRlcLcs++;
9966          ueCfgDb->numMacLcs++;
9967          ueCfgDb->numDrb++;
9968          if(ret == RFAILED)
9969          {
9970             DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetup()");
9971             break;
9972          }
9973       }
9974    }
9975    else
9976       ret = RFAILED;
9977
9978    return ret;
9979 }
9980
9981 /*******************************************************************
9982  *
9983  * @brief Function to extract Dl RRC Msg received from CU
9984  *
9985  * @details
9986  *
9987  *    Function : extractDlRrcMsg
9988  *
9989  *    Functionality: Function to extract Dl RRC Msg received from CU
9990  *
9991  * @params[in] F1AP message
9992  * @return ROK     - success
9993  *         RFAILED - failure
9994  *
9995  * ****************************************************************/
9996
9997 uint8_t extractDlRrcMsg(uint32_t gnbDuUeF1apId, uint32_t gnbCuUeF1apId, \
9998    F1DlRrcMsg *dlRrcMsg, RRCContainer_t *rrcContainer)
9999 {
10000    uint8_t ret = ROK;
10001    dlRrcMsg->rrcMsgSize = rrcContainer->size;
10002    if(dlRrcMsg->rrcMsgSize > 0)
10003    {
10004       DU_ALLOC_SHRABL_BUF(dlRrcMsg->rrcMsgPdu, dlRrcMsg->rrcMsgSize);
10005       if(!dlRrcMsg->rrcMsgPdu)
10006       {
10007          DU_LOG("\nERROR  --> DU APP : Memory allocation failed for RRC Msg in extractDlRrcMsg()");
10008          ret = RFAILED;
10009       }
10010       else
10011       {
10012          dlRrcMsg->gnbDuUeF1apId = gnbDuUeF1apId;
10013          dlRrcMsg->gnbCuUeF1apId = gnbCuUeF1apId;
10014          dlRrcMsg->srbId = SRB1_LCID;
10015          memcpy(dlRrcMsg->rrcMsgPdu, rrcContainer->buf, dlRrcMsg->rrcMsgSize);
10016       }
10017    }
10018    return ret;
10019 }
10020
10021 /*******************************************************************
10022  *
10023  * @brief Extract UE capability info
10024  *
10025  * @details
10026  *
10027  *    Function : extractUeCapability
10028  *
10029  *    Functionality: Extract UE capability info and stores in ue Cb
10030  *
10031  * @params[in] Octet string of UE capability RAT container list
10032  * @return ROK     - success
10033  *         RFAILED - failure
10034  *
10035  * ****************************************************************/
10036 UE_NR_Capability_t *extractUeCapability(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf, DuUeCb *ueCb)
10037 {
10038    uint8_t  idx;
10039    uint16_t recvBufLen;
10040    asn_dec_rval_t rval;
10041    UE_NR_Capability_t  *ueNrCap = NULLP;
10042    UE_CapabilityRAT_ContainerListRRC_t  *ueCapRatContList = NULLP;
10043
10044    /* Decoding UE Capability RAT Container List */
10045    recvBufLen = ueCapablityListBuf->size;
10046    DU_ALLOC(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10047    if(!ueCapRatContList)
10048    {
10049       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
10050       return NULLP;
10051    }
10052    memset(ueCapRatContList, 0, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10053    memset(&rval, 0, sizeof(asn_dec_rval_t));
10054    rval = aper_decode(0, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, (void **)&ueCapRatContList,
10055           ueCapablityListBuf->buf, recvBufLen, 0, 0);
10056    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10057    {
10058       DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
10059       return NULLP;
10060    }
10061    xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, ueCapRatContList);
10062
10063    /* Free encoded buffer after decoding */
10064
10065    for(idx = 0; idx < ueCapRatContList->list.count; idx++)
10066    {
10067       if(ueCapRatContList->list.array[idx]->rat_Type == RAT_Type_nr)
10068       {
10069          /* Decoding UE NR Capability */
10070           recvBufLen = ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.size;
10071           DU_ALLOC(ueNrCap, sizeof(UE_NR_Capability_t));
10072           if(!ueNrCap)
10073           {
10074              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
10075              DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10076              return NULLP;
10077           }
10078           memset(ueNrCap, 0, sizeof(UE_NR_Capability_t));
10079           memset(&rval, 0, sizeof(asn_dec_rval_t));
10080           rval = aper_decode(0, &asn_DEF_UE_NR_Capability, (void **)&ueNrCap,
10081                  ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf, recvBufLen, 0, 0);
10082           if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10083           {
10084              DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
10085              return NULLP;
10086           }
10087           xer_fprint(stdout, &asn_DEF_UE_NR_Capability, ueNrCap);
10088
10089           /* Free encoded buffer after decoding */
10090           free(ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf);
10091       }
10092       free(ueCapRatContList->list.array[idx]);
10093    }
10094
10095    /* Free Memory*/
10096    free(ueCapRatContList->list.array);
10097    DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10098    return ueNrCap;
10099 }
10100
10101 /*******************************************************************
10102 *
10103 * @brief free UE context setup request from CU
10104 *
10105 * @details
10106 *
10107 *    Function : freeAperDecodeF1UeContextSetupReq
10108 *
10109 *    Functionality: freeing part for the memory allocated by aper_decoder
10110 *
10111 * @params[in] F1AP message
10112 * @return ROK     - success
10113 *         RFAILED - failure
10114 *
10115 * ****************************************************************/
10116 void freeAperDecodeF1UeContextSetupReq(UEContextSetupRequest_t   *ueSetReq)
10117 {
10118    uint8_t ieIdx = 0;
10119
10120    if(ueSetReq->protocolIEs.list.array != NULLP)
10121    {
10122       for(ieIdx = 0; ieIdx < ueSetReq->protocolIEs.list.count; ieIdx++)
10123       {
10124          if(ueSetReq->protocolIEs.list.array[ieIdx])
10125          {
10126             switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
10127             {
10128                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10129                   break;
10130                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10131                   break;
10132                case ProtocolIE_ID_id_SpCell_ID:
10133                   freeAperDecodeNrcgi(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
10134                   break;
10135                case ProtocolIE_ID_id_ServCellIndex:
10136                   break;
10137                case ProtocolIE_ID_id_SpCellULConfigured:
10138                   break;
10139                case ProtocolIE_ID_id_CUtoDURRCInformation:
10140
10141                   freeAperDecodeCuToDuInfo(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation);
10142                   break;
10143                case ProtocolIE_ID_id_SCell_ToBeSetup_List:
10144
10145                   freeAperDecodeSplCellList(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SCell_ToBeSetup_List);
10146                   break;
10147                case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
10148
10149                   freeAperDecodeSRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List);
10150                   break;
10151                case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
10152
10153                   freeAperDecodeDRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List);
10154                   break;
10155                case ProtocolIE_ID_id_RRCContainer:
10156                   {
10157
10158                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf != NULLP)
10159                      {
10160
10161                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
10162                      }
10163                      break;
10164                   }
10165                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10166                   break;
10167                case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
10168                   {
10169                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf)
10170                      {
10171                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf);
10172                      }
10173                      break;
10174                   }
10175                default:
10176                   DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld " ,ueSetReq->protocolIEs.list.array[ieIdx]->id);
10177             }
10178             free(ueSetReq->protocolIEs.list.array[ieIdx]);
10179          }
10180       }
10181       free(ueSetReq->protocolIEs.list.array);
10182    }
10183 }
10184 /*******************************************************************
10185  *
10186  * @brief Process UE context setup request from CU
10187  *
10188  * @details
10189  *
10190  *    Function : procF1UeContextSetupReq
10191  *
10192  *    Functionality: Process UE context setup request from CU
10193  *
10194  * @params[in] F1AP message
10195  * @return ROK     - success
10196  *         RFAILED - failure
10197  *
10198  * ****************************************************************/
10199 uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
10200 {
10201    uint8_t  ret=0, ieIdx=0, ueIdx=0, lcId=0, cellIdx=0;
10202    bool ueCbFound = false;
10203    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0, bitRateSize=0;
10204    DuUeCb   *duUeCb = NULL;
10205    UEContextSetupRequest_t   *ueSetReq = NULL;
10206    DRBs_ToBeSetup_List_t *drbCfg = NULL;
10207
10208    ret = ROK;
10209
10210    ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
10211    for(ieIdx=0; (ieIdx < ueSetReq->protocolIEs.list.count && ret == ROK); ieIdx++)
10212    {
10213       switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
10214       {
10215          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10216             {
10217                gnbCuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
10218                break;
10219             }
10220          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10221             {
10222                gnbDuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
10223                break;
10224             }
10225          case ProtocolIE_ID_id_ServCellIndex:
10226             {
10227                cellIdx = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.ServCellIndex;
10228                for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
10229                {
10230                   if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
10231                         (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
10232                   {
10233                      ueCbFound = true;
10234                      duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
10235                      DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
10236                      if(duUeCb->f1UeDb)
10237                      {
10238                         memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
10239                         duUeCb->f1UeDb->actionType = UE_CTXT_SETUP;
10240                         duUeCb->f1UeDb->cellIdx = cellIdx;
10241                      }
10242                      else
10243                      {
10244                         DU_LOG("\nERROR  -->  F1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
10245                         ret = RFAILED;
10246                      }
10247                   }
10248                   else
10249                      ueCbFound = false;
10250
10251                }
10252                if(!ueCbFound)
10253                {
10254                   DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
10255                   ret = RFAILED;
10256                }
10257                break;
10258             }
10259          case ProtocolIE_ID_id_SpCellULConfigured:
10260             /* Indicates whether the gNB-CU requests the gNB-DU to configure the uplink as no UL,
10261                UL, SUL or UL+SUL for the indicated cell for the UE */
10262             break;
10263          case ProtocolIE_ID_id_CUtoDURRCInformation:
10264             {
10265                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.uE_CapabilityRAT_ContainerList)
10266                {
10267                   duUeCb->f1UeDb->duUeCfg.ueNrCapability = \
10268                   extractUeCapability(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.\
10269                   uE_CapabilityRAT_ContainerList, duUeCb);
10270                }
10271                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.iE_Extensions)
10272                {
10273                   duUeCb->f1UeDb->duUeCfg.cellGrpCfg = extractCellGrpInfo(ueSetReq->protocolIEs.list.array[ieIdx]->\
10274                         value.choice.CUtoDURRCInformation.iE_Extensions, &duUeCb->f1UeDb->duUeCfg);
10275                   if(!duUeCb->f1UeDb->duUeCfg.cellGrpCfg)
10276                   {
10277                      DU_LOG("\nERROR  -->  F1AP: Failed to extract cell Grp Info");
10278                      //TODO: Update the failure cause in ue context Setup Response
10279                      ret = RFAILED;
10280                   }
10281                }
10282                break;
10283             }
10284          case ProtocolIE_ID_id_SCell_ToBeSetup_List:
10285             {
10286                DU_LOG("\nINFO   -->  DU_APP: Received SCell_ToBeSetup_List but  Not processing the list");
10287                break;
10288             }
10289          case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
10290             {
10291                if(extractSrbListToSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List,\
10292                &duUeCb->f1UeDb->duUeCfg))
10293                {
10294                   DU_LOG("\nERROR  -->  DU APP : Failed at extractSrbListToSetup()");
10295                   //TODO: Update the failure cause in ue context Setup Response
10296                   ret = RFAILED;
10297                }
10298                break;
10299             }
10300          case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
10301             {
10302                lcId = getDrbLcId(&duUeCb->drbBitMap);
10303                if(lcId != RFAILED)
10304                {
10305                   drbCfg = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List;
10306                   if(extractDrbListToSetup(lcId, drbCfg, NULL, drbCfg->list.count, &duUeCb->f1UeDb->duUeCfg))
10307                   {
10308                      DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetup()");
10309                      //TODO: Update the failure cause in ue context Setup Response
10310                      ret = RFAILED;
10311                   }
10312                }
10313                else
10314                   ret = RFAILED;
10315                break;
10316             }
10317          case ProtocolIE_ID_id_RRCContainer:
10318             {
10319                /* Filling Dl RRC Msg Info */
10320                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
10321                if(!duUeCb->f1UeDb->dlRrcMsg)
10322                {
10323                   DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
10324                   ret = RFAILED;
10325                }
10326                else
10327                {
10328                   duUeCb->f1UeDb->dlRrcMsgPres = true;
10329                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
10330                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
10331                         &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer);
10332                }
10333                break;
10334             }
10335          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10336             {
10337                if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
10338                {
10339                   duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
10340                }
10341                else
10342                {
10343                   DU_LOG("\nERROR  -->  Ignoring delivery report, since rrcContainer is not present");
10344                }
10345                break;
10346             }
10347          case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
10348             {
10349                /* MaximumBitRate Uplink */
10350                bitRateSize = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.size;
10351                if(bitRateSize > 0)
10352                {
10353                   DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.ambrCfg, bitRateSize);
10354                   if(!duUeCb->f1UeDb->duUeCfg.ambrCfg)
10355                   {
10356                      DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
10357                      ret = RFAILED;
10358                   }
10359                   else
10360                   {
10361                      memset(duUeCb->f1UeDb->duUeCfg.ambrCfg, 0, sizeof(AmbrCfg));
10362                      memcpy(&duUeCb->f1UeDb->duUeCfg.ambrCfg->ulBr,
10363                            ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf, bitRateSize);
10364                   }
10365                }
10366                else
10367                   ret = RFAILED;
10368                break;
10369             }
10370          default:
10371             {
10372                break;
10373             }
10374       }
10375    }
10376    if(ret == RFAILED)
10377    {
10378       /*TODO : Negative case*/
10379       // BuildAndSendUeContextSetupRsp(cellId,ueIdx);
10380       DU_LOG("\nERROR  -->  F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
10381    }
10382    else
10383       ret = duProcUeContextSetupRequest(duUeCb);
10384
10385    freeAperDecodeF1UeContextSetupReq(ueSetReq);
10386    return ret;
10387
10388 }
10389 /*******************************************************************
10390  * @brief Free the memory allocated for Dl Tunnel Info
10391  *
10392  * @details
10393  *
10394  *    Function : freeDlTnlInfo
10395  *
10396  *    Functionality:
10397  *       Free the memory allocated for Dl Tunnel Info
10398  *
10399  * @params[in] DLUPTNLInformation_ToBeSetup_List_t *
10400  * @return void
10401  *
10402  * ****************************************************************/
10403
10404 void freeDlTnlInfo(DLUPTNLInformation_ToBeSetup_List_t *tnlInfo)
10405 {
10406    uint8_t arrIdx = 0;
10407
10408    if(tnlInfo)
10409    {
10410       for(arrIdx=0; arrIdx < tnlInfo->list.count; arrIdx++)
10411       {
10412          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf,\
10413                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
10414          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf,\
10415                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
10416          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
10417          DU_FREE(tnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
10418       }
10419       DU_FREE(tnlInfo->list.array, tnlInfo->list.size);
10420    }
10421 }
10422
10423 /*******************************************************************
10424  * @brief Free the memory allocated for DRB setup List
10425  *
10426  * @details
10427  *
10428  *    Function : freeDrbSetupList
10429  *
10430  *    Functionality:
10431  *       Free the memory allocated for DRB setup list
10432  *
10433  * @params[in] DRBs_Setup_List_t *
10434  * @return void
10435  *
10436  * ****************************************************************/
10437 void freeDrbSetupList(DRBs_Setup_List_t *drbSetupList)
10438 {
10439    uint8_t arrIdx = 0;
10440    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
10441
10442    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
10443    {
10444       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
10445       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
10446       DU_FREE(drbSetupList->list.array[arrIdx],  sizeof(DRBs_Setup_Item_t));
10447    }
10448    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
10449 }
10450
10451 /*******************************************************************
10452  * @brief Free the memory allocated for UE Setup response
10453  *
10454  * @details
10455  *
10456  *    Function : FreeUeContextSetupRsp
10457  *
10458  *    Functionality:
10459  *       Free the memory allocated for UE Setup response
10460  *
10461  * @params[in] F1AP PDU for UE setup response
10462  * @return ROK     - success
10463  *         RFAILED - failure
10464  *
10465  * ****************************************************************/
10466 void FreeUeContextSetupRsp(F1AP_PDU_t *f1apMsg)
10467 {
10468    uint8_t idx;
10469    UEContextSetupResponse_t *ueSetRsp = NULLP;
10470
10471    if(f1apMsg)
10472    {
10473       if(f1apMsg->choice.successfulOutcome)
10474       {
10475          ueSetRsp = &f1apMsg->choice.successfulOutcome->value.choice.\
10476                     UEContextSetupResponse;
10477          if(ueSetRsp->protocolIEs.list.array)
10478          {
10479             for(idx = 0; idx < ueSetRsp->protocolIEs.list.count; idx++)
10480             {
10481                if(ueSetRsp->protocolIEs.list.array[idx])
10482                {
10483                   switch(ueSetRsp->protocolIEs.list.array[idx]->id)
10484                   {
10485                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10486                         break;
10487                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10488                         break;
10489                      case ProtocolIE_ID_id_DUtoCURRCInformation:
10490                         {
10491                            CellGroupConfig_t *cellGrpCfg = NULLP;
10492                            cellGrpCfg  = &ueSetRsp->protocolIEs.list.array[idx]->value.choice.\
10493                                          DUtoCURRCInformation.cellGroupConfig;
10494                            if(cellGrpCfg->buf != NULLP)
10495                            {
10496                               DU_FREE(cellGrpCfg->buf, cellGrpCfg->size);
10497                               cellGrpCfg = NULLP;
10498                            }
10499                            break;
10500                         }
10501                     case ProtocolIE_ID_id_DRBs_Setup_List:
10502                         {
10503                            freeDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
10504                            break;
10505                         }
10506                      default:
10507                         DU_LOG("\nERROR  -->  DUAPP: Invalid Id %ld at FreeUeContextSetupRsp()",\
10508                         ueSetRsp->protocolIEs.list.array[idx]->id);
10509                         break;
10510                   }
10511                   DU_FREE(ueSetRsp->protocolIEs.list.array[idx],\
10512                         sizeof(UEContextSetupResponseIEs_t));
10513                }
10514             }
10515             DU_FREE(ueSetRsp->protocolIEs.list.array, \
10516                   ueSetRsp->protocolIEs.list.size);
10517          }
10518          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
10519       }
10520       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10521    }
10522 }
10523
10524 /*******************************************************************
10525  *
10526  * @brief Builds Ue context Setup Rsp DU To CU Info
10527  *
10528  * @details
10529  *
10530  *    Function : EncodeUeCntxtDuToCuInfo
10531  *
10532  *    Functionality: Builds Ue context Setup Rsp DU To CU Info
10533  *
10534  * @params[in] CellGroupConfig_t *, CellGroupConfigRrc_t *
10535  *
10536  * @return ROK     - success
10537  *         RFAILED - failure
10538  *
10539  ******************************************************************/
10540
10541 uint8_t EncodeUeCntxtDuToCuInfo(CellGroupConfig_t *duToCuCellGrp, CellGroupConfigRrc_t *duCellGrpCfg)
10542 {
10543    asn_enc_rval_t        encRetVal;
10544
10545    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, duCellGrpCfg);
10546    memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
10547    encBufSize = 0;
10548    encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, duCellGrpCfg, PrepFinalEncBuf, encBuf);
10549    /* Encode results */
10550    if(encRetVal.encoded == ENCODE_FAIL)
10551    {
10552       DU_LOG( "\nERROR  -->  F1AP : Could not encode UeCntxtDuToCuInfo (at %s)\n",\
10553             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10554       return RFAILED;
10555    }
10556    else
10557    {
10558       DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
10559       for(int i=0; i< encBufSize; i++)
10560       {
10561          printf("%x",encBuf[i]);
10562       }
10563    }
10564    duToCuCellGrp->size = encBufSize;
10565    DU_ALLOC(duToCuCellGrp->buf, duToCuCellGrp->size);
10566    if(!duToCuCellGrp->buf)
10567    {
10568       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in UeCntxtDuToCuInfo");
10569    }
10570    memcpy(duToCuCellGrp->buf, encBuf, duToCuCellGrp->size);
10571    return ROK;
10572 }
10573
10574 /*******************************************************************
10575  *
10576  * @brief Fills Dl Gtp tunnel Info
10577  *
10578  * @details
10579  *
10580  *    Function : fillGtpTunnelforDl
10581  *
10582  *    Functionality: Fills Dl Gtp tunnel Info
10583  *
10584  * @params[in]
10585  *
10586  * @return ROK     - success
10587  *         RFAILED - failure
10588  *
10589  * ****************************************************************/
10590
10591 uint8_t fillGtpTunnelforDl(GTPTunnel_t *gtpDl, GtpTnlCfg *gtpUeCfg)
10592 {
10593    uint8_t bufSize = 0;
10594
10595    gtpDl->transportLayerAddress.size    = 4*sizeof(uint8_t);
10596    DU_ALLOC(gtpDl->transportLayerAddress.buf, gtpDl->transportLayerAddress.size);
10597    if(gtpDl->transportLayerAddress.buf == NULLP)
10598    {
10599       return RFAILED;
10600    }
10601    memcpy(gtpDl->transportLayerAddress.buf, &gtpUeCfg->dlTnlAddress, gtpDl->transportLayerAddress.size);
10602
10603    /*GTP TEID*/
10604    gtpDl->gTP_TEID.size = 4 * sizeof(uint8_t);
10605    DU_ALLOC(gtpDl->gTP_TEID.buf, gtpDl->gTP_TEID.size);
10606    if(gtpDl->gTP_TEID.buf == NULLP)
10607    {
10608       return RFAILED;
10609    }
10610    bufSize = 3; /*forming an Octect String*/
10611    fillTeIdString(bufSize, gtpUeCfg->teId, gtpDl->gTP_TEID.buf);
10612
10613    return ROK;
10614 }
10615
10616 /*******************************************************************
10617  *
10618  * @brief Fills DL Tunnel Setup List
10619  *
10620  * @details
10621  *
10622  *    Function : fillDlTnlSetupList
10623  *
10624  *    Functionality: Fills the DL Tunnel Setup List
10625  *
10626  * @params[in]
10627  *
10628  * @return ROK     - success
10629  *         RFAILED - failure
10630  *
10631  * ****************************************************************/
10632
10633 uint8_t fillDlTnlSetupList(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo, UpTnlCfg *tnlCfg)
10634 {
10635    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
10636
10637    eleCount = 1;
10638    dlTnlInfo->list.count = eleCount;
10639    dlTnlInfo->list.size = (eleCount * sizeof(DLUPTNLInformation_ToBeSetup_Item_t *));
10640
10641    /* Initialize the DL Tnl Setup List Members */
10642    DU_ALLOC(dlTnlInfo->list.array, dlTnlInfo->list.size);
10643    if(dlTnlInfo->list.array == NULLP)
10644    {
10645       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL Tnl Setup List in fillDlTnlSetupList()");
10646       ret = RFAILED;
10647    }
10648    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
10649    {
10650       DU_ALLOC(dlTnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
10651       if(dlTnlInfo->list.array[arrIdx] == NULLP)
10652       {
10653          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDlTnlSetupList()", arrIdx);
10654          return RFAILED;
10655       }
10656       dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
10657       DU_ALLOC(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
10658       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel == NULLP)
10659       {
10660          DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL tunnel info in fillDlTnlSetupList()");
10661          return RFAILED;
10662       }
10663       ret = fillGtpTunnelforDl(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel,\
10664                tnlCfg->tnlCfg1);
10665       if(ret != ROK)
10666          break;
10667    }
10668    return ret;
10669 }
10670
10671 /*******************************************************************
10672  *
10673  * @brief Fills the Drb Setup List for Ue Context Setup Response
10674  *
10675  * @details
10676  *
10677  *    Function : fillDrbSetupList
10678  *
10679  *    Functionality: Fills the Drb Setup List for Ue Context Setup Response
10680  *
10681  * @params[in]
10682  *
10683  * @return ROK     - success
10684  *         RFAILED - failure
10685  *
10686  * ****************************************************************/
10687 uint8_t fillDrbSetupList(DRBs_Setup_List_t *drbSetupList, DuUeCfg *ueCfg)
10688 {
10689    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
10690    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
10691
10692    eleCount = ueCfg->numDrb;
10693    drbSetupList->list.count = eleCount;
10694    drbSetupList->list.size = \
10695         (eleCount * sizeof(DRBs_Setup_Item_t *));
10696
10697    /* Initialize the Drb Setup List Members */
10698    DU_ALLOC(drbSetupList->list.array, drbSetupList->list.size);
10699    if(drbSetupList->list.array == NULLP)
10700    {
10701       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DRB Setup List in fillDrbSetupList()");
10702       ret = RFAILED;
10703    }
10704
10705    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
10706    {
10707       DU_ALLOC(drbSetupList->list.array[arrIdx], sizeof(DRBs_Setup_Item_t));
10708       if(drbSetupList->list.array[arrIdx] == NULLP)
10709       {
10710          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDrbSetupList()", arrIdx);
10711          return RFAILED;
10712       }
10713       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
10714       drbItemIe->id = ProtocolIE_ID_id_DRBs_Setup_Item;
10715       drbItemIe->criticality = Criticality_reject;
10716       drbItemIe->value.present = DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item;
10717       drbItemIe->value.choice.DRBs_Setup_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
10718       ret = fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List,\
10719           &ueCfg->upTnlInfo[arrIdx]);
10720       if(ret != ROK)
10721          break;
10722    }
10723    return ret;
10724 }
10725
10726 /*******************************************************************
10727  *
10728  * @brief Builds and sends the UE Setup Response
10729  *
10730  * @details
10731  *
10732  *    Function : BuildAndSendUeContextSetupRsp
10733  *
10734  *    Functionality: Constructs the UE Setup Response and sends
10735  *                   it to the DU through SCTP.
10736  *
10737  * @params[in] uint8_t cellId,uint8_t ueIdx
10738  *
10739  * @return ROK     - success
10740  *         RFAILED - failure
10741  *
10742  * ****************************************************************/
10743 uint8_t BuildAndSendUeContextSetupRsp(uint8_t cellId,uint8_t ueIdx)
10744 {
10745    uint8_t   idx, ret, cellIdx, elementCnt;
10746    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
10747    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
10748    asn_enc_rval_t  encRetVal;        /* Encoder return value */
10749    F1AP_PDU_t               *f1apMsg = NULLP;
10750    UEContextSetupResponse_t *ueSetRsp = NULLP;
10751    CellGroupConfigRrc_t     *cellGrpCfg = NULLP;
10752    DuUeCb                   *ueCb = NULLP;
10753
10754    DU_LOG("\n INFO   -->  F1AP : Building UE Context Setup Response for cellId %d, ueIdx %d\n", cellId, ueIdx);
10755
10756    while(true)
10757    {
10758       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10759       if(f1apMsg == NULLP)
10760       {
10761          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
10762          ret = RFAILED;
10763          break;
10764       }
10765
10766       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
10767       DU_ALLOC(f1apMsg->choice.successfulOutcome,
10768             sizeof(SuccessfulOutcome_t));
10769       if(f1apMsg->choice.successfulOutcome == NULLP)
10770       {
10771          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
10772          ret = RFAILED;
10773          break;
10774       }
10775
10776       f1apMsg->choice.successfulOutcome->procedureCode = \
10777                                                          ProcedureCode_id_UEContextSetup;
10778       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
10779       f1apMsg->choice.successfulOutcome->value.present = \
10780                                                          SuccessfulOutcome__value_PR_UEContextSetupResponse;
10781
10782       ueSetRsp =
10783          &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
10784       elementCnt = 4;
10785       ueSetRsp->protocolIEs.list.count = elementCnt;
10786       ueSetRsp->protocolIEs.list.size = \
10787                                         elementCnt * sizeof(UEContextSetupResponse_t *);
10788
10789       /* Initialize the UESetup members */
10790       DU_ALLOC(ueSetRsp->protocolIEs.list.array, \
10791             ueSetRsp->protocolIEs.list.size);
10792       if(ueSetRsp->protocolIEs.list.array == NULLP)
10793       {
10794          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
10795          ret = RFAILED;
10796          break;
10797       }
10798
10799       for(idx=0; idx<elementCnt; idx++)
10800       {
10801          DU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
10802                sizeof(UEContextSetupResponseIEs_t));
10803          if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
10804          {
10805             DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
10806             ret = RFAILED;
10807             break;
10808          }
10809       }
10810       /* Fetching Ue Cb Info*/
10811       GET_CELL_IDX(cellId, cellIdx);
10812       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
10813       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
10814       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
10815
10816       idx = 0;
10817       /*GNB CU UE F1AP ID*/
10818       ueSetRsp->protocolIEs.list.array[idx]->id = \
10819                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
10820       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10821       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
10822                                                              UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
10823       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
10824
10825       /*GNB DU UE F1AP ID*/
10826       idx++;
10827       ueSetRsp->protocolIEs.list.array[idx]->id = \
10828                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
10829       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10830       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
10831                                                              UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
10832       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
10833
10834
10835       /*DUtoCURRC Information */
10836       idx++;
10837       ueSetRsp->protocolIEs.list.array[idx]->id  = \
10838                                                    ProtocolIE_ID_id_DUtoCURRCInformation;
10839       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10840       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
10841                                                             UEContextSetupResponseIEs__value_PR_DUtoCURRCInformation;
10842       if(ueCb->f1UeDb)
10843       {
10844          if(ueCb->f1UeDb->duUeCfg.cellGrpCfg)
10845          {
10846             cellGrpCfg = (CellGroupConfigRrc_t*)ueCb->f1UeDb->duUeCfg.cellGrpCfg;
10847             ret = EncodeUeCntxtDuToCuInfo(&ueSetRsp->protocolIEs.list.array[idx]->value.\
10848                      choice.DUtoCURRCInformation.cellGroupConfig, cellGrpCfg);
10849             if(ret == RFAILED)
10850             {
10851                DU_LOG("\nERROR  -->  F1AP : Failed to EncodeUeCntxtDuToCuInfo in BuildAndSendUeContextSetupRsp()");
10852                freeF1UeDb(ueCb->f1UeDb);
10853                ueCb->f1UeDb = NULLP;
10854                break;
10855             }
10856          }
10857       }
10858       else
10859       {
10860          DU_LOG("\nERROR  -->  F1AP : Failed to form DUtoCU RRCInfo at BuildAndSendUeContextSetupRsp()");
10861          ret = RFAILED;
10862          break;
10863       }
10864
10865       /* Drb Setup List */
10866       idx++;
10867       ueSetRsp->protocolIEs.list.array[idx]->id  = \
10868                                  ProtocolIE_ID_id_DRBs_Setup_List;
10869       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10870       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
10871                                  UEContextSetupResponseIEs__value_PR_DRBs_Setup_List;
10872       ret = fillDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List,\
10873                &ueCb->f1UeDb->duUeCfg);
10874       if(ret == RFAILED)
10875       {
10876          DU_LOG("\nERROR  -->  F1AP : Failed to fillDrbSetupList in BuildAndSendUeContextSetupRsp()");
10877          freeF1UeDb(ueCb->f1UeDb);
10878          ueCb->f1UeDb = NULLP;
10879          break;
10880       }
10881
10882        /* Free UeContext Db created during Ue context Req */
10883        freeF1UeDb(ueCb->f1UeDb);
10884        ueCb->f1UeDb = NULLP;
10885
10886       /* TODO: To send Drb list */
10887       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10888
10889       /* Encode the UE context setup response type as APER */
10890       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
10891       encBufSize = 0;
10892       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
10893             encBuf);
10894       /* Encode results */
10895       if(encRetVal.encoded == ENCODE_FAIL)
10896       {
10897          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Response structure (at %s)\n",\
10898                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10899          ret = RFAILED;
10900          break;
10901       }
10902       else
10903       {
10904          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Setup Response\n");
10905          for(int i=0; i< encBufSize; i++)
10906          {
10907             printf("%x",encBuf[i]);
10908          }
10909       }
10910
10911       /* Sending  msg  */
10912       if(sendF1APMsg()  != ROK)
10913       {
10914          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Response failed");
10915          ret = RFAILED;
10916          break;
10917       }
10918       break;
10919    }
10920    FreeUeContextSetupRsp(f1apMsg);
10921    return ret;
10922 }/* End of BuildAndSendUeContextSetupRsp */
10923 /*******************************************************************
10924 *
10925 * @brief  Build And Send Ue Context Rsp
10926 *
10927 * @details
10928 *
10929 *    Function : BuildAndSendUeCtxtRsp
10930 *
10931 *    Functionality : Build And Send Ue Context Rsp
10932
10933 * @params[in]
10934 * @return sucess = ROK
10935 *         failure = RFAILED
10936 *
10937 * ****************************************************************/
10938 uint8_t BuildAndSendUeCtxtRsp(uint8_t cellId, uint8_t ueIdx)
10939 {
10940    uint8_t cellIdx = 0, actionType = 0;
10941
10942    GET_CELL_IDX(cellId, cellIdx);
10943    actionType = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].f1UeDb->actionType;
10944
10945    switch(actionType)
10946    {
10947       case UE_CTXT_SETUP:
10948          {
10949             BuildAndSendUeContextSetupRsp(cellId,ueIdx);
10950             break;
10951          }
10952       case UE_CTXT_MOD:
10953          {
10954             BuildAndSendUeContextModRsp(cellId, ueIdx);
10955             break;
10956          }
10957       default:
10958          DU_LOG("ERROR  -->  F1AP: Invalid Action Type %d at BuildAndSendUeCtxtRsp()", actionType);
10959          break;
10960
10961    }
10962    return ROK;
10963 }
10964
10965 /*******************************************************************
10966  *
10967  * @brief deallocating the memory of  F1reset msg
10968  *
10969  * @details
10970  *
10971  *    Function : FreeF1ResetReq
10972  *
10973  *    Functionality :
10974  *         - freeing memory of F1reset request msg
10975  *
10976  * @params[in]
10977  * @return void
10978  *
10979  *
10980  * ****************************************************************/
10981 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
10982 {
10983    uint8_t idx =0 ;
10984    Reset_t *f1ResetMsg;
10985
10986    if(f1apMsg)
10987    {
10988       if(f1apMsg->choice.initiatingMessage)
10989       {
10990          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
10991
10992          if(f1ResetMsg->protocolIEs.list.array)
10993          {
10994             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
10995             {
10996                if(f1ResetMsg->protocolIEs.list.array[idx])
10997                {
10998                   DU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
10999                }
11000             }
11001             DU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
11002          }
11003          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11004       }
11005       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11006    }
11007 }
11008 /*******************************************************************
11009  *
11010  * @brief Build and Send F1reset request
11011  *
11012  * @details
11013  *
11014  *    Function : BuildAndSendF1ResetReq
11015  *
11016  *    Functionality:
11017  *         - Build and Send F1reset request msg
11018  *
11019  * @params[in]
11020  * @return ROK     - success
11021  *         RFAILED - failure
11022  *
11023  * ****************************************************************/
11024 uint8_t BuildAndSendF1ResetReq()
11025 {
11026    uint8_t          elementCnt=0;
11027    uint8_t          idx=0;
11028    uint8_t          ret= RFAILED;
11029    Reset_t          *f1ResetMsg = NULLP;
11030    F1AP_PDU_t       *f1apMsg = NULLP;
11031    asn_enc_rval_t   encRetVal;
11032    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset request \n");
11033    do
11034    {
11035       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11036       if(f1apMsg == NULLP)
11037       {
11038          break;
11039       }
11040       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
11041       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11042       if(f1apMsg->choice.initiatingMessage == NULLP)
11043       {
11044          break;
11045       }
11046       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
11047       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
11048       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
11049
11050       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11051
11052       elementCnt = 3;
11053       f1ResetMsg->protocolIEs.list.count = elementCnt;
11054       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
11055
11056       /* Initialize the F1Setup members */
11057       DU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
11058       if(f1ResetMsg->protocolIEs.list.array == NULLP)
11059       {
11060          break;
11061       }
11062       for(idx=0; idx<elementCnt; idx++)
11063       {
11064          DU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
11065          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
11066          {
11067             break;
11068          }
11069       }
11070
11071       /*TransactionID*/
11072       idx=0;
11073       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
11074       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11075       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
11076       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
11077
11078       /*Cause*/
11079       idx++;
11080       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
11081       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
11082       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
11083       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
11084       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
11085
11086       /*Reset Type*/
11087       idx++;
11088       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
11089       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11090       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
11091       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
11092       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
11093
11094       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11095
11096       /* Encode the F1SetupRequest type as APER */
11097       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11098       encBufSize = 0;
11099       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11100             encBuf);
11101
11102       /* Encode results */
11103       if(encRetVal.encoded == ENCODE_FAIL)
11104       {
11105          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
11106                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11107          break;
11108       }
11109       else
11110       {
11111          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1Reset\n");
11112          for(idx=0; idx< encBufSize; idx++)
11113          {
11114             printf("%x",encBuf[idx]);
11115          }
11116       }
11117
11118       if(sendF1APMsg() != ROK)
11119       {
11120          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
11121          break;
11122       }
11123
11124       ret = ROK;
11125       break;
11126    }while(true);
11127
11128    FreeF1ResetReq(f1apMsg);
11129    return ret;
11130 }
11131 /*******************************************************************
11132  *
11133  * @brief Build And Send F1ResetAck
11134  *
11135  * @details
11136  *
11137  *    Function : BuildAndSendF1ResetAck
11138  *
11139  *    Functionality:
11140  *         - Build And Send  F1ResetRSP
11141  *
11142  * @return ROK     - success
11143  *         RFAILED - failure
11144  *
11145  * ****************************************************************/
11146 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
11147 {
11148    uint8_t idx;
11149    ResetAcknowledge_t *f1ResetAck;
11150
11151    if(f1apMsg)
11152    {
11153       if(f1apMsg->choice.successfulOutcome)
11154       {
11155          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
11156
11157          if(f1ResetAck->protocolIEs.list.array)
11158          {
11159             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
11160             {
11161                if(f1ResetAck->protocolIEs.list.array[idx])
11162                {
11163                   DU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
11164                }
11165             }
11166             DU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
11167          }
11168          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11169       }
11170       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11171    }
11172 }
11173
11174 /*******************************************************************
11175  *
11176  * @brief Build And Send F1ResetAck
11177  *
11178  * @details
11179  *
11180  *    Function : BuildAndSendF1ResetAck
11181  *
11182  *    Functionality:
11183  *         - Build And Send  F1ResetRSP
11184  *
11185  *  @params[in]
11186  * @return ROK     - success
11187  *         RFAILED - failure
11188  *
11189  * ****************************************************************/
11190 uint8_t BuildAndSendF1ResetAck()
11191 {
11192    uint8_t                idx = 0;
11193    uint8_t                elementCnt = 0;
11194    uint8_t                ret = RFAILED;
11195    F1AP_PDU_t             *f1apMsg = NULL;
11196    ResetAcknowledge_t     *f1ResetAck = NULLP;
11197    asn_enc_rval_t         encRetVal;
11198    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset Acknowledgment \n");
11199
11200    do{
11201       /* Allocate the memory for F1ResetRequest_t */
11202       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11203       if(f1apMsg == NULLP)
11204       {
11205          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11206          break;
11207       }
11208
11209       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
11210
11211       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11212       if(f1apMsg->choice.successfulOutcome == NULLP)
11213       {
11214          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11215          break;
11216       }
11217       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
11218       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
11219       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
11220
11221       elementCnt = 1;
11222
11223       f1ResetAck->protocolIEs.list.count = elementCnt;
11224       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
11225
11226       DU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
11227       if(f1ResetAck->protocolIEs.list.array == NULLP)
11228       {
11229          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
11230          break;
11231       }
11232
11233       for(idx=0; idx<elementCnt; idx++)
11234       {
11235          DU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
11236          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
11237          {
11238             break;
11239          }
11240       }
11241       /*TransactionID*/
11242       idx = 0;
11243       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
11244       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11245       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
11246       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
11247
11248       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11249
11250       /* Encode the F1SetupRequest type as UPER */
11251       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11252       encBufSize = 0;
11253       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
11254
11255       /* Check encode results */
11256       if(encRetVal.encoded == ENCODE_FAIL)
11257       {
11258          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
11259                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11260          break;
11261       }
11262       else
11263       {
11264          DU_LOG("\nDUBUG   -->  F1AP : Created APER encoded buffer for F1ResetAck\n");
11265          for(int i=0; i< encBufSize; i++)
11266          {
11267             printf("%x",encBuf[i]);
11268          }
11269       }
11270       /* Sending msg */
11271       if(sendF1APMsg() != ROK)
11272       {
11273          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Acknowledgement failed");
11274          break;
11275       }
11276
11277       ret = ROK;
11278       break;
11279    }while(true);
11280
11281    FreeF1ResetAck(f1apMsg);
11282    return ret;
11283 }
11284 /******************************************************************
11285 *
11286 * @brief free F1 reset msg allocated by aper_decoder
11287 *
11288 * @details
11289 *
11290 *    Function : freeAperDecodeF1ResetMsg
11291 *
11292 *    Functionality: free F1 reset msg allocated by aper_decoder
11293 *
11294 * @params[in] Reset_t *f1ResetMsg
11295 * @return void
11296 *
11297 * ****************************************************************/
11298
11299 void freeAperDecodeF1ResetMsg(Reset_t *f1ResetMsg)
11300 {
11301    uint8_t ieIdx =0;
11302    if(f1ResetMsg->protocolIEs.list.array)
11303    {
11304       for(ieIdx=0 ;ieIdx < f1ResetMsg->protocolIEs.list.count ; ieIdx++)
11305       {
11306          if(f1ResetMsg->protocolIEs.list.array[ieIdx])
11307          {
11308             free(f1ResetMsg->protocolIEs.list.array[ieIdx]);
11309          }
11310       }
11311       free(f1ResetMsg->protocolIEs.list.array);
11312    }
11313 }
11314
11315 /******************************************************************
11316  *
11317  * @brief Processes DL RRC Message Transfer  sent by CU
11318  *
11319  * @details
11320  *
11321  *    Function : procF1ResetReq
11322  *
11323  *    Functionality: Processes DL RRC Message Transfer sent by CU
11324  *
11325  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11326  * @return ROK     - success
11327  *         RFAILED - failure
11328  *
11329  * ****************************************************************/
11330 uint8_t procF1ResetReq(F1AP_PDU_t *f1apMsg)
11331 {
11332    /* we are currently not supporting Ue release. right now we are supporting only init case of fireset */
11333    uint8_t       ieIdx = 0;
11334    uint8_t        ret = ROK;
11335    Reset_t       *f1ResetMsg = NULLP;
11336
11337    DU_LOG("\nINFO   -->  Processing F1 reset request");
11338    f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11339
11340    for(ieIdx=0; ieIdx<f1ResetMsg->protocolIEs.list.count; ieIdx++)
11341    {
11342       switch(f1ResetMsg->protocolIEs.list.array[ieIdx]->id)
11343       {
11344          case ProtocolIE_ID_id_TransactionID:
11345             break;
11346
11347          case ProtocolIE_ID_id_Cause:
11348             break;
11349
11350          case ProtocolIE_ID_id_ResetType:
11351             {
11352                break;
11353             }
11354
11355          default:
11356             break;
11357       }
11358    }
11359    ret = BuildAndSendF1ResetAck();
11360    DU_LOG("\nINFO   -->  UE release is not supported for now");
11361
11362    freeAperDecodeF1ResetMsg(f1ResetMsg);
11363
11364    return ret;
11365 }
11366
11367 /*******************************************************************
11368  *
11369  * @brief free the RRC delivery report
11370  *
11371  * @details
11372  *
11373  *    Function : freeRrcDeliveryReport
11374  *
11375  *    Functionality: free the RRC delivery report
11376  *
11377  * @params[in]
11378  * @return ROK     - success
11379  *         RFAILED - failure
11380  *
11381  * ****************************************************************/
11382 void freeRrcDeliveryReport(F1AP_PDU_t  *f1apMsg )
11383 {
11384    uint8_t idx=0;
11385    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11386
11387    if(f1apMsg)
11388    {
11389       if(f1apMsg->choice.initiatingMessage)
11390       {
11391          rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11392          if(rrcDeliveryReport->protocolIEs.list.array)
11393          {
11394             for(idx =0 ;idx <rrcDeliveryReport->protocolIEs.list.count ;
11395                   idx++)
11396             {
11397                if(rrcDeliveryReport->protocolIEs.list.array[idx])
11398                {
11399                   DU_FREE(rrcDeliveryReport->protocolIEs.list.array[idx],
11400                         sizeof(RRCDeliveryReportIEs_t));
11401                }
11402             }
11403             DU_FREE(rrcDeliveryReport->protocolIEs.list.array,
11404                   rrcDeliveryReport->protocolIEs.list.size);
11405          }
11406          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11407       }
11408       DU_FREE(f1apMsg,
11409             sizeof(F1AP_PDU_t));
11410    }
11411 }
11412
11413 /*******************************************************************
11414 *
11415 * @brief Builds and sends the RRC delivery report
11416 *
11417 * @details
11418 *
11419 *    Function : BuildAndSendRrcDeliveryReport
11420 *
11421 *    Functionality: Builds and sends the RRC delivery report
11422 *
11423 * @params[in]
11424 *
11425 * @return ROK     - success
11426 *         RFAILED - failure
11427 *
11428 * ****************************************************************/
11429 uint8_t BuildAndSendRrcDeliveryReport(uint32_t gnbCuUeF1apId, \
11430    uint32_t gnbDuUeF1apId, RrcDeliveryReport *rrcDelivery)
11431 {
11432    uint8_t             ret = RFAILED;
11433    uint8_t             idx    = 0;
11434    uint8_t             idx1   = 0;
11435    uint8_t             elementCnt = 0;
11436    F1AP_PDU_t          *f1apMsg = NULLP;
11437    asn_enc_rval_t      encRetVal;
11438    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11439
11440    do{
11441
11442       DU_LOG("\nINFO   -->  F1AP : Building RRC delivery Message Transfer Message\n");
11443       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11444       if(f1apMsg == NULLP)
11445       {
11446          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11447          break;
11448       }
11449       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
11450       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11451       if(f1apMsg->choice.initiatingMessage == NULLP)
11452       {
11453          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU  failed");
11454          break;
11455       }
11456       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_RRCDeliveryReport;
11457       f1apMsg->choice.initiatingMessage->criticality   = Criticality_ignore;
11458       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RRCDeliveryReport;
11459
11460       rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11461       elementCnt = 4;
11462       rrcDeliveryReport->protocolIEs.list.count = elementCnt;
11463       rrcDeliveryReport->protocolIEs.list.size = elementCnt * sizeof(RRCDeliveryReportIEs_t *);
11464
11465       /* Initialize the F1Setup members */
11466       DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array, rrcDeliveryReport->protocolIEs.list.size);
11467       if(rrcDeliveryReport->protocolIEs.list.array == NULLP)
11468       {
11469          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRC Delivery  failed");
11470          break;
11471       }
11472       for(idx =0 ;idx <elementCnt; idx++)
11473       {
11474          DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array[idx], sizeof(RRCDeliveryReportIEs_t));
11475          if(rrcDeliveryReport->protocolIEs.list.array[idx] == NULLP)
11476          {
11477             break;
11478          }
11479       }
11480
11481       idx1 = 0;
11482
11483       /*GNB CU UE F1AP ID*/
11484       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11485       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
11486       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_CU_UE_F1AP_ID;
11487       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
11488
11489       /*GNB DU UE F1AP ID*/
11490       idx1++;
11491       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11492       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
11493       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_DU_UE_F1AP_ID;
11494       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
11495
11496       /*RRC delivery status*/
11497       idx1++;
11498       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_RRCDeliveryStatus;
11499       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
11500       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_RRCDeliveryStatus;
11501       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.delivery_status =\
11502       rrcDelivery->rrcDeliveryStatus.deliveryStatus;
11503       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.triggering_message =\
11504       rrcDelivery->rrcDeliveryStatus.triggeringMessage;
11505
11506       /* SRB ID */
11507       idx1++;
11508       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
11509       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
11510       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_SRBID;
11511       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.SRBID =  rrcDelivery->srbId;
11512
11513       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11514
11515       /* Encode the RRC DELIVERY REPORT type as APER */
11516       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11517       encBufSize = 0;
11518       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11519             encBuf);
11520
11521       /* Encode results */
11522       if(encRetVal.encoded == ENCODE_FAIL)
11523       {
11524          DU_LOG("\nERROR  -->  F1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
11525                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11526          break;
11527       }
11528       else
11529       {
11530          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for RRC Delivery Msg \n");
11531          for(idx=0; idx< encBufSize; idx++)
11532          {
11533             printf("%x",encBuf[idx]);
11534          }
11535       }
11536
11537       /* Sending msg */
11538       if(sendF1APMsg() != ROK)
11539       {
11540          DU_LOG("\nERROR  -->  F1AP : Sending RRC delivery  msg request failed");
11541          break;
11542       }
11543       ret = ROK;
11544       break;
11545
11546    }while(true);
11547
11548    freeRrcDeliveryReport(f1apMsg);
11549    return ret;
11550 }
11551
11552 /*******************************************************************
11553  *
11554  * @brief Processes cells to be activated
11555  *
11556  * @details
11557  *
11558  *    Function : extractCellsToBeActivated
11559  *
11560  *    Functionality:
11561  *      - Processes cells to be activated list received in F1SetupRsp
11562  *
11563  * @params[in] void
11564  * @return ROK     - success
11565  *         RFAILED - failure
11566  *
11567  * ****************************************************************/
11568
11569 uint8_t extractCellsToBeActivated(Cells_to_be_Activated_List_t cellsToActivate)
11570 {
11571    uint8_t  ret = ROK;
11572    uint16_t idx, nci, pci = 0;
11573    Cells_to_be_Activated_List_Item_t cell;
11574
11575    for(idx=0; idx<cellsToActivate.list.count; idx++)
11576    {
11577       nci = 0;
11578       cell = cellsToActivate.list.array[idx]->value.choice.Cells_to_be_Activated_List_Item;
11579       bitStringToInt(&cell.nRCGI.nRCellIdentity, &nci);
11580
11581       if(cell.nRPCI)
11582       {
11583          pci = *cell.nRPCI;
11584       }
11585       ret = duProcCellsToBeActivated(cell.nRCGI.pLMN_Identity.buf, nci, pci);
11586    }
11587    return ret;
11588 }
11589 /******************************************************************
11590 *
11591 * @brief Processes F1 Setup Response allocated by aper_decoder
11592 *
11593 * @details
11594 *
11595 *    Function : freeF1SetupRsp
11596 *
11597 *    Functionality: free F1 Setup Response allocated by aper_decoder
11598 *
11599 * @params[in] F1SetupResponse_t *f1SetRspMsg
11600 * @return void
11601 *
11602 * ****************************************************************/
11603
11604 void freeAperDecodeF1SetupRsp(F1SetupResponse_t *f1SetRspMsg)
11605 {
11606    uint8_t ieIdx =0;
11607    uint8_t arrIdx =0;
11608    Cells_to_be_Activated_List_t *cellToActivate =NULLP;
11609    RRC_Version_t      *rrcVer =NULLP;
11610
11611    if(f1SetRspMsg->protocolIEs.list.array)
11612    {
11613       for(ieIdx=0; ieIdx<f1SetRspMsg->protocolIEs.list.count; ieIdx++)
11614       {
11615          if(f1SetRspMsg->protocolIEs.list.array[ieIdx])
11616          {
11617             switch(f1SetRspMsg->protocolIEs.list.array[ieIdx]->id)
11618             {
11619                case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11620                   {
11621                      cellToActivate =
11622                         &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.Cells_to_be_Activated_List;
11623                      if(cellToActivate->list.array)
11624                      {
11625                         for(arrIdx=0; arrIdx<cellToActivate->list.count ; arrIdx++)
11626                         {
11627                            if(cellToActivate->list.array[arrIdx])
11628                            {
11629
11630                               if(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.\
11631                               pLMN_Identity.buf)
11632                               {
11633                                  if(cellToActivate->list.array[0]->value.choice.\
11634                                        Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf)
11635                                  {
11636                                     free(cellToActivate->list.array[0]->value.choice.\
11637                                           Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf);
11638                                  }
11639
11640                                  free(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
11641                                        nRCGI.pLMN_Identity.buf);
11642                               }
11643                               free(cellToActivate->list.array[arrIdx]);
11644                            }
11645                         }
11646                         free(cellToActivate->list.array);
11647                      }
11648                      break;
11649                   }
11650                case ProtocolIE_ID_id_TransactionID:
11651                   {
11652                      break;
11653                   }
11654                case ProtocolIE_ID_id_gNB_CU_Name:
11655                   {
11656                      free(f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_Name.buf);
11657                      break;
11658                   }
11659                case ProtocolIE_ID_id_GNB_CU_RRC_Version:
11660                   {
11661                      rrcVer = &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
11662                      if(rrcVer->latest_RRC_Version.buf)
11663                      {
11664                         if(rrcVer->iE_Extensions)
11665                         {
11666                            if(rrcVer->iE_Extensions->list.array)
11667                            {
11668                               if(rrcVer->iE_Extensions->list.array[0])
11669                               {
11670                                  if(rrcVer->iE_Extensions->list.\
11671                                        array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf)
11672                                  {
11673                                     free(rrcVer->iE_Extensions->list.\
11674                                           array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf);
11675                                  }
11676                                  free(rrcVer->iE_Extensions->list.array[0]);
11677                               }
11678                               free(rrcVer->iE_Extensions->list.array);
11679                            }
11680                            free(rrcVer->iE_Extensions);
11681                         }
11682                         free(rrcVer->latest_RRC_Version.buf);
11683                      }
11684                      break;
11685
11686                   }
11687                default:
11688                   {
11689                      DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
11690                            f1SetRspMsg->protocolIEs.list.array[ieIdx]->id);
11691                   }
11692             }
11693             free(f1SetRspMsg->protocolIEs.list.array[ieIdx]);
11694          }
11695       }
11696       free(f1SetRspMsg->protocolIEs.list.array);
11697    }
11698 }
11699 /******************************************************************
11700  *
11701  * @brief Processes F1 Setup Response sent by CU
11702  *
11703  * @details
11704  *
11705  *    Function : procF1SetupRsp
11706  *
11707  *    Functionality: Processes F1 Setup Response sent by CU
11708  *
11709  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11710  * @return ROK     - success
11711  *         RFAILED - failure
11712  *
11713  * ****************************************************************/
11714 uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg)
11715 {
11716    uint8_t ret = ROK;
11717    uint16_t idx =0;
11718    F1SetupResponse_t *f1SetRspMsg = NULLP;
11719    GNB_CU_Name_t     *cuName = NULLP;
11720    F1SetupRsp  f1SetRspDb;
11721    RRC_Version_t      *rrcVer =NULLP;
11722
11723    memset(&f1SetRspDb, 0, sizeof(F1SetupRsp));
11724
11725    DU_LOG("\nINFO   -->  F1AP : F1 Setup Response received");
11726    f1SetRspMsg = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
11727
11728    for(idx=0; idx<f1SetRspMsg->protocolIEs.list.count; idx++)
11729    {
11730       switch(f1SetRspMsg->protocolIEs.list.array[idx]->id)
11731       {
11732          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11733             {
11734                extractCellsToBeActivated(f1SetRspMsg->protocolIEs.list.array[idx]->\
11735                      value.choice.Cells_to_be_Activated_List);
11736                break;
11737             }
11738          case ProtocolIE_ID_id_TransactionID:
11739             {
11740                f1SetRspDb.transId = f1SetRspMsg->protocolIEs.list.array[idx]->\
11741                                     value.choice.TransactionID;
11742                break;
11743             }
11744          case ProtocolIE_ID_id_gNB_CU_Name:
11745             {
11746                cuName = &f1SetRspMsg->protocolIEs.list.array[idx]->\
11747                         value.choice.GNB_CU_Name;
11748                strcpy(f1SetRspDb.cuName, (const char*)cuName->buf);
11749                break;
11750             }
11751          case ProtocolIE_ID_id_GNB_CU_RRC_Version:
11752             {
11753                rrcVer = &f1SetRspMsg->protocolIEs.list.array[idx]->value.choice.RRC_Version;
11754                strcpy(f1SetRspDb.rrcVersion.rrcVer,
11755                      (const char*)rrcVer->latest_RRC_Version.buf);
11756                break;
11757             }
11758          default:
11759             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
11760                   f1SetRspMsg->protocolIEs.list.array[idx]->id);
11761       }
11762       duProcF1SetupRsp();
11763    }
11764
11765    freeAperDecodeF1SetupRsp(f1SetRspMsg);
11766    return ret;
11767 }
11768 /*******************************************************************
11769 *
11770 * @brief free GNB DU config update ack
11771 *
11772 * @details
11773 *
11774 *    Function : freeAperDecodeGnbDuAck
11775 *
11776 *    Functionality: Processes GNB DU config update ack And
11777 *                     added free part for the memory allocated by aper_decoder
11778 *
11779 * @params[in] F1AP_PDU_t ASN decoded F1AP message
11780 * @return ROK     - success
11781 *         RFAILED - failure
11782 *
11783 * ****************************************************************/
11784
11785 void freeAperDecodeGnbDuAck(GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck)
11786 {
11787    uint8_t ieIdx = 0;
11788
11789    if(gnbDuAck->protocolIEs.list.array)
11790    {
11791       for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
11792       {
11793          if(gnbDuAck->protocolIEs.list.array[ieIdx])
11794          {
11795             free(gnbDuAck->protocolIEs.list.array[ieIdx]);
11796          }
11797       }
11798       free(gnbDuAck->protocolIEs.list.array);
11799    }
11800 }
11801
11802 /*******************************************************************
11803 *
11804 * @brief Building  result of gnb-du config update ack output
11805 *
11806 * @details
11807 *
11808 *    Function : duProcGnbDuCfgUpdAckMsg
11809 *
11810 *    Functionality:
11811 *        Building output of gnb-du config update ack
11812 *
11813 * @params[in] transId
11814 * @return void
11815 *
11816 * ****************************************************************/
11817
11818 uint8_t duProcGnbDuCfgUpdAckMsg(uint8_t transId)
11819 {
11820    uint8_t  ieIdx=0, arrIdx=0,ret=ROK;
11821    uint8_t  ueId =0 , ueIdx =0;
11822    uint16_t cellId =0, cellIdx =0, crnti=0;
11823    CmLList *f1apPduNode = NULLP;
11824    ReservedF1apPduInfo *f1apPduInfo =NULLP;
11825    F1AP_PDU_t *f1apMsgPdu = NULLP;
11826    GNBDUConfigurationUpdate_t *gnbDuConfigUpdate = NULLP;
11827    BIT_STRING_t *cellIdentity=NULLP;
11828    struct Served_Cells_To_Delete_ItemIEs *deleteItemIe=NULLP;
11829    Served_Cells_To_Delete_List_t *cellsToDelete=NULLP;
11830    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
11831
11832    DU_LOG("\nINFO   -->  DU APP: GNB-DU config update Ack received ");
11833    f1apPduNode = searchFromReservedF1apPduList(transId);
11834    f1apPduInfo = (ReservedF1apPduInfo *)f1apPduNode->node;
11835    f1apMsgPdu = (F1AP_PDU_t *)f1apPduInfo->f1apMsg;
11836
11837    if(f1apMsgPdu)
11838    {
11839       if(f1apMsgPdu->choice.initiatingMessage)
11840       {
11841          gnbDuConfigUpdate = &f1apMsgPdu->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
11842          for(ieIdx=0; ieIdx < gnbDuConfigUpdate->protocolIEs.list.count; ieIdx++)
11843          {
11844             switch(gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->id)
11845             {
11846                case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
11847                   {
11848                      cellsToDelete = &gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
11849                                      Served_Cells_To_Delete_List;
11850                      if(cellsToDelete->list.array)
11851                      {
11852                         if(cellsToDelete->list.array[arrIdx])
11853                         {
11854                            deleteItemIe = (Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx];
11855                            deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
11856                            if(deleteItem->oldNRCGI.nRCellIdentity.buf)
11857                            {
11858                               cellIdentity = &deleteItem->oldNRCGI.nRCellIdentity;
11859                               bitStringToInt(cellIdentity, &cellId);
11860                            }
11861                         }
11862                      }
11863
11864                      GET_CELL_IDX(cellId, cellIdx);
11865                      if(duCb.actvCellLst[cellIdx] != NULLP)
11866                      {
11867                         if(duCb.actvCellLst[cellIdx]->numActvUes == 0)
11868                         {
11869                            duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
11870                            ret = duSendCellDeletReq(cellId);
11871                            if(ret == RFAILED)
11872                            {
11873                               DU_LOG("ERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to send cell delete\
11874                               request for cellId[%d]", cellId);
11875                            }
11876                         }
11877                         else
11878                         {
11879                            for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
11880                            {
11881                               crnti = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].crnti;
11882                               GET_UE_IDX(crnti,ueId);
11883                               ret = BuildAndSendUeContextReleaseReq(cellId, ueId);
11884                               if(ret == RFAILED)
11885                               {
11886                                  DU_LOG("ERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to build and send UE delete\
11887                                  request for cellId[%d]", cellId);
11888                               }
11889                            }
11890                         }
11891                      }
11892                      else
11893                      {
11894                         DU_LOG("ERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): CellId [%d] not found", cellId);
11895                         ret = RFAILED;
11896                      }
11897                      break;
11898                   }
11899
11900                default:
11901                   break;
11902             }
11903          }
11904       }
11905    }
11906
11907    FreeDUConfigUpdate(f1apMsgPdu);
11908    deleteFromReservedF1apPduList(f1apPduNode);
11909    return ret;
11910 }
11911
11912 /*******************************************************************
11913 *
11914 * @brief Processes GNB DU config update ack
11915 *
11916 * @details
11917 *
11918 *    Function : procF1GNBDUCfgUpdAck
11919 *
11920 *    Functionality: added free part for the memory allocated by aper_decoder
11921 *
11922 * @params[in] F1AP_PDU_t *f1apMsg
11923 * @return void
11924 *
11925 * ****************************************************************/
11926 uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
11927 {
11928    uint8_t ieIdx=0,transId=0;
11929    GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
11930
11931    DU_LOG("\nINFO   -->  F1AP : GNB-DU config update acknowledgment");
11932    gnbDuAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
11933
11934    for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
11935    {
11936       switch(gnbDuAck->protocolIEs.list.array[ieIdx]->id)
11937       {
11938          case ProtocolIE_ID_id_TransactionID:
11939             {
11940                transId = gnbDuAck->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
11941                break;
11942             }
11943          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11944             {
11945                break;
11946             }
11947          default :
11948             {
11949                DU_LOG("\nERROR  -->  F1AP: procF1GNBDUCfgUpdAck(): Invalid IE Received: %ld", \
11950                      gnbDuAck->protocolIEs.list.array[ieIdx]->id);
11951                break;
11952             }
11953       }
11954    }
11955
11956    duProcGnbDuCfgUpdAckMsg(transId);
11957
11958 #if 0
11959    /* presently we are not supporting F1 Reset from DU to CU , we are only
11960     * supporting F1 Reset from CU to DU */
11961
11962    if(BuildAndSendF1ResetReq() != ROK)
11963    {
11964       return RFAILED;
11965    }
11966 #endif
11967
11968    freeAperDecodeGnbDuAck(gnbDuAck);
11969    return ROK;
11970 }
11971 /******************************************************************
11972 *
11973 * @brief free DL RRC Message Transfer allocated by aper_decoder
11974 *
11975 * @details
11976 *
11977 *    Function : freeAperDecodef1DlRrcMsg
11978 *
11979 *    Functionality: free DL RRC Message Transfer allocated by aper_decoder
11980 *
11981 * @params[in] DLRRCMessageTransfer_t *f1DlRrcMsg
11982 * @return ROK     - success
11983 *         RFAILED - failure
11984 *
11985 * ****************************************************************/
11986
11987 void freeAperDecodef1DlRrcMsg(DLRRCMessageTransfer_t *f1DlRrcMsg)
11988 {
11989    uint8_t ieIdx =0;
11990    RRCContainer_t *rrcContainer = NULLP;
11991
11992    if(f1DlRrcMsg->protocolIEs.list.array)
11993    {
11994       for(ieIdx=0; ieIdx<f1DlRrcMsg->protocolIEs.list.count; ieIdx++)
11995       {
11996          if(f1DlRrcMsg->protocolIEs.list.array[ieIdx])
11997          {
11998             switch(f1DlRrcMsg->protocolIEs.list.array[ieIdx]->id)
11999             {
12000                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12001                   break;
12002                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12003                   break;
12004                case ProtocolIE_ID_id_SRBID:
12005                   break;
12006                case ProtocolIE_ID_id_RRCContainer:
12007                   {
12008                      rrcContainer =&f1DlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
12009                      free(rrcContainer->buf);
12010                   }
12011                case ProtocolIE_ID_id_ExecuteDuplication:
12012                   break;
12013                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
12014                   break;
12015                   break;
12016             }
12017             free(f1DlRrcMsg->protocolIEs.list.array[ieIdx]);
12018          }
12019       }
12020       free(f1DlRrcMsg->protocolIEs.list.array);
12021    }
12022 }
12023 /******************************************************************
12024  *
12025  * @brief Processes DL RRC Message Transfer  sent by CU
12026  *
12027  * @details
12028  *
12029  *    Function : procF1DlRrcMsgTrans
12030  *
12031  *    Functionality: Processes DL RRC Message Transfer sent by CU
12032  *
12033  * @params[in] F1AP_PDU_t ASN decoded F1AP message
12034  * @return ROK     - success
12035  *         RFAILED - failure
12036  *
12037  * ****************************************************************/
12038 uint8_t procF1DlRrcMsgTrans(F1AP_PDU_t *f1apMsg)
12039 {
12040    uint8_t  idx, ret;
12041    DLRRCMessageTransfer_t *f1DlRrcMsg = NULLP;
12042    F1DlRrcMsg dlMsg;
12043    memset(&dlMsg, 0, sizeof(F1DlRrcMsg));
12044
12045    DU_LOG("\nINFO   -->  DU_APP : DL RRC message transfer Recevied");
12046    f1DlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
12047
12048    ret = ROK;
12049
12050    for(idx=0; idx<f1DlRrcMsg->protocolIEs.list.count; idx++)
12051    {
12052       switch(f1DlRrcMsg->protocolIEs.list.array[idx]->id)
12053       {
12054          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12055             {
12056                dlMsg.gnbCuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
12057                break;
12058             }
12059          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12060             {
12061                dlMsg.gnbDuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
12062                break;
12063             }
12064          case ProtocolIE_ID_id_SRBID:
12065             {
12066                dlMsg.srbId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
12067                break;
12068             }
12069          case ProtocolIE_ID_id_ExecuteDuplication:
12070             dlMsg.execDup = true;
12071             break;
12072
12073          case ProtocolIE_ID_id_RRCContainer:
12074             {
12075                if(f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0)
12076                {
12077                   dlMsg.rrcMsgSize = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
12078                   DU_ALLOC_SHRABL_BUF(dlMsg.rrcMsgPdu, dlMsg.rrcMsgSize);
12079                   if(dlMsg.rrcMsgPdu)
12080                   {
12081                      memcpy(dlMsg.rrcMsgPdu, f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
12082                         dlMsg.rrcMsgSize);
12083                   }
12084                   else
12085                   {
12086                      DU_LOG("\nERROR  -->  DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
12087                      return RFAILED;
12088                   }
12089                }
12090                else
12091                {
12092                   DU_LOG("\nERROR  -->  DU_APP : RRC Container Size is invalid:%ld",\
12093                   f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
12094                   return RFAILED;
12095                }
12096                break;
12097             }
12098          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
12099             {
12100                dlMsg.deliveryStatRpt = true;
12101                break;
12102             }
12103          default:
12104             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
12105                   f1DlRrcMsg->protocolIEs.list.array[idx]->id);
12106       }
12107    }
12108
12109    ret = duProcDlRrcMsg(&dlMsg);
12110
12111    freeAperDecodef1DlRrcMsg(f1DlRrcMsg);
12112    return ret;
12113 }
12114 /*******************************************************************
12115  *
12116 * @brief Builds the DRB to be Setup Mod list
12117 *
12118 * @details
12119 *
12120 *    Function :
12121 *
12122 *    Functionality: Constructs the DRB to be Setup Mod list
12123 *
12124 * @params[in] DRBs_SetupMod_List_t *drbSet
12125 *
12126 * @return ROK     - success
12127 *         RFAILED - failure
12128 *
12129 * ****************************************************************/
12130
12131 uint8_t BuildDrbSetupModList(DRBs_SetupMod_List_t *drbSet , DuUeCfg *ueCfg)
12132 {
12133    uint8_t arrIdx =0;
12134    uint8_t drbCnt =0;
12135    struct DRBs_SetupMod_ItemIEs *drbItemIe;
12136
12137    drbCnt = 1;
12138    drbSet->list.count = drbCnt;
12139    drbSet->list.size = drbCnt * sizeof(DRBs_SetupMod_ItemIEs_t *);
12140    DU_ALLOC(drbSet->list.array, drbSet->list.size);
12141    if(drbSet->list.array == NULLP)
12142    {
12143       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
12144       return  RFAILED;
12145    }
12146    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
12147    {
12148       DU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
12149       if(drbSet->list.array[arrIdx] == NULLP)
12150       {
12151               DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
12152               return  RFAILED;
12153       }
12154
12155       drbItemIe = (struct DRBs_SetupMod_ItemIEs *)drbSet->list.array[arrIdx];
12156       drbItemIe->id = ProtocolIE_ID_id_DRBs_SetupMod_Item;
12157       drbItemIe->criticality = Criticality_reject;
12158       drbItemIe->value.present = DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item;
12159       drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
12160       if(fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List,\
12161       &ueCfg->upTnlInfo[arrIdx])!= ROK)
12162       {
12163          DU_LOG("\nERROR  -->  F1AP : Failed to fill DlTnl SetupList in BuildDrbToBeSetupModList");
12164          return RFAILED;
12165       }
12166
12167    }
12168
12169    return ROK;
12170 }
12171 /*******************************************************************
12172 * @brief Free the memory allocated for DRB setup List
12173 *
12174 * @details
12175 *
12176 *    Function : FreeDrbSetupModList
12177 *
12178 *    Functionality:
12179 *       Free the memory allocated for DRB setup list
12180 *
12181 * @params[in] DRBs_Setup_List_t *
12182 * @return void
12183 *
12184 * ****************************************************************/
12185 void FreeDrbSetupModList(DRBs_SetupMod_List_t *drbSetupList)
12186 {
12187    uint8_t arrIdx = 0;
12188    DRBs_SetupMod_ItemIEs_t *drbItemIe = NULLP;
12189
12190    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
12191    {
12192       drbItemIe = ((DRBs_SetupMod_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
12193       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
12194       DU_FREE(drbSetupList->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
12195    }
12196    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
12197 }
12198 /*******************************************************************
12199 * @brief Free the memory allocated for UE Context Mod Response
12200 *
12201 * @details
12202 *
12203 *    Function : FreeUeContextModResp
12204 *
12205 *    Functionality:
12206 *       Free the memory allocated for UE Context Mod Response
12207 *
12208 * @params[in] F1AP_PDU_t *f1apMsg
12209 * @return void
12210 *
12211 * ****************************************************************/
12212
12213 void FreeUeContextModResp(F1AP_PDU_t *f1apMsg)
12214 {
12215    uint8_t ieIdx;
12216    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
12217    if(f1apMsg)
12218    {
12219       if(f1apMsg->choice.successfulOutcome)
12220       {
12221          ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
12222          if(ueContextModifyRes->protocolIEs.list.array)
12223          {
12224             for(ieIdx=0 ; ieIdx<ueContextModifyRes->protocolIEs.list.count; ieIdx++)
12225             {
12226                if(ueContextModifyRes->protocolIEs.list.array[ieIdx])
12227                {
12228                   switch(ueContextModifyRes->protocolIEs.list.array[ieIdx]->id)
12229                   {
12230                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12231                         break;
12232                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12233                         break;
12234                      case ProtocolIE_ID_id_DRBs_SetupMod_List:
12235                         {
12236                             FreeDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
12237                             value.choice.DRBs_SetupMod_List));
12238                             break;
12239                         }
12240                   }
12241                   DU_FREE(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
12242                }
12243
12244             }
12245             DU_FREE(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
12246          }
12247          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12248       }
12249       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12250    }
12251 }
12252
12253 /*****************************************************************i
12254 *
12255 * @brief Creating the ue context modifcation response and sending
12256 *
12257 * @details
12258 *
12259 *    Function : BuildAndSendUeContextModRsp
12260 *
12261 *    Functionality:
12262 *         - Creating the ue context modifcation response
12263 *
12264 * @params[in] uint8_t cellId,uint8_t ueIdx
12265 * @return ROK     - success
12266 *         RFAILED - failure
12267 *
12268 * ****************************************************************/
12269 uint8_t BuildAndSendUeContextModRsp(uint8_t cellId,uint8_t ueIdx)
12270 {
12271    uint8_t   ieIdx = 0;
12272    uint8_t   cellIdx =0;
12273    uint8_t   elementCnt = 0;
12274    uint8_t   ret = RFAILED;
12275    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
12276    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
12277    F1AP_PDU_t *f1apMsg = NULLP;
12278    asn_enc_rval_t         encRetVal;
12279    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
12280    DuUeCb                   *ueCb = NULLP;
12281
12282    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification response\n");
12283
12284    while(1)
12285    {
12286       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12287       if(f1apMsg == NULLP)
12288       {
12289          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
12290          break;
12291       }
12292
12293       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
12294
12295       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12296       if(f1apMsg->choice.successfulOutcome == NULLP)
12297       {
12298          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
12299          break;
12300       }
12301       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextModification;
12302       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
12303       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_UEContextModificationResponse;
12304
12305       ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
12306
12307       elementCnt = 3;
12308       ueContextModifyRes->protocolIEs.list.count = elementCnt;
12309       ueContextModifyRes->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationResponse_t*);
12310
12311       /* Initialize the UE context modification members */
12312       DU_ALLOC(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
12313       if(ueContextModifyRes->protocolIEs.list.array == NULLP)
12314       {
12315          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
12316          break;
12317       }
12318
12319       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
12320       {
12321          DU_ALLOC(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
12322          if(ueContextModifyRes->protocolIEs.list.array[ieIdx] == NULLP)
12323          {
12324             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
12325             break;
12326          }
12327       }
12328
12329       /* Fetching Ue Cb Info*/
12330       GET_CELL_IDX(cellId, cellIdx);
12331       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
12332       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
12333       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
12334
12335       ieIdx=0;
12336       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
12337       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12338       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
12339       UEContextModificationResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
12340       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
12341
12342       ieIdx++;
12343       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
12344       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12345       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present=\
12346       UEContextModificationResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
12347       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
12348
12349       ieIdx++;
12350       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_SetupMod_List;
12351       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12352       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
12353       UEContextModificationResponseIEs__value_PR_DRBs_SetupMod_List;
12354       if(ueCb->f1UeDb)
12355       {
12356          ret = BuildDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
12357                   value.choice.DRBs_SetupMod_List) , &ueCb->f1UeDb->duUeCfg);
12358          if(ret != ROK)
12359          {
12360             DU_LOG( "\nERROR  -->  F1AP : Failed to build drb setupmod List ");
12361             break;
12362          }
12363          freeF1UeDb(ueCb->f1UeDb);
12364          ueCb->f1UeDb = NULLP;
12365       }
12366       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12367
12368       /* Encode the F1SetupRequest type as APER */
12369       memset(encBuf, 0, ENC_BUF_MAX_LEN);
12370       encBufSize = 0;
12371       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,encBuf);
12372
12373       /* Encode results */
12374       if(encRetVal.encoded == ENCODE_FAIL)
12375       {
12376          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
12377                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12378          ret = RFAILED;
12379          break;
12380       }
12381       else
12382       {
12383          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Modification Response\n");
12384          for(int i=0; i< encBufSize; i++)
12385          {
12386             printf("%x",encBuf[i]);
12387          }
12388       }
12389
12390       /* Sending  msg  */
12391       if(sendF1APMsg() != ROK)
12392       {
12393          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Res Failed");
12394          ret = RFAILED;
12395          break;
12396       }
12397       break;
12398    }
12399    FreeUeContextModResp(f1apMsg);
12400    return ret;
12401 }
12402 /*******************************************************************
12403  *
12404  * @brief Deallocating the memory allocated by the aper decoder
12405  *          for QOSInfo
12406  *
12407  * @details
12408  *
12409  *    Function : freeAperDecodeQosInfo
12410  *
12411  *    Functionality:  Deallocating the memory allocated for QOSInfo
12412  *
12413  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
12414  *
12415  * @return void
12416  *
12417  * ****************************************************************/
12418
12419 void freeAperDecodeQosInfo(QoSFlowLevelQoSParameters_t *drbQos)
12420 {
12421    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
12422    {
12423       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
12424       {
12425          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
12426          {
12427             free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
12428          }
12429          free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
12430       }
12431       free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI);
12432    }
12433 }
12434 /*******************************************************************
12435  *
12436  * @brief Deallocating the memory allocated by the aper decoder
12437  *          for UlTnlInfoforDrb
12438  *
12439  * @details
12440  *
12441  *    Function : freeAperDecodeUlTnlInfoforDrbSetupMod
12442  *
12443  *    Functionality:  Deallocating memory allocated for UlTnlInfoforDrb
12444  *
12445  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
12446  *
12447  * @return void
12448  *
12449  * ****************************************************************/
12450 void freeAperDecodeUlTnlInfoforDrbSetupMod(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
12451 {
12452    uint8_t arrIdx =0;
12453
12454    if(ulInfo->list.array)
12455    {
12456       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
12457       {
12458          if(ulInfo->list.array[arrIdx])
12459          {
12460             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
12461             {
12462                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
12463                {
12464                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
12465                   {
12466                      free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12467                            gTP_TEID.buf);
12468                   }
12469                   free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12470                         transportLayerAddress.buf);
12471                }
12472                free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel);
12473             }
12474             free(ulInfo->list.array[arrIdx]);
12475          }
12476       }
12477       free(ulInfo->list.array);
12478    }
12479 }
12480 /*******************************************************************
12481  *
12482  * @brief Deallocating the memory allocated by the aper decoder
12483  *          for DrbSetupModItem
12484  *
12485  * @details
12486  *
12487  *    Function : freeAperDecodeDrbSetupModItem
12488  *
12489  *    Functionality:  Deallocating memory allocated for DrbSetupModItem
12490  *
12491  * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
12492  *
12493  * @return void
12494  *
12495  * ****************************************************************/
12496
12497 void freeAperDecodeDrbSetupModItem(DRBs_ToBeSetupMod_Item_t *drbItem)
12498 {
12499    uint8_t arrIdx =0;
12500    SNSSAI_t *snssai =NULLP;
12501    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
12502
12503    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
12504    switch(drbItem->qoSInformation.present)
12505    {
12506       case QoSInformation_PR_NOTHING:
12507          break;
12508       case QoSInformation_PR_eUTRANQoS:
12509          {
12510             if(drbItem->qoSInformation.choice.eUTRANQoS)
12511             {
12512                free(drbItem->qoSInformation.choice.eUTRANQoS);
12513             }
12514             break;
12515          }
12516       case QoSInformation_PR_choice_extension:
12517          {
12518             if(drbItem->qoSInformation.choice.choice_extension)
12519             {
12520                freeAperDecodeQosInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.\
12521                      DRB_Information.dRB_QoS);
12522                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
12523                if(snssai->sST.buf)
12524                {
12525                   free(snssai->sST.buf);
12526                }
12527                if(snssai->sD)
12528                {
12529                   if(snssai->sD->buf)
12530                   {
12531                      free(snssai->sD->buf);
12532                   }
12533                   free(snssai->sD);
12534                }
12535
12536                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.\
12537                          DRB_Information.flows_Mapped_To_DRB_List;
12538                if(flowMap->list.array)
12539                {
12540                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
12541                   {
12542                      if(flowMap->list.array[arrIdx] )
12543                      {
12544                         freeAperDecodeQosInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
12545                         free(flowMap->list.array[arrIdx]);
12546                      }
12547                   }
12548                   free(flowMap->list.array);
12549                }
12550
12551                free(drbItem->qoSInformation.choice.choice_extension);
12552             }
12553             break;
12554          }
12555
12556    }
12557    freeAperDecodeUlTnlInfoforDrbSetupMod(&drbItem->uLUPTNLInformation_ToBeSetup_List);
12558    if(drbItem->uLConfiguration)
12559    {
12560       free(drbItem->uLConfiguration);
12561    }
12562 }
12563
12564 /*******************************************************************
12565  *
12566  * @brief Deallocating the memory allocated by the aper decoder
12567  *          for DrbToBeSetupModList
12568  *
12569  * @details
12570  *
12571  *    Function : freeAperDecodeDrbToBeSetupModList
12572  *
12573  *    Functionality:  Deallocating memory allocated for DrbToBeSetupModList
12574  *
12575  * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
12576  *
12577  * @return void
12578  *
12579  * ****************************************************************/
12580
12581 void freeAperDecodeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
12582 {
12583    uint8_t arrIdx =0;
12584    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
12585
12586    if(drbSet->list.array)
12587    {
12588       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
12589       {
12590          if(drbSet->list.array[arrIdx] != NULLP)
12591          {
12592             if(arrIdx == 0)
12593             {
12594                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
12595                freeAperDecodeDrbSetupModItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
12596             }
12597             free(drbSet->list.array[arrIdx]);
12598          }
12599       }
12600       free(drbSet->list.array);
12601    }
12602
12603 }
12604 /*******************************************************************
12605  *
12606  * @brief Deallocating the memory allocated by the aper decoder
12607  *          for UeContextModificationReqMsg
12608  *
12609  * @details
12610  *
12611  *    Function : freeAperDecodeUeContextModificationReqMsg
12612  *
12613  *    Functionality:  Deallocating memory allocated for
12614  *                  UeContextModificationReqMsg
12615  *
12616  * @params[in] UEContextModificationRequest_t *UeContextModifyReq
12617  *
12618  * @return void
12619  *
12620  * ****************************************************************/
12621 void freeAperDecodeUeContextModificationReqMsg(UEContextModificationRequest_t *UeContextModifyReq )
12622 {
12623    uint8_t arrIdx, ieId;
12624
12625    if(UeContextModifyReq->protocolIEs.list.array)
12626    {
12627       for( arrIdx = 0 ; arrIdx<UeContextModifyReq->protocolIEs.list.count ; arrIdx++)
12628       {
12629          if(UeContextModifyReq->protocolIEs.list.array[arrIdx])
12630          {
12631             ieId = UeContextModifyReq->protocolIEs.list.array[arrIdx]->id;
12632             switch(ieId)
12633             {
12634                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12635                   break;
12636                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12637                   break;
12638                case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
12639                   {
12640                      freeAperDecodeDrbToBeSetupModList(&UeContextModifyReq->protocolIEs.list.array[arrIdx]->\
12641                            value.choice.DRBs_ToBeSetupMod_List);
12642                      break;
12643                   }
12644             }
12645             free(UeContextModifyReq->protocolIEs.list.array[arrIdx]);
12646          }
12647       }
12648       free(UeContextModifyReq->protocolIEs.list.array);
12649    }
12650 }
12651 /*******************************************************************
12652  *
12653  * @brief processing the F1 UeContextModificationReq
12654  *
12655  * @details
12656  *
12657  *    Function : procF1UeContextModificationReq
12658  *
12659  *    Functionality:  processing the F1 UeContextModificationReq
12660  *
12661  * @params[in] F1AP_PDU_t *f1apMsg
12662  *
12663  * @return
12664  * ****************************************************************/
12665 uint8_t procF1UeContextModificationReq(F1AP_PDU_t *f1apMsg)
12666 {
12667    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
12668    uint8_t  ret = ROK, ieIdx = 0, lcId =0,cellIdx=0, ueIdx=0;
12669    DuUeCb   *duUeCb = NULLP;
12670    DRBs_ToBeSetupMod_List_t *drbSetupModCfg;
12671    uint32_t gnbCuUeF1apId, gnbDuUeF1apId;
12672
12673    ueContextModifyReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
12674    for(ieIdx=0; (ieIdx < ueContextModifyReq->protocolIEs.list.count && ret == ROK); ieIdx++)
12675    {
12676       switch(ueContextModifyReq->protocolIEs.list.array[ieIdx]->id)
12677       {
12678          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12679             {
12680                gnbCuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
12681                break;
12682             }
12683          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12684             {
12685                gnbDuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
12686                break;
12687             }
12688          case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
12689             {
12690                for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
12691                {
12692                   for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
12693                   {
12694                      if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
12695                            (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
12696                      {
12697
12698                         duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
12699                         lcId = getDrbLcId(&duUeCb->drbBitMap);
12700                         if(lcId != RFAILED)
12701                         {
12702                            DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
12703                            if(duUeCb->f1UeDb)
12704                            {
12705                               duUeCb->f1UeDb->actionType = UE_CTXT_MOD;
12706                               drbSetupModCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
12707                               choice.DRBs_ToBeSetupMod_List;
12708                               if(extractDrbListToSetup(lcId, NULL, drbSetupModCfg ,drbSetupModCfg->list.count, \
12709                               &duUeCb->f1UeDb->duUeCfg))
12710                               {
12711                                  DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetup()");
12712                                  ret = RFAILED;
12713                               }
12714                            }
12715                         }
12716                      }
12717                      else
12718                      {
12719                         DU_LOG("\nERROR  -->  DU APP : wrong values of gnbCuUeF1apId and gnbDuUeF1apId ");
12720                         ret = RFAILED;
12721                      }
12722                   }
12723                }
12724                break;
12725             }
12726       }
12727    }
12728    if(ret != RFAILED)
12729    {
12730       ret = duProcUeContextModReq(duUeCb);
12731    }
12732    freeAperDecodeUeContextModificationReqMsg(ueContextModifyReq);
12733    return ret;
12734 }
12735 /*****************************************************************i
12736 *
12737 * @brief Free memory allocated for UE Context Release Request
12738 *
12739 * @details
12740 *
12741 *    Function : FreeUeContextReleaseReq
12742 *
12743 *    Functionality:
12744 *         - Free memory allocated for UE Context Release Request
12745 *
12746 * @params[in] F1AP_PDU_t *f1apMsg
12747 * @return void
12748 *
12749 * *************************************************************/
12750 void FreeUeContextReleaseReq(F1AP_PDU_t *f1apMsg)
12751 {
12752    uint8_t ieIdx;
12753    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
12754
12755    if(f1apMsg)
12756    {
12757       if(f1apMsg->choice.initiatingMessage)
12758       {
12759          ueReleaseReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
12760          if(ueReleaseReq->protocolIEs.list.array)
12761          {
12762             for(ieIdx=0 ; ieIdx<ueReleaseReq->protocolIEs.list.count; ieIdx++)
12763             {
12764                DU_FREE(ueReleaseReq->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseRequest_t));
12765             }
12766             DU_FREE(ueReleaseReq->protocolIEs.list.array, ueReleaseReq->protocolIEs.list.size);
12767          }
12768          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
12769       }
12770       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12771    }
12772
12773 }
12774 /*****************************************************************i
12775 *
12776 * @brief Build and Send UE Context Release Request
12777 *
12778 * @details
12779 *
12780 *    Function : BuildAndSendUeContextReleaseReq
12781 *
12782 *    Functionality:
12783 *         - Build and Send UE Context Release Request
12784 *
12785 * @params[in]
12786 * @return ROK     - success
12787 *         RFAILED - failure
12788 *
12789 * *************************************************************/
12790 uint8_t BuildAndSendUeContextReleaseReq(uint16_t cellId, uint8_t ueIdx)
12791 {
12792    bool memAllocFail = false;
12793    uint8_t ieIdx =0;
12794    uint8_t ret = RFAILED;
12795    uint16_t cellIdx =0;
12796    uint16_t crnti = 0;
12797    uint8_t  elementCnt = 0;
12798    uint32_t  gnbCuUeF1apId =0;   /* gNB-CU UE F1AP Id */
12799    uint32_t  gnbDuUeF1apId =0;   /* gNB-DU UE F1AP Id */
12800    asn_enc_rval_t encRetVal;
12801    F1AP_PDU_t *f1apMsg = NULLP;
12802    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
12803
12804    DU_LOG("\nINFO  --> Building the UE Context Release Request");
12805    do
12806    {
12807       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12808       if(f1apMsg == NULLP)
12809       {
12810          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for f1apMsg");
12811          break;
12812       }
12813
12814       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
12815       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
12816       if(f1apMsg->choice.initiatingMessage == NULLP)
12817       {
12818          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for\
12819          initiatingMessage");
12820          break;
12821       }
12822       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextReleaseRequest;
12823       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
12824       f1apMsg->choice.initiatingMessage->value.present = \
12825       InitiatingMessage__value_PR_UEContextReleaseRequest;
12826
12827       ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
12828
12829       elementCnt = 2;
12830
12831       ueReleaseReq->protocolIEs.list.count = elementCnt;
12832       ueReleaseReq->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseRequest_t *);
12833
12834       /* Initialize the F1Setup members */
12835       DU_ALLOC(ueReleaseReq->protocolIEs.list.array,ueReleaseReq->protocolIEs.list.size);
12836       if(ueReleaseReq->protocolIEs.list.array == NULLP)
12837       {
12838          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE array");
12839          break;
12840       }
12841       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
12842       {
12843          DU_ALLOC(ueReleaseReq->protocolIEs.list.array[ieIdx],\
12844                sizeof(UEContextReleaseRequest_t));
12845          if(ueReleaseReq->protocolIEs.list.array[ieIdx] == NULLP)
12846          {
12847             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE elements");
12848             memAllocFail = true;
12849             break;
12850          }
12851       }
12852       if(memAllocFail == true)
12853          break;
12854
12855       /* Fetching Ue Cb Info*/
12856       GET_CELL_IDX(cellId, cellIdx);
12857       if(duCb.actvCellLst[cellIdx] == NULLP)
12858       {
12859          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): CellId[%d] does not exist", cellId);
12860          break;
12861       }
12862       else
12863       {
12864          GET_CRNTI(crnti, ueIdx);
12865          if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].crnti != crnti)
12866          {
12867             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): crnti[%d] does not exist", crnti);
12868             break;
12869          }
12870          gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
12871          gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
12872       }
12873
12874       ieIdx=0;
12875       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
12876       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
12877       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present = \
12878       UEContextReleaseRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
12879       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
12880
12881       ieIdx++;
12882       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
12883       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
12884       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present =\
12885       UEContextReleaseRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
12886       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
12887
12888       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12889
12890       /* Encode the F1SetupRequest type as APER */
12891       memset(encBuf, 0, ENC_BUF_MAX_LEN);
12892       encBufSize = 0;
12893       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
12894       /* Encode results */
12895       if(encRetVal.encoded == ENCODE_FAIL)
12896       {
12897          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseRequest structure (at %s)\n",\
12898                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12899          break;
12900       }
12901       else
12902       {
12903          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseRequest\n");
12904          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
12905          {
12906             printf("%x",encBuf[ieIdx]);
12907          }
12908       }
12909
12910       /* Sending msg */
12911       if(sendF1APMsg() != ROK)
12912       {
12913          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Request failed");
12914          break;
12915       }
12916       ret = ROK;
12917       break;
12918    }while(true);
12919
12920    FreeUeContextReleaseReq(f1apMsg);
12921    return ret;
12922 }
12923 /*****************************************************************i
12924  *
12925  * @brief Free memory allocated for UE Context Release Complete
12926  *
12927  * @details
12928  *
12929  *    Function : FreeUeContextReleaseComplete
12930  *
12931  *    Functionality:
12932  *         - Free memory allocated for UE Context Release Complete
12933  *
12934  * @params[in] F1AP_PDU_t *f1apMsg
12935  * @return void
12936  *
12937  * *************************************************************/
12938 void FreeUeContextReleaseComplete(F1AP_PDU_t *f1apMsg)
12939 {
12940    uint8_t ieIdx;
12941    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
12942
12943    if(f1apMsg)
12944    {
12945       if(f1apMsg->choice.successfulOutcome)
12946       {
12947          ueReleaseComplete =&f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
12948          if(ueReleaseComplete->protocolIEs.list.array)
12949          {
12950             for(ieIdx=0 ; ieIdx<ueReleaseComplete->protocolIEs.list.count; ieIdx++)
12951             {
12952                DU_FREE(ueReleaseComplete->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseComplete_t));
12953             }
12954             DU_FREE(ueReleaseComplete->protocolIEs.list.array, ueReleaseComplete->protocolIEs.list.size);
12955          }
12956          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12957       }
12958       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12959    }
12960
12961 }
12962 /*****************************************************************i
12963  *
12964  * @brief Build and Send UE Context Release Complete
12965  *
12966  * @details
12967  *
12968  *    Function : BuildAndSendUeContextReleaseComplete
12969  *
12970  *    Functionality:
12971  *         - Build and Send UE Context Release Complete
12972  *
12973  * @params[in]  cellId,  gnbCuUeF1apId, gnbDuUeF1apId
12974  * @return ROK     - success
12975  *         RFAILED - failure
12976  *
12977  * *************************************************************/
12978 uint8_t BuildAndSendUeContextReleaseComplete(uint16_t cellId, uint32_t gnbCuUeF1apId, uint32_t gnbDuUeF1apId)
12979 {
12980    bool memAllocFail = false;
12981    uint8_t ieIdx =0, ret = RFAILED, elementCnt = 0;
12982    asn_enc_rval_t encRetVal;
12983    F1AP_PDU_t *f1apMsg = NULLP;
12984    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
12985
12986    DU_LOG("\nINFO  --> Building the UE Context Release Complete");
12987    do
12988    {
12989       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12990       if(f1apMsg == NULLP)
12991       {
12992          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for f1apMsg");
12993          break;
12994       }
12995
12996       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
12997       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12998       if(f1apMsg->choice.successfulOutcome == NULLP)
12999       {
13000          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for\
13001                successfulOutcome");
13002          break;
13003       }
13004       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextRelease;
13005       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
13006       f1apMsg->choice.successfulOutcome->value.present = \
13007       SuccessfulOutcome__value_PR_UEContextReleaseComplete;
13008
13009       ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
13010
13011       elementCnt = 2;
13012       ueReleaseComplete->protocolIEs.list.count = elementCnt;
13013       ueReleaseComplete->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseComplete_t *);
13014
13015       /* Initialize the UE Release Complete members */
13016       DU_ALLOC(ueReleaseComplete->protocolIEs.list.array,ueReleaseComplete->protocolIEs.list.size);
13017       if(ueReleaseComplete->protocolIEs.list.array == NULLP)
13018       {
13019          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE array");
13020          break;
13021       }
13022       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
13023       {
13024          DU_ALLOC(ueReleaseComplete->protocolIEs.list.array[ieIdx],\
13025                sizeof(UEContextReleaseComplete_t));
13026          if(ueReleaseComplete->protocolIEs.list.array[ieIdx] == NULLP)
13027          {
13028             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE\
13029             elements");
13030             memAllocFail = true;
13031             break;
13032          }
13033       }
13034       if(memAllocFail == true)
13035          break;
13036
13037
13038       ieIdx=0;
13039       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
13040       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13041       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present = \
13042       UEContextReleaseCompleteIEs__value_PR_GNB_CU_UE_F1AP_ID;
13043       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
13044
13045       ieIdx++;
13046       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
13047       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13048       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present =\
13049       UEContextReleaseCompleteIEs__value_PR_GNB_DU_UE_F1AP_ID;
13050       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
13051
13052       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13053
13054       /* Encode the F1SetupComplete type as APER */
13055       memset(encBuf, 0, ENC_BUF_MAX_LEN);
13056       encBufSize = 0;
13057       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
13058       /* Encode results */
13059       if(encRetVal.encoded == ENCODE_FAIL)
13060       {
13061          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseComplete structure (at %s)\n",\
13062                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13063          break;
13064       }
13065       else
13066       {
13067          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseComplete\n");
13068          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
13069          {
13070             printf("%x",encBuf[ieIdx]);
13071          }
13072       }
13073
13074       /* Sending msg */
13075       if(sendF1APMsg() != ROK)
13076       {
13077          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Complete failed");
13078          break;
13079       }
13080       ret = ROK;
13081       break;
13082    }while(true);
13083
13084    if(ret == ROK)
13085    {
13086       duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
13087       ret = duSendCellDeletReq(cellId);
13088       if(ret != ROK)
13089       {
13090          DU_LOG("\nERROR  -->  F1AP: BuildAndSendUeContextReleaseComplete(): Failed to process cell\
13091                Delete req for CellId");
13092       }
13093    }
13094    FreeUeContextReleaseComplete(f1apMsg);
13095    return ret;
13096
13097 }
13098
13099 /*******************************************************************
13100 *
13101 * @brief added free part for the memory allocated by aper_decoder
13102 *
13103 * @details
13104 *
13105 *    Function : freeAperDecodeUeContextReleaseCommand
13106 *
13107 *    Functionality: added free part for the memory allocated by aper_decoder
13108 *
13109 * @params[in] F1AP_PDU_t *f1apMsg
13110 * @return void
13111 *
13112 * ****************************************************************/
13113 void freeAperDecodeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
13114 {
13115    uint8_t ieIdx=0;
13116    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
13117
13118    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
13119
13120    if(ueContextReleaseCommand->protocolIEs.list.array)
13121    {
13122       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
13123       {
13124          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
13125          {
13126             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
13127             {
13128                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13129                   break;
13130                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13131                   break;
13132                case ProtocolIE_ID_id_Cause:
13133                   break;
13134                case ProtocolIE_ID_id_RRCContainer:
13135                {
13136                   if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
13137                   {
13138                      free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
13139                   }
13140                   break;
13141                }
13142                default :
13143                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
13144                        ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
13145                   break;
13146             }
13147          }
13148          free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]);
13149       }
13150       free(ueContextReleaseCommand->protocolIEs.list.array);
13151    }
13152 }
13153 /*******************************************************************
13154 *
13155 * @brief processing of UE Context Release Command
13156 *
13157 * @details
13158 *
13159 *    Function : procF1UeContextReleaseCommand
13160 *
13161 *    Functionality: processing of UE Context Release Command
13162 *
13163 * @params[in] F1AP_PDU_t *f1apMsg
13164 * @return void
13165 *
13166 * ****************************************************************/
13167 uint8_t procF1UeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
13168 {
13169    uint8_t  ieIdx=0, ret=ROK, ueIdx=0;
13170    uint16_t cellIdx =0;
13171    bool ueIdxFound;
13172    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0;
13173    DuUeCb   *duUeCb = NULLP;
13174    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
13175
13176    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
13177
13178    if(ueContextReleaseCommand->protocolIEs.list.array)
13179    {
13180       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
13181       {
13182          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
13183          {
13184             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
13185             {
13186                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13187                   {
13188                      gnbCuUeF1apId= ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13189                                     value.choice.GNB_CU_UE_F1AP_ID;
13190                      break;
13191                   }
13192
13193                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13194                   {
13195                      gnbDuUeF1apId = ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13196                                      value.choice.GNB_DU_UE_F1AP_ID;
13197                      break;
13198                   }
13199
13200                case ProtocolIE_ID_id_Cause:
13201                   {
13202                      break;
13203                   }
13204
13205                case ProtocolIE_ID_id_RRCContainer:
13206                   {
13207                      for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
13208                      {
13209                         for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
13210                         {
13211                            if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
13212                                  (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
13213                            {
13214                               duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
13215                               DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
13216                               if(duUeCb->f1UeDb)
13217                               {
13218                                  memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
13219                                  duUeCb->f1UeDb->actionType = UE_CTXT_RELEASE;
13220                                  duUeCb->f1UeDb->cellIdx = cellIdx;
13221                                  /* Filling Dl RRC Msg Info */
13222                                  DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
13223                                  if(!duUeCb->f1UeDb->dlRrcMsg)
13224                                  {
13225                                     DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
13226                                     Memory allocation failed ");
13227                                     ret = RFAILED;
13228                                  }
13229                                  else
13230                                  {
13231                                     duUeCb->f1UeDb->dlRrcMsgPres = true;
13232                                     memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
13233                                     ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
13234                                           &ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13235                                           value.choice.RRCContainer);
13236                                  }
13237
13238                               }
13239                               else
13240                               {
13241                                  DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
13242                                  Memory allocation failed ");
13243                                  ret = RFAILED;
13244
13245                               }
13246
13247                               ueIdxFound = true;
13248                               break;
13249                            }
13250                         }
13251                         if(ueIdxFound == true)
13252                         {
13253                            break;
13254                         }
13255                      }
13256                      if(!ueIdxFound)
13257                      {
13258                         DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
13259                         ret = RFAILED;
13260                      }
13261
13262
13263                      break;
13264                   }
13265                default :
13266                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
13267                         ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
13268                   break;
13269             }
13270          }
13271       }
13272    }
13273    if(ret != RFAILED)
13274    {
13275       duProcUeContextReleaseCommand(duUeCb);
13276    }
13277    freeAperDecodeUeContextReleaseCommand(f1apMsg);
13278    return ret;
13279 }
13280 /**************************************************************
13281  *
13282  * @brief Handles received F1AP message and sends back response
13283  *
13284  * @details
13285  *
13286  *    Function : F1APMsgHdlr
13287  *
13288  *    Functionality:
13289  *         - Decodes received F1AP control message
13290  *         - Prepares response message, encodes and sends to SCTP
13291  *
13292  * @params[in]
13293  * @return ROK     - success
13294  *         RFAILED - failure
13295  *
13296  * ****************************************************************/
13297 void F1APMsgHdlr(Buffer *mBuf)
13298 {
13299    int i =0;
13300    char *recvBuf =NULLP;
13301    MsgLen copyCnt =0;
13302    MsgLen recvBufLen =0;
13303    F1AP_PDU_t *f1apMsg =NULLP;
13304    asn_dec_rval_t rval; /* Decoder return value */
13305    F1AP_PDU_t f1apasnmsg ;
13306    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
13307    ODU_PRINT_MSG(mBuf, 0,0);
13308
13309    /* Copy mBuf into char array to decode it */
13310    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
13311    DU_ALLOC(recvBuf, (Size)recvBufLen);
13312
13313    if(recvBuf == NULLP)
13314    {
13315       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
13316       return;
13317    }
13318    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
13319    {
13320       DU_LOG("\nERROR   -->  F1AP : Failed while copying %d", copyCnt);
13321       return;
13322    }
13323
13324    printf("\nDEBUG   -->  F1AP : Received flat buffer to be decoded : ");
13325    for(i=0; i< recvBufLen; i++)
13326    {
13327       printf("%x",recvBuf[i]);
13328    }
13329
13330    /* Decoding flat buffer into F1AP messsage */
13331    f1apMsg = &f1apasnmsg;
13332    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
13333
13334    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
13335    DU_FREE(recvBuf, (Size)recvBufLen);
13336
13337    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
13338    {
13339       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
13340       return;
13341    }
13342    printf("\n");
13343    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13344
13345    switch(f1apMsg->present)
13346    {
13347       case F1AP_PDU_PR_successfulOutcome:
13348          {
13349             switch(f1apMsg->choice.successfulOutcome->value.present)
13350             {
13351                case SuccessfulOutcome__value_PR_ResetAcknowledge:
13352                   {
13353                      DU_LOG("\nINFO   -->  F1AP : F1ResetAcknowledge is received successfully ");
13354                      break;
13355                   }
13356                case SuccessfulOutcome__value_PR_F1SetupResponse:
13357                   {
13358 #ifndef ODU_TEST_STUB
13359                      procF1SetupRsp(f1apMsg);
13360 #endif
13361                      break;
13362                   }
13363
13364                case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
13365                   {
13366                      procF1GNBDUCfgUpdAck(f1apMsg);
13367                      break;
13368                   }
13369
13370                default:
13371                   {
13372                      DU_LOG("\nERROR  -->  F1AP : Invalid type of SuccessfulOutcome__value_PR_ResetAcknowledge [%d]",\
13373                            f1apMsg->choice.successfulOutcome->value.present);
13374                      return;
13375                   }
13376             }/* End of switch(successfulOutcome) */
13377             free(f1apMsg->choice.successfulOutcome);
13378             break;
13379          }
13380       case F1AP_PDU_PR_initiatingMessage:
13381          {
13382             switch(f1apMsg->choice.initiatingMessage->value.present)
13383             {
13384                case InitiatingMessage__value_PR_Reset:
13385                   {
13386                      procF1ResetReq(f1apMsg);
13387                      break;
13388                   }
13389                case InitiatingMessage__value_PR_DLRRCMessageTransfer:
13390                   {
13391                      procF1DlRrcMsgTrans(f1apMsg);
13392                      break;
13393                   }
13394                case InitiatingMessage__value_PR_UEContextSetupRequest:
13395                   {
13396                      procF1UeContextSetupReq(f1apMsg);
13397                      break;
13398                   }
13399                case InitiatingMessage__value_PR_UEContextModificationRequest:
13400                   {
13401                      procF1UeContextModificationReq(f1apMsg);
13402                      break;
13403                   }
13404                case InitiatingMessage__value_PR_UEContextReleaseCommand:
13405                   {
13406                       procF1UeContextReleaseCommand(f1apMsg);
13407                       break;
13408                   }
13409                default:
13410                   {
13411                      DU_LOG("\nERROR  -->  F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
13412                            f1apMsg->choice.initiatingMessage->value.present);
13413                      return;
13414                   }
13415             }/* End of switch(initiatingMessage) */
13416             free(f1apMsg->choice.initiatingMessage);
13417             break;
13418          }
13419
13420       default:
13421          {
13422             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
13423             return;
13424          }
13425          free(f1apMsg);
13426
13427    }/* End of switch(f1apMsg->present) */
13428
13429 } /* End of F1APMsgHdlr */
13430
13431 /**********************************************************************
13432   End of file
13433  **********************************************************************/