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=0, plmnidx=0, sliceLstIdx=0;
 960    uint8_t elementCnt=0, extensionCnt=0;
 961
 962    extensionCnt=IE_EXTENSION_LIST_COUNT;
 963    DU_ALLOC(*ieExtend,sizeof(ProtocolExtensionContainer_4624P3_t));
 964    if((*ieExtend) == NULLP)
 965    {
 966       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 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       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 976       return RFAILED;
 977    }
 978    for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
 979    {
 980       DU_ALLOC((*ieExtend)->list.array[plmnidx],\
 981             sizeof(ServedPLMNs_ItemExtIEs_t));
 982       if((*ieExtend)->list.array[plmnidx] == NULLP)
 983       {
 984          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 985          return RFAILED;
 986       }
 987    }
 988
 989    elementCnt = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].taiSliceSuppLst.numSupportedSlices;
 990    idx = 0;
 991    (*ieExtend)->list.array[idx]->id = ProtocolIE_ID_id_TAISliceSupportList;
 992    (*ieExtend)->list.array[idx]->criticality = Criticality_ignore;
 993    (*ieExtend)->list.array[idx]->extensionValue.present = \
 994    ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
 995    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 996       list.count = elementCnt;
 997    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 998       list.size = (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 999       list.count * sizeof(SliceSupportItem_t *);
1000
1001    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1002          list.array, elementCnt * sizeof(SliceSupportItem_t *));
1003    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1004          list.array == NULLP)
1005    {
1006       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1007       return RFAILED;
1008    }
1009
1010    for(sliceLstIdx =0; sliceLstIdx<elementCnt; sliceLstIdx++)
1011    {
1012       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1013             list.array[sliceLstIdx],sizeof(SliceSupportItem_t));
1014       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1015             list.array[sliceLstIdx] == NULLP)
1016       {
1017          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1018          return RFAILED;
1019       }
1020       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1021          list.array[sliceLstIdx]->sNSSAI.sST.size = sizeof(uint8_t);
1022       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
1023             .list.array[sliceLstIdx]->sNSSAI.sST.buf,(*ieExtend)->list.array[idx]->\
1024             extensionValue.choice.SliceSupportList.\
1025             list.array[sliceLstIdx]->sNSSAI.sST.size);
1026       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
1027             .list.array[sliceLstIdx]->sNSSAI.sST.buf == NULLP)
1028       {
1029          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1030          return RFAILED;
1031       }
1032       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1033          list.array[sliceLstIdx]->sNSSAI.sST.buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.\
1034          cellInfo.srvdPlmn[0].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
1035
1036       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1037             list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1038       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1039             list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
1040       {
1041          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1042          return RFAILED;
1043       }
1044       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1045          list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
1046       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1047             list.array[sliceLstIdx]->sNSSAI.sD->buf, (*ieExtend)->list.array[idx]->extensionValue.choice.\
1048             SliceSupportList.list.array[sliceLstIdx]->sNSSAI.sD->size);
1049       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1050             list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
1051       {
1052          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1053          return RFAILED;
1054       }
1055       memcpy((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1056       list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[0].duCellInfo.\
1057       cellInfo.srvdPlmn[0].taiSliceSuppLst.snssai[sliceLstIdx]->sd, (*ieExtend)->list.array[idx]->\
1058       extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->sNSSAI.sD->size);
1059    }
1060    return ROK;
1061 }
1062 /*******************************************************************
1063  *
1064  * @brief Builds Served PLMN
1065  *
1066  * @details
1067  *
1068  *    Function : BuildServedPlmn
1069  *
1070  *    Functionality: Building the Served PLMN
1071  *
1072  * @params[in] GNB_DU_Served_Cells_Item_t *srvCellItem
1073  * @return ROK     - success
1074  *         RFAILED - failure
1075  *
1076  * ****************************************************************/
1077 uint8_t  BuildServedPlmn(ServedPLMNs_List_t *srvplmn)
1078 {
1079    uint8_t  plmnidx;
1080    uint8_t  servPlmnCnt=1;
1081    uint8_t buildPlmnIdret=0;
1082    uint8_t BuildExtensionsret=0;
1083    srvplmn->list.count = servPlmnCnt;
1084    srvplmn->list.size = \
1085                         servPlmnCnt*sizeof(ServedPLMNs_Item_t *);
1086    DU_ALLOC(srvplmn->list.array,srvplmn->list.size);
1087    if(srvplmn->list.array == NULLP)
1088    {
1089       return RFAILED;
1090    }
1091    for(plmnidx=0; plmnidx<servPlmnCnt; plmnidx++)
1092    {
1093       DU_ALLOC(srvplmn->list.array[plmnidx],\
1094             sizeof(ServedPLMNs_Item_t));
1095       if(srvplmn->list.array[plmnidx] == NULLP)
1096       {
1097          return RFAILED;
1098       }
1099    }
1100    srvplmn->list.array[0]->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
1101    DU_ALLOC(srvplmn->list.array[0]->pLMN_Identity.buf, srvplmn->list.array[0]->pLMN_Identity.size);
1102    buildPlmnIdret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
1103          srvplmn->list.array[0]->pLMN_Identity.buf);
1104    if(buildPlmnIdret!= ROK)
1105    {
1106       return RFAILED;
1107    }
1108    BuildExtensionsret = BuildExtensions(&srvplmn->list.array[0]->iE_Extensions);
1109    if(BuildExtensionsret!= ROK)
1110    {
1111       return RFAILED;
1112    }
1113    return ROK;
1114 }
1115 /*******************************************************************
1116  *
1117  * @brief Builds Served Cell List
1118  *
1119  * @details
1120  *
1121  *    Function : BuildServedCellList
1122  *
1123  *    Functionality: Building Served Cell List
1124  *
1125  * @params[in] PLMNID plmn
1126  * @return ROK     - success
1127  *         RFAILED - failure
1128  *
1129  * ****************************************************************/
1130
1131 uint8_t BuildServedCellList(GNB_DU_Served_Cells_List_t *duServedCell)
1132 {
1133    uint8_t  BuildNrcgiret=0;
1134    uint8_t  BuildFiveGSTacret=0;
1135    uint8_t  BuildServedPlmnret=0;
1136    uint8_t  BuildNrModeret=0;
1137    uint8_t  idx;
1138    uint8_t  plmnidx;
1139    uint8_t  plmnCnt=1;
1140    GNB_DU_Served_Cells_Item_t *srvCellItem;
1141    duServedCell->list.size = plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t *);
1142    duServedCell->list.count = plmnCnt;
1143
1144    DU_ALLOC(duServedCell->list.array, duServedCell->list.size);
1145    if(duServedCell->list.array == NULLP)
1146    {
1147       return RFAILED;
1148    }
1149    for(plmnidx=0; plmnidx<plmnCnt; plmnidx++)
1150    {
1151       DU_ALLOC(duServedCell->list.array[plmnidx],\
1152             sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1153       if(duServedCell->list.array[plmnidx] == NULLP)
1154       {
1155          return RFAILED;
1156       }
1157    }
1158    idx = 0;
1159    duServedCell->list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_Served_Cells_Item;
1160    duServedCell->list.array[idx]->criticality = Criticality_reject;
1161    duServedCell->list.array[idx]->value.present = \
1162                                                   GNB_DU_Served_Cells_ItemIEs__value_PR_GNB_DU_Served_Cells_Item;
1163    srvCellItem = \
1164                  &duServedCell->list.array[idx]->value.choice.GNB_DU_Served_Cells_Item;
1165    /*nRCGI*/
1166    BuildNrcgiret = BuildNrcgi(&srvCellItem->served_Cell_Information.nRCGI);
1167    if(BuildNrcgiret != ROK)
1168    {
1169       return RFAILED;
1170    }
1171    /*nRPCI*/
1172    srvCellItem->served_Cell_Information.nRPCI = \
1173                                                 duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
1174
1175    /*fiveGS_TAC*/
1176    BuildFiveGSTacret = BuildFiveGSTac(&srvCellItem->served_Cell_Information);
1177    if(BuildFiveGSTacret != ROK)
1178    {
1179       return RFAILED;
1180    }
1181    /*Served PLMNs*/
1182    BuildServedPlmnret = BuildServedPlmn(&srvCellItem->served_Cell_Information.servedPLMNs);
1183    if(BuildServedPlmnret !=ROK)
1184    {
1185       return RFAILED;
1186    }
1187    /*nR Mode Info with FDD*/
1188    BuildNrModeret = BuildNrMode(&srvCellItem->served_Cell_Information.nR_Mode_Info);
1189    if(BuildNrModeret != ROK)
1190    {
1191       return RFAILED;
1192    }
1193    /*Measurement timing Config*/
1194    srvCellItem->served_Cell_Information.measurementTimingConfiguration.\
1195       size = sizeof(uint8_t);
1196    DU_ALLOC(srvCellItem->served_Cell_Information.\
1197          measurementTimingConfiguration.buf,srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1198    if(srvCellItem->served_Cell_Information.\
1199          measurementTimingConfiguration.buf == NULLP)
1200    {
1201       return RFAILED;
1202    }
1203    srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf[0] = \
1204                                                                                 duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
1205
1206    /* GNB DU System Information */
1207    DU_ALLOC(srvCellItem->gNB_DU_System_Information,
1208          sizeof(GNB_DU_System_Information_t));
1209    if(!srvCellItem->gNB_DU_System_Information)
1210    {
1211       return RFAILED;
1212    }
1213    /* MIB */
1214    srvCellItem->gNB_DU_System_Information->mIB_message.size = duCfgParam.srvdCellLst[0].duSysInfo.mibLen;
1215    DU_ALLOC(srvCellItem->gNB_DU_System_Information->mIB_message.buf,
1216          srvCellItem->gNB_DU_System_Information->mIB_message.size);
1217    if(!srvCellItem->gNB_DU_System_Information->mIB_message.buf)
1218    {
1219       return RFAILED;
1220    }
1221    memcpy(srvCellItem->gNB_DU_System_Information->mIB_message.buf, duCfgParam.srvdCellLst[0].duSysInfo.mibMsg, \
1222                    srvCellItem->gNB_DU_System_Information->mIB_message.size);
1223
1224    /* SIB1 */
1225    srvCellItem->gNB_DU_System_Information->sIB1_message.size =\
1226                                                               duCfgParam.srvdCellLst[0].duSysInfo.sib1Len;
1227
1228    DU_ALLOC(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,
1229          srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1230    if(!srvCellItem->gNB_DU_System_Information->sIB1_message.buf)
1231    {
1232       return RFAILED;
1233    }
1234    for(int x=0; x<srvCellItem->gNB_DU_System_Information->sIB1_message.size; x++)
1235    {
1236       srvCellItem->gNB_DU_System_Information->sIB1_message.buf[x]=\
1237                                                                   duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg[x];
1238    }
1239    return ROK;
1240 }
1241 /*******************************************************************
1242  *
1243  * @brief Builds RRC Version
1244  *
1245  * @details
1246  *
1247  *    Function : BuildRrcVer
1248  *
1249  *    Functionality: Building RRC Version
1250  *
1251  * @params[in] int idx,int elementCnt,RRC_Version_t *rrcver
1252  * @return ROK     - success
1253  *         RFAILED - failure
1254  *
1255  * ****************************************************************/
1256 uint8_t BuildRrcVer(RRC_Version_t *rrcVer)
1257 {
1258    uint8_t rrcExt;
1259    uint8_t rrcLatest;
1260    rrcVer->latest_RRC_Version.size = sizeof(uint8_t);
1261    DU_ALLOC(rrcVer->latest_RRC_Version.buf,sizeof(uint8_t));
1262    if(rrcVer->latest_RRC_Version.buf == NULLP)
1263    {
1264       return RFAILED;
1265    }
1266    rrcVer->latest_RRC_Version.buf[0] = 0;
1267    rrcVer->latest_RRC_Version.bits_unused = 5;
1268    DU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1269    if(rrcVer->iE_Extensions == NULLP)
1270    {
1271       return RFAILED;
1272    }
1273    rrcVer->iE_Extensions->list.count = 1;
1274    rrcVer->iE_Extensions->list.size = sizeof(RRC_Version_ExtIEs_t *);
1275    DU_ALLOC(rrcVer->iE_Extensions->list.array,rrcVer->iE_Extensions->list.size);
1276    if(rrcVer->iE_Extensions->list.array == NULLP)
1277    {
1278       return RFAILED;
1279    }
1280    rrcExt = 0;
1281    DU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
1282          sizeof(RRC_Version_ExtIEs_t));
1283    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
1284    {
1285       return RFAILED;
1286    }
1287    rrcVer->iE_Extensions->list.array[rrcExt]->id = \
1288                                                    ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
1289    rrcVer->iE_Extensions->list.array[rrcExt]->criticality = Criticality_reject;
1290    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.present =\
1291                                                                       RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
1292    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1293       .Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
1294    DU_ALLOC(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1295          .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1296          array[rrcExt]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1297    if(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1298          .Latest_RRC_Version_Enhanced.buf == NULLP)
1299    {
1300       return RFAILED;
1301    }
1302    rrcLatest = 0;
1303    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1304       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 15;
1305    rrcLatest++;
1306    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1307       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 5;
1308    rrcLatest++;
1309    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1310       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 0;
1311    return ROK;
1312 }
1313 /*******************************************************************
1314  *
1315  * @brief Sends F1 msg over SCTP
1316  *
1317  * @details
1318  *
1319  *    Function : sendF1APMsg
1320  *
1321  *    Functionality: Sends F1 msg over SCTP
1322  *
1323  * @params[in] Region region
1324  *             Pool pool
1325  * @return ROK     - success
1326  *         RFAILED - failure
1327  *
1328  * ****************************************************************/
1329 uint8_t sendF1APMsg()
1330 {
1331    Buffer *mBuf = NULLP;
1332
1333    if(ODU_GET_MSG_BUF(DU_APP_MEM_REGION, DU_POOL, &mBuf) == ROK)
1334    {
1335       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
1336       {
1337             ODU_PRINT_MSG(mBuf, 0,0);
1338
1339             if(sctpSend(mBuf, F1_INTERFACE) != ROK)
1340             {
1341                DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
1342                ODU_PUT_MSG_BUF(mBuf);
1343                return RFAILED;
1344             }
1345       }
1346       else
1347       {
1348          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
1349          ODU_PUT_MSG_BUF(mBuf);
1350          return RFAILED;
1351       }
1352       ODU_PUT_MSG_BUF(mBuf);
1353    }
1354    else
1355    {
1356       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
1357       return RFAILED;
1358    }
1359    return ROK;
1360 } /* sendF1APMsg */
1361
1362 /*******************************************************************
1363  *
1364  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1365  *
1366  * @details
1367  *
1368  *    Function :  FreeRrcVer
1369  *
1370  *    Functionality: deallocating the memory of function BuildRrcVer
1371  *
1372  * @params[in] RRC_Version_t *rrcVer
1373  *
1374  * @return void
1375  *
1376  *****************************************************************/
1377 void FreeRrcVer(RRC_Version_t *rrcVer)
1378 {
1379    if(rrcVer->latest_RRC_Version.buf != NULLP)
1380    {
1381       if(rrcVer->iE_Extensions != NULLP)
1382       {
1383          if(rrcVer->iE_Extensions->list.array != NULLP)
1384          {
1385             if(rrcVer->iE_Extensions->list.array[0] != NULLP)
1386             {
1387                if(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf
1388                      != NULLP)
1389                {
1390                   DU_FREE(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice\
1391                         .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1392                         array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1393                }
1394                DU_FREE(rrcVer->iE_Extensions->list.array[0],sizeof(RRC_Version_ExtIEs_t));
1395             }
1396             DU_FREE(rrcVer->iE_Extensions->list.array,sizeof(RRC_Version_ExtIEs_t*));
1397          }
1398          DU_FREE(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1399       }
1400       DU_FREE(rrcVer->latest_RRC_Version.buf,rrcVer->latest_RRC_Version.size);
1401    }
1402 }
1403 /*******************************************************************
1404  *
1405  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1406  *
1407  * @details
1408  *
1409  *    Function :  FreeServedCellList
1410  *
1411  *    Functionality:  deallocating the memory of function BuildServedCellList
1412
1413  *
1414  * @params[in] GNB_DU_Served_Cells_List_t *duServedCell
1415  *
1416  * @return void
1417  *
1418  * ****************************************************************/
1419 void FreeServedCellList( GNB_DU_Served_Cells_List_t *duServedCell)
1420 {
1421    uint8_t   plmnCnt=MAX_PLMN;
1422    uint8_t  extensionCnt=IE_EXTENSION_LIST_COUNT;
1423    uint8_t  plmnIdx=0, sliceIdx=0;
1424    GNB_DU_Served_Cells_Item_t *srvCellItem;
1425    ServedPLMNs_Item_t  *servedPlmnItem;
1426    SliceSupportItem_t  *sliceSupportItem;
1427
1428    if(duServedCell->list.array!=NULLP)
1429    {
1430       if(duServedCell->list.array[0]!=NULLP)
1431       {
1432          srvCellItem= &duServedCell->list.array[0]->value.choice.GNB_DU_Served_Cells_Item;
1433
1434          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1435                srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size * sizeof(uint8_t));
1436          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1437                srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size * sizeof(uint8_t));
1438
1439          if(srvCellItem->served_Cell_Information.fiveGS_TAC!=NULLP)
1440          {
1441             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
1442                   sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
1443             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,sizeof(FiveGS_TAC_t));
1444          }
1445
1446          if(srvCellItem->served_Cell_Information.servedPLMNs.list.array!=NULLP)
1447          {
1448             if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx] != NULLP)
1449             {
1450                servedPlmnItem = srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx];
1451                DU_FREE(servedPlmnItem->pLMN_Identity.buf, servedPlmnItem->pLMN_Identity.size);
1452
1453                if(servedPlmnItem->iE_Extensions != NULLP)
1454                {
1455                   if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1456                   {
1457                      if(servedPlmnItem->iE_Extensions->list.array[0] != NULLP)
1458                      {
1459                         if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1460                         SliceSupportList.list.array != NULLP)
1461                         {
1462                            for(sliceIdx =0; sliceIdx<servedPlmnItem->iE_Extensions->list.array[0]->\
1463                            extensionValue.choice.SliceSupportList.list.count; sliceIdx++)
1464                            {
1465                               if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1466                               SliceSupportList.list.array[sliceIdx] != NULLP)
1467                               {
1468                                  sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[0]->\
1469                                  extensionValue.choice.SliceSupportList.list.array[sliceIdx];
1470
1471                                  DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sizeof(uint8_t));
1472
1473                                  if(sliceSupportItem->sNSSAI.sD != NULLP)
1474                                  {
1475                                     DU_FREE(sliceSupportItem->sNSSAI.sD->buf,\
1476                                     sliceSupportItem->sNSSAI.sD->size);
1477                                     DU_FREE(sliceSupportItem->sNSSAI.sD, sizeof(OCTET_STRING_t));
1478                                  }
1479
1480                                  DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.\
1481                                  choice.SliceSupportList.list.array[sliceIdx], sizeof(SliceSupportItem_t));
1482                               }
1483                            }
1484                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1485                            SliceSupportList.list.array, servedPlmnItem->iE_Extensions->list.array[0]->\
1486                            extensionValue.choice.SliceSupportList.list.size);
1487                         }
1488                         DU_FREE(servedPlmnItem->iE_Extensions->list.array[0],\
1489                         sizeof(ServedPLMNs_ItemExtIEs_t));
1490                      }
1491                      DU_FREE(servedPlmnItem->iE_Extensions->list.array,\
1492                      extensionCnt*sizeof(ServedPLMNs_ItemExtIEs_t*));
1493                   }
1494                   DU_FREE(servedPlmnItem->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P3_t));
1495                }
1496                DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx],\
1497                sizeof(ServedPLMNs_Item_t));
1498             }
1499             DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array,\
1500             sizeof(ServedPLMNs_Item_t *));
1501          }
1502
1503          if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD != NULLP)
1504          {
1505             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
1506                   freqBandListNr.list.array != NULLP)
1507             {
1508                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
1509                uL_NRFreqInfo.freqBandListNr.list.array[0],sizeof(FreqBandNrItem_t));
1510                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
1511                uL_NRFreqInfo.freqBandListNr.list.array,sizeof(FreqBandNrItem_t*));
1512             }
1513
1514             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1515                   freqBandListNr.list.array)
1516             {
1517                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1518                      freqBandListNr.list.array[0],sizeof(FreqBandNrItem_t));
1519                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1520                      freqBandListNr.list.array,sizeof(FreqBandNrItem_t *));
1521             }
1522             DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD, sizeof(FDD_Info_t));
1523          }
1524
1525          DU_FREE(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1526                srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1527
1528          if(srvCellItem->gNB_DU_System_Information != NULLP)
1529          {
1530             if(srvCellItem->gNB_DU_System_Information->mIB_message.buf != NULLP)
1531             {
1532                DU_FREE(srvCellItem->gNB_DU_System_Information->mIB_message.buf,\
1533                      srvCellItem->gNB_DU_System_Information->mIB_message.size);
1534             }
1535
1536             if(srvCellItem->gNB_DU_System_Information->sIB1_message.buf != NULLP)
1537             {
1538                DU_FREE(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,\
1539                      srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1540             }
1541
1542             DU_FREE(srvCellItem->gNB_DU_System_Information, sizeof(GNB_DU_System_Information_t));
1543          }
1544
1545          DU_FREE(duServedCell->list.array[0], sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1546       }
1547       DU_FREE(duServedCell->list.array, plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t*));
1548    }
1549 }
1550
1551 /*******************************************************************
1552  *
1553  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1554  *
1555  * @details
1556  *
1557  *    Function :  FreeF1SetupReq
1558  *
1559  *    Functionality:  deallocating the memory of function BuildAndSendF1SetupReq
1560  *
1561  * @params[in] F1AP_PDU_t *f1apMsg
1562  *
1563  * @return void
1564  *
1565  * ****************************************************************/
1566 void FreeF1SetupReq(F1AP_PDU_t *f1apMsg)
1567 {
1568    uint8_t ieIdx, ieIdx2;
1569    F1SetupRequest_t *f1SetupReq=NULLP;
1570
1571    if(f1apMsg != NULLP)
1572    {
1573       if(f1apMsg->choice.initiatingMessage != NULLP)
1574       {
1575          f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1576          if(f1SetupReq->protocolIEs.list.array != NULLP)
1577          {
1578             for(ieIdx = 0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
1579             {
1580                if(f1SetupReq->protocolIEs.list.array[ieIdx] != NULLP)
1581                {
1582                   switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
1583                   {
1584                      case ProtocolIE_ID_id_TransactionID:
1585                         break;
1586                      case ProtocolIE_ID_id_gNB_DU_ID:
1587                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1588                               f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1589                         break;
1590                      case ProtocolIE_ID_id_gNB_DU_Name:
1591                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,\
1592                               strlen((char *)duCfgParam.duName));
1593                         break;
1594                      case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
1595                         FreeServedCellList(&f1SetupReq->protocolIEs.list.\
1596                               array[ieIdx]->value.choice.GNB_DU_Served_Cells_List);
1597                         break;
1598                      case ProtocolIE_ID_id_GNB_DU_RRC_Version:
1599                         FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version);
1600                         break;
1601                      default:
1602                         DU_LOG("\nERROR  -->  Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id);
1603                         break;
1604                   }
1605                }
1606             }
1607             for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++)
1608             {
1609                DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx2],sizeof(F1SetupRequestIEs_t));
1610             }
1611             DU_FREE(f1SetupReq->protocolIEs.list.array,\
1612                   f1SetupReq->protocolIEs.list.size);
1613          }
1614          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1615       }
1616       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1617    }
1618 }
1619 /*******************************************************************
1620  *
1621  * @brief Builds and Send the F1SetupRequest
1622  *
1623  * @details
1624  *
1625  *    Function : BuildAndSendF1SetupReq
1626  *
1627  * Functionality:Fills the F1SetupRequest
1628  *
1629  * @return ROK     - success
1630  *         RFAILED - failure
1631  *
1632  ******************************************************************/
1633 uint8_t BuildAndSendF1SetupReq()
1634 {
1635    uint8_t   ret, ieIdx, elementCnt;
1636    F1AP_PDU_t                 *f1apMsg = NULLP;
1637    F1SetupRequest_t           *f1SetupReq=NULLP;
1638    GNB_DU_Served_Cells_List_t *duServedCell=NULLP;
1639    RRC_Version_t              *rrcVer=NULLP;
1640    asn_enc_rval_t             encRetVal;        /* Encoder return value */
1641    ret= RFAILED;
1642
1643    DU_LOG("\nINFO   -->  F1AP : Building F1 Setup Request\n");
1644    do
1645    {
1646       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1647       if(f1apMsg == NULLP)
1648       {
1649          break;
1650       }
1651       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1652       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1653       if(f1apMsg->choice.initiatingMessage == NULLP)
1654       {
1655          break;
1656       }
1657       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_F1Setup;
1658       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
1659       f1apMsg->choice.initiatingMessage->value.present = \
1660                                                          InitiatingMessage__value_PR_F1SetupRequest;
1661
1662       f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1663
1664       elementCnt = (duCfgParam.duName != NULL) ? 5 : 4;
1665
1666       f1SetupReq->protocolIEs.list.count = elementCnt;
1667       f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t );
1668
1669       /* Initialize the F1Setup members */
1670       DU_ALLOC(f1SetupReq->protocolIEs.list.array,f1SetupReq->protocolIEs.list.size);
1671       if(f1SetupReq->protocolIEs.list.array == NULLP)
1672       {
1673          break;
1674       }
1675       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
1676       {
1677          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx],\
1678                sizeof(F1SetupRequestIEs_t));
1679          if(f1SetupReq->protocolIEs.list.array[ieIdx] == NULLP)
1680          {
1681             break;
1682          }
1683       }
1684
1685       ieIdx = 0;
1686       /*TransactionID*/
1687       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransactionID;
1688       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1689       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present =\
1690                                                                F1SetupRequestIEs__value_PR_TransactionID;
1691       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = \
1692                                                                              TRANS_ID;
1693
1694       /*DU ID*/
1695       ieIdx++;
1696       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
1697       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1698       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1699                                                                 F1SetupRequestIEs__value_PR_GNB_DU_ID;
1700       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size =\
1701                                                                              sizeof(uint8_t);
1702
1703       DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1704             f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1705       if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == \
1706             NULLP)
1707       {
1708          break;
1709       }
1710
1711       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] =\
1712          duCfgParam.duId;
1713
1714       /*DU Name*/
1715       if(duCfgParam.duName != NULL)
1716       {
1717          ieIdx++;
1718          f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_Name;
1719          f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
1720          f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = F1SetupRequestIEs__value_PR_GNB_DU_Name;
1721          f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.size =\
1722             strlen((char *)duCfgParam.duName);
1723          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.\
1724                GNB_DU_Name.buf, strlen((char *)duCfgParam.duName));
1725          if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.\
1726                buf == NULLP)
1727          {
1728             break;
1729          }
1730          strcpy((char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.\
1731                choice.GNB_DU_Name.buf,
1732                (char*)&duCfgParam.duName);
1733
1734       }
1735
1736       /*Served Cell list */
1737       ieIdx++;
1738       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1739                                                      ProtocolIE_ID_id_gNB_DU_Served_Cells_List;
1740       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1741       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1742                                                                 F1SetupRequestIEs__value_PR_GNB_DU_Served_Cells_List;
1743       duServedCell = &f1SetupReq->protocolIEs.list.\
1744                      array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
1745       if(BuildServedCellList(duServedCell))
1746       {
1747          break;
1748       }
1749       /*RRC Version*/
1750       ieIdx++;
1751       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1752                                                      ProtocolIE_ID_id_GNB_DU_RRC_Version ;
1753       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1754       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1755                                                                 F1SetupRequestIEs__value_PR_RRC_Version;
1756       rrcVer = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
1757       if(BuildRrcVer(rrcVer))
1758       {
1759          break;
1760       }
1761       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1762
1763       /* Encode the F1SetupRequest type as APER */
1764       memset(encBuf, 0, ENC_BUF_MAX_LEN);
1765       encBufSize = 0;
1766       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1767             encBuf);
1768
1769       /* Encode results */
1770       if(encRetVal.encoded == ENCODE_FAIL)
1771       {
1772          DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupRequest structure (at %s)\n",\
1773                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1774          break;
1775       }
1776       else
1777       {
1778          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1SetupRequest\n");
1779          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
1780          {
1781             printf("%x",encBuf[ieIdx]);
1782          }
1783       }
1784
1785       /* Sending msg */
1786       if(sendF1APMsg() != ROK)
1787       {
1788          DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup request failed");
1789          break;
1790       }
1791
1792       ret=ROK;
1793       break;
1794    }while(true);
1795
1796    FreeF1SetupReq(f1apMsg);
1797
1798    return ret;
1799 }/* End of BuildAndSendF1SetupReq */
1800
1801 /*******************************************************************
1802  *
1803  * @brief Deallocating memory allocated for Served_Cells_To_Modify_Item_t
1804  *
1805  * @details
1806  *
1807  *    Function : freeCellsToModifyItem
1808  *
1809  *    Functionality: Deallocating memory of variables allocated in
1810  *                    BuildAndSendDUConfigUpdate function
1811  *
1812  * @params[in]  Served_Cells_To_Modify_Item_t *modifyItem
1813  *
1814  * @return ROK     - void
1815  *
1816  * ****************************************************************/
1817
1818 void freeCellsToModifyItem(Served_Cells_To_Modify_Item_t *modifyItem)
1819 {
1820    uint8_t arrIdx=0, servedPlmnIdx=0, sliceLstIdx=0;
1821    ServedPLMNs_Item_t *servedPlmnItem = NULLP;
1822    SliceSupportItem_t *sliceSupportItem = NULLP;
1823
1824    DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf, modifyItem->oldNRCGI.pLMN_Identity.size);
1825    DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf, modifyItem->oldNRCGI.nRCellIdentity.size);
1826
1827    DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1828            modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
1829    DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1830          modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
1831
1832    if(modifyItem->served_Cell_Information.servedPLMNs.list.array != NULLP)
1833    {
1834       if(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx] != NULLP)
1835       {
1836          servedPlmnItem = modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx];
1837
1838          DU_FREE(servedPlmnItem->pLMN_Identity.buf,servedPlmnItem->pLMN_Identity.size);
1839
1840          if(servedPlmnItem->iE_Extensions != NULLP)
1841          {
1842             if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1843             {
1844                if(servedPlmnItem->iE_Extensions->list.array[arrIdx] != NULLP)
1845                {
1846                   if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1847                         list.array != NULLP)
1848                   {
1849                      for(sliceLstIdx =0; sliceLstIdx<servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
1850                            extensionValue.choice.SliceSupportList.list.count; sliceLstIdx++)
1851                      {
1852                         if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1853                               list.array[sliceLstIdx] != NULLP)
1854                         {
1855
1856                            sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1857                                               SliceSupportList.list.array[sliceLstIdx];
1858
1859                            DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sliceSupportItem->sNSSAI.sST.size);
1860                            if(sliceSupportItem->sNSSAI.sD != NULLP)
1861                            {
1862                               DU_FREE(sliceSupportItem->sNSSAI.sD->buf, sliceSupportItem->sNSSAI.sD->size);
1863                               DU_FREE(sliceSupportItem->sNSSAI.sD,sizeof(OCTET_STRING_t));
1864                            }
1865                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1866                                  SliceSupportList.list.array[sliceLstIdx], sizeof(SliceSupportItem_t));
1867                         }
1868                      }
1869                      DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.\
1870                            choice.SliceSupportList.list.array,\
1871                            servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
1872                            extensionValue.choice.SliceSupportList.list.size);
1873                   }
1874                }
1875                for(servedPlmnIdx=0; servedPlmnIdx< servedPlmnItem->iE_Extensions->list.count ; servedPlmnIdx++)
1876                {
1877                   DU_FREE(servedPlmnItem->iE_Extensions->list.array[servedPlmnIdx], sizeof(ServedPLMNs_ItemExtIEs_t ));
1878                }
1879                DU_FREE(servedPlmnItem->iE_Extensions->list.array, servedPlmnItem->iE_Extensions->list.size);
1880             }
1881             DU_FREE(servedPlmnItem->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1882          }
1883       }
1884       for(servedPlmnIdx=0; servedPlmnIdx<modifyItem->served_Cell_Information.servedPLMNs.list.count; servedPlmnIdx++)
1885       {
1886          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[servedPlmnIdx], sizeof(ServedPLMNs_Item_t));
1887       }
1888       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1889          modifyItem->served_Cell_Information.servedPLMNs.list.size);
1890    }
1891
1892    if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD != NULLP)
1893    {
1894       if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1895       {
1896          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
1897                array[arrIdx], sizeof(FreqBandNrItem_t));
1898          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array, \
1899                modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1900       }
1901
1902       if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1903       {
1904          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.\
1905              array[arrIdx], sizeof(FreqBandNrItem_t));
1906          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,\
1907                modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1908       }
1909       DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD,sizeof(FDD_Info_t));
1910    }
1911
1912    DU_FREE(modifyItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1913       modifyItem->served_Cell_Information.measurementTimingConfiguration.size);
1914 }
1915
1916 /*******************************************************************
1917  *
1918  * @brief Deallocating memory of BuildAndSendDUConfigUpdate
1919  *
1920  * @details
1921  *
1922  *    Function : FreeDUConfigUpdate
1923  *
1924  *    Functionality: Deallocating memory of variables allocated in
1925  *                    BuildAndSendDUConfigUpdate function
1926  *
1927  * @params[in]  F1AP_PDU_t *f1apDuCfg
1928  *
1929  * @return ROK     - void
1930  *
1931  * ****************************************************************/
1932 void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg)
1933 {
1934    uint8_t  ieIdx=0, cellModifyIdx=0, cellDeleteIdx=0;
1935    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
1936    Served_Cells_To_Modify_List_t  *cellsToModify=NULLP;
1937    Served_Cells_To_Delete_List_t  *cellsToDelete=NULLP;
1938    Served_Cells_To_Delete_Item_t  *deleteItem = NULLP;
1939    Served_Cells_To_Delete_ItemIEs_t *deleteItemIe = NULLP;
1940
1941    if(f1apDuCfg != NULLP)
1942    {
1943       if(f1apDuCfg->choice.initiatingMessage != NULLP)
1944       {
1945          duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->\
1946                        value.choice.GNBDUConfigurationUpdate;
1947          if(duCfgUpdate->protocolIEs.list.array != NULLP)
1948          {
1949             for(ieIdx=0; ieIdx<duCfgUpdate->protocolIEs.list.count; ieIdx++)
1950             {
1951                if(duCfgUpdate->protocolIEs.list.array[ieIdx] != NULLP)
1952                {
1953                   switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
1954                   {
1955                      case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
1956                         {
1957                            cellsToModify = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1958                                            value.choice.Served_Cells_To_Modify_List;
1959                            if(cellsToModify->list.array != NULLP)
1960                            {
1961                               for(cellModifyIdx=0; cellModifyIdx<cellsToModify->list.count ;cellModifyIdx++)
1962                               {
1963                                  if(cellsToModify->list.array[cellModifyIdx] != NULLP)
1964                                  {
1965                                     freeCellsToModifyItem(&cellsToModify->list.array[cellModifyIdx]->value.choice.\
1966                                           Served_Cells_To_Modify_Item);
1967                                     DU_FREE(cellsToModify->list.array[cellModifyIdx],\
1968                                           sizeof(Served_Cells_To_Modify_ItemIEs_t));
1969                                  }
1970                               }
1971                               DU_FREE(cellsToModify->list.array,cellsToModify->list.size);
1972                            }
1973                            break;
1974                         }
1975                      case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
1976                         {
1977                            cellsToDelete = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1978                                            value.choice.Served_Cells_To_Delete_List;
1979                            if(cellsToDelete->list.array != NULLP)
1980                            {
1981                               for(cellDeleteIdx=0; cellDeleteIdx<cellsToDelete->list.count ;cellDeleteIdx++)
1982                               {
1983                                  if(cellsToDelete->list.array[cellDeleteIdx] != NULLP)
1984                                  {
1985                                     deleteItemIe = ((Served_Cells_To_Delete_ItemIEs_t*)\
1986                                           cellsToDelete->list.array[cellDeleteIdx]);
1987                                     deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
1988                                     DU_FREE(deleteItem->oldNRCGI.pLMN_Identity.buf,\
1989                                           deleteItem->oldNRCGI.pLMN_Identity.size);
1990                                     DU_FREE(deleteItem->oldNRCGI.nRCellIdentity.buf,\
1991                                           deleteItem->oldNRCGI.nRCellIdentity.size);
1992                                     DU_FREE(cellsToDelete->list.array[cellDeleteIdx],\
1993                                           sizeof(Served_Cells_To_Delete_ItemIEs_t));
1994                                  }
1995                               }
1996                               DU_FREE(cellsToDelete->list.array,cellsToDelete->list.size);
1997                            }
1998
1999                            break;
2000                         }
2001                      case ProtocolIE_ID_id_gNB_DU_ID:
2002                         {
2003                            DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2004                                  duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2005                            break;
2006                         }
2007                   }
2008                   DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx],\
2009                         sizeof(GNBDUConfigurationUpdateIEs_t));
2010                }
2011             }
2012             DU_FREE(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2013          }
2014          DU_FREE(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2015       }
2016       DU_FREE(f1apDuCfg, (Size)sizeof(F1AP_PDU_t));
2017    }
2018 }
2019
2020 /*******************************************************************
2021  *
2022  * @brief Fills Served Plmns required in ServCellInfo IE
2023  *
2024  * @details
2025  *
2026  *    Function : fillServedPlmns
2027  *
2028  *    Functionality: Fills Served Plmns required in ServCellInfo IE
2029  *
2030  * @params[in] Pointer to ServedPLMNs_List_t *
2031  *
2032  * @return ROK     - success
2033  *         RFAILED - failure
2034  *
2035  *****************************************************************/
2036
2037 uint8_t fillServedPlmns(ServedPLMNs_List_t *servedPlmn)
2038 {
2039    uint8_t ieIdx=0, arrayIdx=0, ieListCnt=0, elementCnt=0, sliceLstIdx=0;
2040
2041    servedPlmn->list.array[arrayIdx]->pLMN_Identity.size = 3*sizeof(uint8_t);
2042    DU_ALLOC(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf, servedPlmn->list.\
2043          array[arrayIdx]->pLMN_Identity.size);
2044    if(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf == NULLP)
2045    {
2046       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2047       return RFAILED;
2048    }
2049    buildPlmnId(duCfgParam.srvdCellLst[arrayIdx].duCellInfo.cellInfo.srvdPlmn[arrayIdx].plmn,\
2050          servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf);
2051    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
2052    if(servedPlmn->list.array[arrayIdx]->iE_Extensions == NULLP)
2053    {
2054       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2055       return RFAILED;
2056    }
2057
2058    ieListCnt=1;
2059    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.count = ieListCnt;
2060    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.size = ieListCnt *sizeof(ServedPLMNs_ItemExtIEs_t *);
2061    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array,servedPlmn->list.array[arrayIdx]->\
2062          iE_Extensions->list.size);
2063    if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array == NULLP)
2064    {
2065       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2066       return RFAILED;
2067    }
2068    for(ieIdx=arrayIdx;ieIdx<ieListCnt;ieIdx++)
2069    {
2070       DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx],\
2071             sizeof(ServedPLMNs_ItemExtIEs_t));
2072       if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx] == NULLP)
2073       {
2074          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2075          return RFAILED;
2076       }
2077    }
2078
2079    ieIdx = 0;
2080    elementCnt = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].taiSliceSuppLst.numSupportedSlices;
2081    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->id =ProtocolIE_ID_id_TAISliceSupportList;
2082    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->criticality = Criticality_ignore;
2083    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.present = \
2084    ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
2085    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2086       list.count = elementCnt;
2087    servedPlmn->list.array[arrayIdx]->\
2088       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2089       list.size = elementCnt * sizeof(SliceSupportItem_t *);
2090    DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2091          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2092          list.array,servedPlmn->list.array[arrayIdx]->\
2093          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.size);
2094    if(servedPlmn->list.array[arrayIdx]->\
2095          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2096          list.array == NULLP)
2097    {
2098       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2099       return RFAILED;
2100    }
2101
2102    for(sliceLstIdx =0; sliceLstIdx< elementCnt; sliceLstIdx++)
2103    {
2104       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2105       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2106       list.array[sliceLstIdx],sizeof( SliceSupportItem_t));
2107       if(servedPlmn->list.array[arrayIdx]->\
2108       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2109       list.array[sliceLstIdx] == NULLP)
2110       {
2111          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2112          return RFAILED;
2113       }
2114
2115       servedPlmn->list.array[arrayIdx]->\
2116       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2117       list.array[sliceLstIdx]->sNSSAI.sST.size = sizeof(uint8_t);
2118       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2119       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2120       list.array[sliceLstIdx]->sNSSAI.sST.buf,servedPlmn->list.array[arrayIdx]->\
2121       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->\
2122       sNSSAI.sST.size);
2123
2124       if(servedPlmn->list.array[arrayIdx]->\
2125       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2126       list.array[sliceLstIdx]->sNSSAI.sST.buf == NULLP)
2127       {
2128          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2129          return RFAILED;
2130       }
2131       servedPlmn->list.array[arrayIdx]->\
2132       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2133       list.array[sliceLstIdx]->sNSSAI.sST.buf[arrayIdx] =  duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
2134       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
2135
2136       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2137       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2138       list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
2139       if(servedPlmn->list.array[arrayIdx]->\
2140       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2141       list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
2142       {
2143          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2144          return RFAILED;
2145       }
2146       servedPlmn->list.array[arrayIdx]->\
2147       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2148       list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
2149       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2150       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2151       list.array[sliceLstIdx]->sNSSAI.sD->buf,servedPlmn->list.array[arrayIdx]->\
2152       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2153       list.array[sliceLstIdx]->sNSSAI.sD->size);
2154       if(servedPlmn->list.array[arrayIdx]->\
2155       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2156       list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
2157       {
2158          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2159          return RFAILED;
2160       }
2161       memcpy(servedPlmn->list.array[arrayIdx]->\
2162       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2163       list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
2164       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sd,\
2165       servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2166       list.array[sliceLstIdx]->sNSSAI.sD->size);
2167    }
2168    return ROK;
2169 }
2170
2171 /*******************************************************************
2172  *
2173  * @brief Fills Nr Fdd Info required in ServCellInfo IE
2174  *
2175  * @details
2176  *
2177  *    Function : fillNrFddInfo
2178  *
2179  *    Functionality: Fills Nr Fdd Info required in ServCellInfo IE
2180  *
2181  * @params[in] Pointer to NR_Mode_Info_t *
2182  *
2183  * @return ROK     - success
2184  *         RFAILED - failure
2185  *
2186  *****************************************************************/
2187
2188 uint8_t fillNrFddInfo(NR_Mode_Info_t *nrFdd)
2189 {
2190    nrFdd->choice.fDD->uL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.\
2191       f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn;
2192    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.count = 1;
2193    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t*);
2194    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
2195          array, nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size);
2196    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2197    {
2198       return RFAILED;
2199    }
2200    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0], \
2201       sizeof(FreqBandNrItem_t));
2202    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2203    {
2204       return RFAILED;
2205    }
2206    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2207       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
2208       freqBand[0].nrFreqBand;
2209    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2210    nrFdd->choice.fDD->dL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.\
2211       dlNrFreqInfo.nrArfcn;
2212    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.count = 1;
2213    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
2214    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,nrFdd->\
2215          choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
2216    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2217    {
2218       return RFAILED;
2219    }
2220    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0],\
2221          sizeof(FreqBandNrItem_t));
2222    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2223    {
2224       return RFAILED;
2225    }
2226    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2227       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
2228       freqBand[0].nrFreqBand;
2229    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2230
2231    /*Transmission Bandwidth*/
2232    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2233       f1Mode.mode.fdd.ulTxBw.nrScs;
2234    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2235       f1Mode.mode.fdd.ulTxBw.nrb;
2236    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2237       f1Mode.mode.fdd.dlTxBw.nrScs;
2238    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2239       f1Mode.mode.fdd.dlTxBw.nrb;
2240
2241    return ROK;
2242 }
2243
2244 /*******************************************************************
2245  *
2246  * @brief Fills ServCellInfo IE
2247  *
2248  * @details
2249  *
2250  *    Function : fillServedCellInfo
2251  *
2252  *    Functionality: Fills ServCellInfo
2253  *
2254  * @params[in] Pointer to Served_Cell_Information_t *
2255  *
2256  * @return ROK     - success
2257  *         RFAILED - failure
2258  *
2259  *****************************************************************/
2260
2261 uint8_t fillServedCellInfo(Served_Cell_Information_t *srvCellInfo)
2262 {
2263    uint8_t tmp, ieIdx, ieListCnt;
2264
2265    /*nRCGI*/
2266    srvCellInfo->nRCGI.pLMN_Identity.size =3*sizeof(uint8_t);
2267    DU_ALLOC(srvCellInfo->nRCGI.pLMN_Identity.buf,\
2268          srvCellInfo->nRCGI.pLMN_Identity.size);
2269    if(srvCellInfo->nRCGI.pLMN_Identity.buf == NULLP)
2270    {
2271       return RFAILED;
2272    }
2273    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2274          srvCellInfo->nRCGI.pLMN_Identity.buf);
2275    srvCellInfo->nRCGI.nRCellIdentity.size =5*sizeof(uint8_t);
2276    DU_ALLOC(srvCellInfo->nRCGI.nRCellIdentity.buf,\
2277          srvCellInfo->nRCGI.nRCellIdentity.size);
2278    if(srvCellInfo->nRCGI.nRCellIdentity.buf == NULLP)
2279    {
2280       return RFAILED;
2281    }
2282    for (tmp = 0 ; tmp < srvCellInfo->\
2283          nRCGI.nRCellIdentity.size-1 ; tmp++)
2284    {
2285       srvCellInfo->nRCGI.nRCellIdentity.buf[tmp] = 0;
2286    }
2287    srvCellInfo->nRCGI.nRCellIdentity.buf[4] = 16;
2288    srvCellInfo->nRCGI.nRCellIdentity.bits_unused =4;
2289
2290    /*nRPCI*/
2291    srvCellInfo->nRPCI = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
2292
2293    /*servedPLMNs*/
2294    ieListCnt = 1;
2295    srvCellInfo->servedPLMNs.list.count = ieListCnt;
2296    srvCellInfo->servedPLMNs.list.size = ieListCnt*sizeof(ServedPLMNs_Item_t *);
2297    DU_ALLOC(srvCellInfo->servedPLMNs.list.array,\
2298          srvCellInfo->servedPLMNs.list.size);
2299    if(srvCellInfo->servedPLMNs.list.array == NULLP)
2300    {
2301       return RFAILED;
2302    }
2303    for(ieIdx=0; ieIdx < ieListCnt; ieIdx++)
2304    {
2305       DU_ALLOC(srvCellInfo->servedPLMNs.list.array[ieIdx],\
2306             sizeof(ServedPLMNs_Item_t));
2307       if(srvCellInfo->servedPLMNs.list.array[ieIdx]== NULLP)
2308       {
2309          return RFAILED;
2310       }
2311    }
2312    if(fillServedPlmns(&srvCellInfo->servedPLMNs))
2313    {
2314       return RFAILED;
2315    }
2316
2317    /*nR Mode Info with FDD*/
2318    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_fDD;
2319    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.fDD,\
2320          sizeof(FDD_Info_t));
2321    if(srvCellInfo->nR_Mode_Info.choice.fDD == NULLP)
2322    {
2323       return RFAILED;
2324    }
2325    if(fillNrFddInfo(&srvCellInfo->nR_Mode_Info))
2326       return RFAILED;
2327
2328    /*Measurement timing Config*/
2329    srvCellInfo->measurementTimingConfiguration.size = sizeof(uint8_t);
2330    DU_ALLOC(srvCellInfo->measurementTimingConfiguration.\
2331          buf,srvCellInfo->measurementTimingConfiguration.size);
2332    if(srvCellInfo->measurementTimingConfiguration.buf == NULLP)
2333    {
2334       return RFAILED;
2335    }
2336    srvCellInfo->measurementTimingConfiguration.\
2337          buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
2338
2339    return ROK;
2340 }
2341
2342 /*******************************************************************
2343  *
2344  * @brief Fills ServCellToModItem IE
2345  *
2346  * @details
2347  *
2348  *    Function : fillServCellToModItem
2349  *
2350  *    Functionality: Fills ServCellToModItem IE
2351  *
2352  * @params[in] Pointer to Served_Cells_To_Modify_Item_t *
2353  *
2354  * @return ROK     - success
2355  *         RFAILED - failure
2356  *
2357  *****************************************************************/
2358
2359 uint8_t fillServCellToModItem(Served_Cells_To_Modify_Item_t *modifyItem)
2360 {
2361    uint8_t ieIdx;
2362
2363    /*pLMN_Identity*/
2364    modifyItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2365    DU_ALLOC(modifyItem->oldNRCGI.pLMN_Identity.buf,modifyItem->oldNRCGI.pLMN_Identity.size);
2366    if(modifyItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2367    {
2368       return RFAILED;
2369    }
2370    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2371          modifyItem->oldNRCGI.pLMN_Identity.buf);
2372
2373    /*nRCellIdentity*/
2374    modifyItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2375    DU_ALLOC(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2376          modifyItem->oldNRCGI.nRCellIdentity.size);
2377    if(modifyItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2378    {
2379       return RFAILED;
2380    }
2381    for(ieIdx = 0; ieIdx < modifyItem->oldNRCGI.nRCellIdentity.size-1; ieIdx++)
2382    {
2383       modifyItem->oldNRCGI.nRCellIdentity.buf[ieIdx] = 0;
2384    }
2385    modifyItem->oldNRCGI.nRCellIdentity.buf[4] = 16;
2386    modifyItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
2387
2388    if(fillServedCellInfo(&modifyItem->served_Cell_Information))
2389       return RFAILED;
2390    else
2391       return ROK;
2392 }
2393
2394 /*******************************************************************
2395  *
2396  * @brief Builds ServCellToModList
2397  *
2398  * @details
2399  *
2400  *    Function : buildServCellToModList
2401  *
2402  *    Functionality: Builds the serv cell to Mod List
2403  *
2404  * @params[in] Pointer to Served_Cells_To_Modify_List_t *
2405  *
2406  * @return ROK     - success
2407  *         RFAILED - failure
2408  *
2409  *****************************************************************/
2410
2411 uint8_t buildServCellToModList(Served_Cells_To_Modify_List_t *cellsToModify)
2412 {
2413    uint8_t ieListCnt, ieIdx;
2414    Served_Cells_To_Modify_Item_t *modifyItem = NULLP;
2415
2416    ieListCnt = 1;
2417    cellsToModify->list.count = ieListCnt;
2418    cellsToModify->list.size = ieListCnt*sizeof(Served_Cells_To_Modify_ItemIEs_t *);
2419    DU_ALLOC(cellsToModify->list.array,cellsToModify->list.size);
2420    if(cellsToModify->list.array == NULLP)
2421    {
2422       return RFAILED;
2423    }
2424    for(ieIdx=0; ieIdx< ieListCnt; ieIdx++)
2425    {
2426       DU_ALLOC(cellsToModify->list.array[ieIdx],sizeof(Served_Cells_To_Modify_ItemIEs_t));
2427       if(cellsToModify->list.array[ieIdx] == NULLP)
2428       {
2429          return RFAILED;
2430       }
2431    }
2432    cellsToModify->list.array[0]->id = ProtocolIE_ID_id_Served_Cells_To_Modify_Item;
2433    cellsToModify->list.array[0]->criticality = Criticality_reject;
2434    cellsToModify->list.array[0]->value.present =\
2435       Served_Cells_To_Modify_ItemIEs__value_PR_Served_Cells_To_Modify_Item;
2436    modifyItem=&cellsToModify->list.array[0]->value.choice.Served_Cells_To_Modify_Item;
2437
2438    if(fillServCellToModItem(modifyItem))
2439       return RFAILED;
2440    else
2441       return ROK;
2442 }
2443 /*******************************************************************
2444  *
2445  * @brief filling the DeleteItemList
2446  *
2447  * @details
2448  *
2449  *    Function : fillCellToDeleteItem
2450  *
2451  *    Functionality: Filling the DeleteItemIe
2452  *
2453  * @params[in] Pointer to Served_Cells_To_Delete_ItemIEs_t
2454  *
2455  * @return ROK     - success
2456  *         RFAILED - failure
2457  *
2458  *****************************************************************/
2459 uint8_t fillCellToDeleteItem(struct Served_Cells_To_Delete_ItemIEs *deleteItemIe)
2460 {
2461    uint8_t arrIdx;
2462    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
2463
2464    deleteItemIe->id = ProtocolIE_ID_id_Served_Cells_To_Delete_Item;
2465    deleteItemIe->criticality = Criticality_reject;
2466    deleteItemIe->value.present =\
2467    Served_Cells_To_Delete_ItemIEs__value_PR_Served_Cells_To_Delete_Item;
2468    deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
2469
2470    /*pLMN_Identity*/
2471    deleteItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2472    DU_ALLOC(deleteItem->oldNRCGI.pLMN_Identity.buf,deleteItem->oldNRCGI.pLMN_Identity.size);
2473    if(deleteItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2474    {
2475       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2476       return RFAILED;
2477    }
2478    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2479          deleteItem->oldNRCGI.pLMN_Identity.buf);
2480
2481    /*nRCellIdentity*/
2482    deleteItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2483    DU_ALLOC(deleteItem->oldNRCGI.nRCellIdentity.buf,\
2484          deleteItem->oldNRCGI.nRCellIdentity.size);
2485    if(deleteItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2486    {
2487       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2488       return RFAILED;
2489    }
2490    for(arrIdx = 0; arrIdx < deleteItem->oldNRCGI.nRCellIdentity.size-1; arrIdx++)
2491    {
2492       deleteItem->oldNRCGI.nRCellIdentity.buf[arrIdx] = 0;
2493    }
2494    deleteItem->oldNRCGI.nRCellIdentity.buf[4] = 16;
2495    deleteItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
2496    return ROK;
2497 }
2498 /*******************************************************************
2499  *
2500  * @brief Builds ServCellToDeleteList
2501  *
2502  * @details
2503  *
2504  *    Function : buildServCellToDeleteList
2505  *
2506  *    Functionality: Builds the serv cell to delete List
2507  *
2508  * @params[in] Pointer to Served_Cells_To_Delete_List_t *
2509  *
2510  * @return ROK     - success
2511  *         RFAILED - failure
2512  *
2513  *****************************************************************/
2514
2515 uint8_t buildServCellToDeleteList(Served_Cells_To_Delete_List_t *cellsToDelete)
2516 {
2517    uint8_t ieListCnt, arrIdx;
2518
2519    ieListCnt = 1;
2520    cellsToDelete->list.count = ieListCnt;
2521    cellsToDelete->list.size = ieListCnt*sizeof(Served_Cells_To_Delete_ItemIEs_t *);
2522
2523    DU_ALLOC(cellsToDelete->list.array,cellsToDelete->list.size);
2524    if(cellsToDelete->list.array == NULLP)
2525    {
2526       DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2527       return RFAILED;
2528    }
2529
2530    for(arrIdx=0; arrIdx< ieListCnt; arrIdx++)
2531    {
2532       DU_ALLOC(cellsToDelete->list.array[arrIdx],sizeof(Served_Cells_To_Delete_ItemIEs_t));
2533       if(cellsToDelete->list.array[arrIdx] == NULLP)
2534       {
2535          DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2536          return RFAILED;
2537       }
2538    }
2539
2540    arrIdx=0;
2541    if(fillCellToDeleteItem((Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx]) !=ROK)
2542    {
2543       DU_LOG("\nERROR  -->  F1AP: buildServCellToDeleteList(): failed to fill Served_Cells_To_Delete_ItemIEs");
2544       return RFAILED;
2545    }
2546    return ROK;
2547 }
2548
2549 /*******************************************************************
2550  *
2551  * @brief Builds and sends the DUConfigUpdate
2552  *
2553  * @details
2554  *
2555  *    Function : BuildAndSendDUConfigUpdate
2556  *
2557  *    Functionality: Constructs the DU Update message and sends
2558  *                   it to the CU through SCTP.
2559  *
2560  * @params[in] void **buf,Buffer to which encoded pattern is written into
2561  * @params[in] int *size,size of buffer
2562  *
2563  * @return ROK     - success
2564  *         RFAILED - failure
2565  *
2566  * ****************************************************************/
2567 uint8_t BuildAndSendDUConfigUpdate(ServCellAction servCellAction)
2568 {
2569    uint8_t ret =0, ieIdx=0, elementCnt=0;
2570    bool memAlloctionFailure = false;
2571    F1AP_PDU_t                 *f1apDuCfg = NULLP;
2572    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
2573    asn_enc_rval_t encRetVal;     /* Encoder return value */
2574
2575    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2576    ret= RFAILED;
2577
2578    while(true)
2579    {
2580       DU_LOG("\nINFO   -->  F1AP : Building DU config update\n");
2581       /* Allocate the memory for F1DuCfg */
2582       DU_ALLOC(f1apDuCfg, sizeof(F1AP_PDU_t));
2583       if(f1apDuCfg == NULLP)
2584       {
2585          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2586          break;
2587       }
2588
2589       f1apDuCfg->present = F1AP_PDU_PR_initiatingMessage;
2590       DU_ALLOC(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2591       if(f1apDuCfg->choice.initiatingMessage == NULLP)
2592       {
2593          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2594          break;
2595       }
2596
2597       f1apDuCfg->choice.initiatingMessage->procedureCode = \
2598                                                            ProcedureCode_id_gNBDUConfigurationUpdate;
2599       f1apDuCfg->choice.initiatingMessage->criticality = Criticality_reject;
2600       f1apDuCfg->choice.initiatingMessage->value.present = \
2601                                                            InitiatingMessage__value_PR_GNBDUConfigurationUpdate;
2602       duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\
2603                     choice.GNBDUConfigurationUpdate;
2604       elementCnt = 3;
2605       duCfgUpdate->protocolIEs.list.count = elementCnt;
2606       duCfgUpdate->protocolIEs.list.size = \
2607                                            elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t*);
2608
2609       /* Initialize the F1Setup members */
2610       DU_ALLOC(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2611       if(duCfgUpdate->protocolIEs.list.array == NULLP)
2612       {
2613          DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2614          break;
2615       }
2616       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
2617       {
2618          DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx],sizeof(GNBDUConfigurationUpdateIEs_t));
2619          if(duCfgUpdate->protocolIEs.list.array[ieIdx] == NULLP)
2620          {
2621             DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2622             memAlloctionFailure = true;
2623             break;
2624          }
2625       }
2626
2627       if(memAlloctionFailure == true)
2628       {
2629          break;
2630       }
2631       /*TransactionID*/
2632       ieIdx = 0;
2633       duCfgUpdate->protocolIEs.list.array[ieIdx]->id=ProtocolIE_ID_id_TransactionID;
2634       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
2635       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2636       GNBDUConfigurationUpdateIEs__value_PR_TransactionID;
2637       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = TRANS_ID;
2638
2639       ieIdx++;
2640       if(servCellAction == SERV_CELL_TO_MODIFY)
2641       {
2642          /*Served Cell to Modify */
2643          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2644          ProtocolIE_ID_id_Served_Cells_To_Modify_List;
2645          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2646          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2647          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Modify_List;
2648          if(buildServCellToModList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2649                   Served_Cells_To_Modify_List))
2650          {
2651             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToModList");
2652             break;
2653          }
2654       }
2655       else
2656       {
2657          /*Served Cell to Delete */
2658          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2659          ProtocolIE_ID_id_Served_Cells_To_Delete_List;
2660          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2661          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2662          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Delete_List;
2663          if(buildServCellToDeleteList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2664          Served_Cells_To_Delete_List)!=ROK)
2665          {
2666             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToDeleteList");
2667             break;
2668          }
2669
2670       }
2671       // NOTE :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
2672       /*GNB DU ID */
2673       ieIdx++;
2674       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
2675       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
2676       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2677       GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID;
2678       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size = sizeof(uint8_t);
2679       DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2680             duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2681       if(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == NULLP)
2682       {
2683          DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): Memory allocation failed for GNB_DU_ID");
2684          break;
2685       }
2686       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] = duCfgParam.duId;
2687
2688       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
2689
2690       /* Encode the DU Config Update type as APER */
2691       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
2692       encBufSize = 0;
2693       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
2694
2695       /* Checking encode results */
2696       if(encRetVal.encoded == ENCODE_FAIL)
2697       {
2698          DU_LOG("ERROR  -->  F1AP : Could not encode DUConfigUpdate structure (at %s)\n",\
2699                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2700          break;
2701       }
2702       else
2703       {
2704          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DUConfigUpdate\n");
2705          for(ieIdx =0; ieIdx < encBufSize; ieIdx++)
2706          {
2707             printf("%x",encBuf[ieIdx]);
2708          }
2709       }
2710       /* Sending msg */
2711       if(sendF1APMsg() != ROK)
2712       {
2713          DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update failed");
2714          break;
2715       }
2716
2717       ret = ROK;
2718       break;
2719    }
2720
2721    addToReservedF1apPduList(TRANS_ID,f1apDuCfg);
2722    return ret;
2723 }
2724
2725
2726 /*******************************************************************
2727  *
2728  * @brief free the ULRRCMessageTransfer
2729  *
2730  * @details
2731  *
2732  *    Function : FreeULRRCMessageTransfer
2733  *
2734  *    Functionality: Deallocating the memory of variable allocated in
2735  *                      FreeULRRCMessageTransfer
2736  *
2737  * @params[in]
2738  *
2739  * @return ROK     - void
2740  *
2741  ******************************************************************/
2742 void FreeULRRCMessageTransfer( F1AP_PDU_t *f1apMsg)
2743 {
2744    uint8_t idx1;
2745    ULRRCMessageTransfer_t  *ulRRCMsg;
2746
2747    if(f1apMsg != NULLP)
2748    {
2749       if(f1apMsg->choice.initiatingMessage != NULLP)
2750       {
2751          ulRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2752          if(ulRRCMsg->protocolIEs.list.array != NULLP)
2753          {
2754             for(idx1=0;idx1<ulRRCMsg->protocolIEs.list.count;idx1++)
2755             {
2756                if(ulRRCMsg->protocolIEs.list.array[idx1] != NULLP)
2757                {
2758                   if(ulRRCMsg->protocolIEs.list.array[idx1]->value.present ==
2759                         ULRRCMessageTransferIEs__value_PR_RRCContainer)
2760                   {
2761                      DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2762                            ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2763                   }
2764                   DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1],sizeof(ULRRCMessageTransferIEs_t));
2765                }
2766             }
2767             DU_FREE(ulRRCMsg->protocolIEs.list.array,ulRRCMsg->protocolIEs.list.size );
2768          }
2769          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2770       }
2771       DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
2772    }
2773 }
2774 /*******************************************************************
2775  *
2776  * @brief Builds and sends the ULRRCMessageTransfer
2777  *
2778  * @details
2779  *
2780  *    Function : BuildAndSendULRRCMessageTransfer
2781  *
2782  *    Functionality: Constructs the UL RRC Message Transfer and sends
2783  *                   it to the CU through SCTP.
2784  *
2785  * @params[in]
2786  *
2787  * @return ROK     - success
2788  *         RFAILED - failure
2789  *
2790  * ****************************************************************/
2791 uint8_t BuildAndSendULRRCMessageTransfer(DuUeCb  ueCb, uint8_t lcId, \
2792       uint16_t msgLen, uint8_t *rrcMsg)
2793 {
2794    uint8_t   elementCnt =0;
2795    uint8_t   idx1 =0;
2796    uint8_t   idx =0;
2797    F1AP_PDU_t                   *f1apMsg = NULLP;
2798    ULRRCMessageTransfer_t       *ulRRCMsg = NULLP;
2799    asn_enc_rval_t               encRetVal;        /* Encoder return value */
2800    uint8_t ret =RFAILED;
2801
2802    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2803
2804    while(true)
2805    {
2806       DU_LOG("\n INFO   -->  F1AP : Building UL RRC Message Transfer Message\n");
2807
2808       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
2809       if(f1apMsg == NULLP)
2810       {
2811          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2812          break;
2813       }
2814       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
2815       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2816       if(f1apMsg->choice.initiatingMessage == NULLP)
2817       {
2818          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
2819          break;
2820       }
2821       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_ULRRCMessageTransfer;
2822       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
2823       f1apMsg->choice.initiatingMessage->value.present = \
2824                                                          InitiatingMessage__value_PR_ULRRCMessageTransfer;
2825       ulRRCMsg =
2826          &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2827       elementCnt = 4;
2828       ulRRCMsg->protocolIEs.list.count = elementCnt;
2829       ulRRCMsg->protocolIEs.list.size = \
2830                                         elementCnt * sizeof(ULRRCMessageTransferIEs_t *);
2831
2832       /* Initialize the F1Setup members */
2833       DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size);
2834       if(ulRRCMsg->protocolIEs.list.array == NULLP)
2835       {
2836          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
2837          break;
2838       }
2839       for(idx=0; idx<elementCnt; idx++)
2840       {
2841          DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t));
2842          if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP)
2843          {
2844             break;
2845          }
2846       }
2847
2848       idx1 = 0;
2849
2850       /*GNB CU UE F1AP ID*/
2851       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
2852       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2853       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2854                                                               ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
2855       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = ueCb.gnbCuUeF1apId;
2856
2857       /*GNB DU UE F1AP ID*/
2858       idx1++;
2859       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
2860       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2861       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2862                                                               ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
2863       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = ueCb.gnbDuUeF1apId;
2864
2865       /*SRBID*/
2866       idx1++;
2867       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
2868       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2869       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2870                                                               ULRRCMessageTransferIEs__value_PR_SRBID;
2871       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = lcId;
2872
2873       /*RRCContainer*/
2874       idx1++;
2875       ulRRCMsg->protocolIEs.list.array[idx1]->id  = ProtocolIE_ID_id_RRCContainer;
2876       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2877       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2878                                                               ULRRCMessageTransferIEs__value_PR_RRCContainer;
2879       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size = msgLen;
2880       DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2881             ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
2882       if(!ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
2883       {
2884          DU_LOG(" ERROR  -->  F1AP : Memory allocation for BuildAndSendULRRCMessageTransfer failed");
2885          break;
2886       }
2887       memset(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, 0, msgLen);
2888       memcpy(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, \
2889             rrcMsg, ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2890
2891       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2892
2893       /* Encode the F1SetupRequest type as APER */
2894       memset(encBuf, 0, ENC_BUF_MAX_LEN);
2895       encBufSize = 0;
2896       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
2897             encBuf);
2898       /* Encode results */
2899       if(encRetVal.encoded == ENCODE_FAIL)
2900       {
2901          DU_LOG( "\nERROR  -->  F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
2902                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2903          break;
2904       }
2905       else
2906       {
2907          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
2908          for(int i=0; i< encBufSize; i++)
2909          {
2910             printf("%x",encBuf[i]);
2911          }
2912       }
2913
2914       /* Sending  msg  */
2915       if(sendF1APMsg()  !=      ROK)
2916       {
2917          DU_LOG("\nERROR  -->   F1AP : Sending  UL RRC Message Transfer Failed");
2918          break;
2919       }
2920       ret = ROK;
2921       break;
2922    }
2923    FreeULRRCMessageTransfer(f1apMsg);
2924
2925    return ret;
2926 }/* End of BuildAndSendULRRCMessageTransfer*/
2927
2928 /*******************************************************************
2929  *
2930  * @brief Builds tag config
2931  *
2932  * @details
2933  *
2934  *    Function : BuildTagConfig
2935  *
2936  *    Functionality: Builds tag config in MacCellGroupConfig
2937  *
2938  * @params[in] TAG_Config *tag_Config
2939  *
2940  * @return ROK     - success
2941  *         RFAILED - failure
2942  *
2943  * ****************************************************************/
2944 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
2945 {
2946    struct TAG_Config__tag_ToAddModList *tagList;
2947    uint8_t                     idx, elementCnt;
2948
2949    tagConfig->tag_ToReleaseList = NULLP;
2950    tagConfig->tag_ToAddModList = NULLP;
2951    DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
2952    if(!tagConfig->tag_ToAddModList)
2953    {
2954       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2955       return RFAILED;
2956    }
2957
2958    elementCnt = 1; //ODU_VALUE_ONE;
2959    tagList = tagConfig->tag_ToAddModList;
2960    tagList->list.count = elementCnt;
2961    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
2962
2963    tagList->list.array = NULLP;
2964    DU_ALLOC(tagList->list.array, tagList->list.size);
2965    if(!tagList->list.array)
2966    {
2967       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2968       return RFAILED;
2969    }
2970
2971    for(idx=0; idx<tagList->list.count; idx++)
2972    {
2973       tagList->list.array[idx] = NULLP;
2974       DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
2975       if(!tagList->list.array[idx])
2976       {
2977          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2978          return RFAILED;
2979       }
2980    }
2981
2982    idx = 0;
2983    tagList->list.array[idx]->tag_Id = TAG_ID;
2984    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
2985
2986    return ROK;
2987 }
2988
2989 /*******************************************************************
2990  *
2991  * @brief Builds PHR Config
2992  *
2993  * @details
2994  *
2995  *    Function : BuildPhrConfig
2996  *
2997  *    Functionality: Builds phrConfig in MacCellGroupConfig
2998  *
2999  * @params[in] PHR Config *
3000  *
3001  * @return ROK     - success
3002  *         RFAILED - failure
3003  *
3004  * ****************************************************************/
3005 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
3006 {
3007
3008    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
3009    phrConfig->choice.setup = NULLP;
3010    DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
3011    if(!phrConfig->choice.setup)
3012    {
3013       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
3014       return RFAILED;
3015    }
3016
3017    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
3018    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
3019    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
3020    phrConfig->choice.setup->multiplePHR              = false;
3021    phrConfig->choice.setup->dummy                    = false;
3022    phrConfig->choice.setup->phr_Type2OtherCell       = false;
3023    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
3024
3025    return ROK;
3026 }
3027
3028 /*******************************************************************
3029  *
3030  * @brief Builds BSR Config
3031  *
3032  * @details
3033  *
3034  *    Function : BuildBsrConfig
3035  *
3036  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
3037  *
3038  * @params[in] BSR_Config *bsrConfig
3039  *
3040  * @return ROK     - success
3041  *         RFAILED - failure
3042  *
3043  * ****************************************************************/
3044 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
3045 {
3046    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
3047    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
3048    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
3049
3050    return ROK;
3051 }
3052
3053 /*******************************************************************
3054  *
3055  * @brief Builds scheduling request config
3056  *
3057  * @details
3058  *
3059  *    Function : BuildSchedulingReqConfig
3060  *
3061  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
3062  *
3063  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
3064  *
3065  * @return ROK     - success
3066  *         RFAILED - failure
3067  *
3068  * ****************************************************************/
3069 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
3070 {
3071    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
3072    uint8_t                     idx, elementCnt;
3073
3074    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
3075    DU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
3076          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
3077    if(!schedulingRequestConfig->schedulingRequestToAddModList)
3078    {
3079       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3080       return RFAILED;
3081    }
3082
3083    elementCnt = 1; //ODU_VALUE_ONE;
3084    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
3085    schReqList->list.count = elementCnt;
3086    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
3087
3088    schReqList->list.array = NULLP;
3089    DU_ALLOC(schReqList->list.array, schReqList->list.size);
3090    if(!schReqList->list.array)
3091    {
3092       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3093       return RFAILED;
3094    }
3095
3096    for(idx=0;idx<schReqList->list.count; idx++)
3097    {
3098       schReqList->list.array[idx] = NULLP;
3099       DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
3100       if(!schReqList->list.array[idx])
3101       {
3102          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3103          return RFAILED;
3104       }
3105    }
3106
3107    idx = 0;
3108    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
3109
3110    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
3111    DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
3112    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
3113    {
3114       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3115       return RFAILED;
3116    }
3117    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
3118    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
3119    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
3120
3121    return ROK;
3122 }
3123
3124 /*******************************************************************
3125  *
3126  * @brief Builds RLC Config
3127  *
3128  * @details
3129  *
3130  *    Function : BuildRlcConfig
3131  *
3132  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
3133  *
3134  * @params[in] RLC_Config *rlcConfig
3135  *
3136  * @return ROK     - success
3137  *         RFAILED - failure
3138  *
3139  * ****************************************************************/
3140 uint8_t BuildRlcConfig(struct RLC_Config *rlcConfig)
3141 {
3142
3143    rlcConfig->present = RLC_Config_PR_am;
3144
3145    rlcConfig->choice.am = NULLP;
3146    DU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
3147    if(!rlcConfig->choice.am)
3148    {
3149       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3150       return RFAILED;
3151    }
3152
3153    /* UL */
3154    rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
3155    DU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3156    if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
3157    {
3158       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3159       return RFAILED;
3160    }
3161    *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3162    rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
3163    rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
3164    rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
3165    rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
3166
3167    /* DL */
3168    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
3169    DU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3170    if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
3171    {
3172       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3173       return RFAILED;
3174    }
3175    *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3176    rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
3177    rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
3178
3179    return ROK;
3180 }
3181
3182 /*******************************************************************
3183  *
3184  * @brief Builds MAC LC Config
3185  *
3186  * @details
3187  *
3188  *    Function : BuildMacLCConfig
3189  *
3190  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
3191  *
3192  * @params[in] struct LogicalChannelConfig macLcConfig
3193  *
3194  * @return ROK     - success
3195  *         RFAILED - failure
3196  *
3197  * ****************************************************************/
3198 uint8_t BuildMacLCConfig(struct LogicalChannelConfig *macLcConfig)
3199 {
3200
3201    macLcConfig->ul_SpecificParameters = NULLP;
3202    DU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
3203    if(!macLcConfig->ul_SpecificParameters)
3204    {
3205       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3206       return RFAILED;
3207    }
3208
3209    macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
3210    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     PRIORTISIED_BIT_RATE;
3211    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     BUCKET_SIZE_DURATION;
3212    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
3213    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
3214    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
3215    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
3216
3217    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
3218    DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
3219    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
3220    {
3221       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3222       return RFAILED;
3223    }
3224    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
3225
3226    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
3227    DU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
3228    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
3229    {
3230       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3231       return RFAILED;
3232    }
3233    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
3234
3235    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
3236    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
3237    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
3238
3239    return ROK;
3240 }
3241
3242 /*******************************************************************
3243  *
3244  * @brief Builds RLC Bearer to Add/Mod list
3245  *
3246  * @details
3247  *
3248  *    Function :BuildRlcBearerToAddModList
3249  *
3250  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
3251  *
3252  * @params[in] rlc_BearerToAddModList
3253  *
3254  * @return ROK     - success
3255  *         RFAILED - failure
3256  *
3257  * ****************************************************************/
3258 uint8_t BuildRlcBearerToAddModList(struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
3259 {
3260    uint8_t                     idx, elementCnt;
3261
3262    elementCnt = 1;
3263    rlcBearerList->list.count = elementCnt;
3264    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
3265
3266    rlcBearerList->list.array = NULLP;
3267    DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
3268    if(!rlcBearerList->list.array)
3269    {
3270       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3271       return RFAILED;
3272    }
3273
3274    for(idx=0; idx<rlcBearerList->list.count; idx++)
3275    {
3276       rlcBearerList->list.array[idx] = NULLP;
3277       DU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
3278       if(!rlcBearerList->list.array[idx])
3279       {
3280          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3281          return RFAILED;
3282       }
3283    }
3284
3285    idx = 0;
3286    rlcBearerList->list.array[idx]->logicalChannelIdentity = SRB1_LCID;
3287
3288    DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, \
3289       sizeof(struct RLC_BearerConfig__servedRadioBearer));
3290    if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3291    {
3292       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3293       return RFAILED;
3294    }
3295
3296    rlcBearerList->list.array[idx]->servedRadioBearer->present = \
3297       RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
3298    rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = \
3299       SRB1_LCID;
3300
3301    rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3302    rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3303    DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3304    if(!rlcBearerList->list.array[idx]->rlc_Config)
3305    {
3306       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3307       return RFAILED;
3308    }
3309
3310    if(BuildRlcConfig(rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3311    {
3312       DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3313       return RFAILED;
3314    }
3315
3316    rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3317    DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, \
3318       sizeof(struct LogicalChannelConfig));
3319    if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3320    {
3321       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3322       return RFAILED;
3323    }
3324
3325    if(BuildMacLCConfig(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3326    {
3327       DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3328       return RFAILED;
3329    }
3330
3331    return ROK;
3332 }
3333
3334 /*******************************************************************
3335  *
3336  * @brief Build Control resource set to add/modify list
3337  *
3338  * @details
3339  *
3340  *    Function : BuildControlRSetToAddModList
3341  *
3342  *    Functionality: Build Control resource set to add/modify list
3343  *
3344  * @params[in]
3345  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3346  *
3347  * @return ROK     - success
3348  *         RFAILED - failure
3349  *
3350  * ****************************************************************/
3351    uint8_t BuildControlRSetToAddModList
3352 (
3353  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3354  )
3355 {
3356    uint8_t idx;
3357    uint8_t elementCnt;
3358    uint8_t numBytes, bitsUnused;
3359    struct ControlResourceSet *controlRSet;
3360    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3361    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3362
3363
3364    elementCnt = 1;
3365    controlRSetList->list.count = elementCnt;
3366    controlRSetList->list.size = \
3367                                 elementCnt * sizeof(struct ControlResourceSet *);
3368
3369    controlRSetList->list.array = NULLP;
3370    DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3371    if(!controlRSetList->list.array)
3372    {
3373       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3374       return RFAILED;
3375    }
3376
3377    for(idx = 0; idx < elementCnt; idx++)
3378    {
3379       controlRSetList->list.array[idx] = NULLP;
3380       DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3381       if(!controlRSetList->list.array[idx])
3382       {
3383          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3384          return RFAILED;
3385       }
3386    }
3387
3388    idx=0;
3389    controlRSet = controlRSetList->list.array[idx];
3390
3391    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3392
3393    /* size 6 bytes
3394     * 3 LSBs unsued
3395     * Bit string stored ff0000000000
3396     */
3397    numBytes = 6;
3398    bitsUnused = 3;
3399    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3400
3401    controlRSet->frequencyDomainResources.buf = NULLP;
3402    DU_ALLOC(controlRSet->frequencyDomainResources.buf, \
3403          controlRSet->frequencyDomainResources.size);
3404    if(!controlRSet->frequencyDomainResources.buf)
3405    {
3406       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3407       return RFAILED;
3408    }
3409
3410    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3411    coreset0EndPrb = CORESET0_END_PRB;
3412    coreset1StartPrb = coreset0EndPrb + 6;
3413    coreset1NumPrb = CORESET1_NUM_PRB;
3414    /* calculate the PRBs */
3415    freqDomRscAllocType0(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3416    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3417    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3418
3419    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3420    controlRSet->cce_REG_MappingType.present = \
3421                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3422
3423    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3424    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3425    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3426    controlRSet->tci_PresentInDCI = NULLP;
3427 #if 0
3428    uint8_t tciStateIdx;
3429
3430    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3431          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3432    if(!controlRset->tci_StatesPDCCH_ToAddList)
3433    {
3434       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3435       return RFAILED;
3436    }
3437
3438    elementCnt = 1;
3439    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3440    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3441    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3442          controlRset->tci_StatesPDCCH_ToAddList->list.size)
3443       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3444       {
3445          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3446          return RFAILED;
3447       }
3448
3449    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3450    {
3451       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3452       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3453       {
3454          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3455          return RFAILED;
3456       }
3457    }
3458
3459    tciStateIdx = 0;
3460    /* TODO */
3461    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3462
3463    DU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3464    if(!controlRset->tci_PresentInDCI)
3465    {
3466       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3467       return RFAILED;
3468    }
3469    /* TODO */
3470    *(controlRset->tci_PresentInDCI);
3471 #endif
3472
3473    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3474    DU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3475    if(!controlRSet->pdcch_DMRS_ScramblingID)
3476    {
3477       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3478       return RFAILED;
3479    }
3480    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3481
3482    return ROK;
3483 } /* End BuildControlRSetToAddModList */
3484
3485 /*******************************************************************
3486  *
3487  * @brief Build search space to add/modify list
3488  *
3489  * @details
3490  *
3491  *    Function : BuildSearchSpcToAddModList
3492  *
3493  *    Functionality: Build search space to add/modify list
3494  *
3495  * @params[in]
3496  * @return ROK     - success
3497  *         RFAILED - failure
3498  *
3499  * ****************************************************************/
3500    uint8_t BuildSearchSpcToAddModList
3501 (
3502  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
3503  )
3504 {
3505    uint8_t idx;
3506    uint8_t numBytes;
3507    uint8_t byteIdx;
3508    uint8_t bitsUnused;
3509    uint8_t elementCnt;
3510    struct SearchSpace *searchSpc;
3511
3512    elementCnt = 1;
3513    searchSpcList->list.count = elementCnt;
3514    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3515
3516    searchSpcList->list.array = NULLP;
3517    DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3518    if(!searchSpcList->list.array)
3519    {
3520       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3521       return RFAILED;
3522    }
3523
3524    for(idx = 0; idx < elementCnt; idx++)
3525    {
3526       searchSpcList->list.array[idx] = NULLP;
3527       DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3528       if(!searchSpcList->list.array[idx])
3529       {
3530          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3531          return RFAILED;
3532       }
3533    }
3534
3535    idx = 0;
3536    searchSpc = searchSpcList->list.array[idx];
3537
3538    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3539
3540    searchSpc->controlResourceSetId = NULLP;
3541    DU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3542    if(!searchSpc->controlResourceSetId)
3543    {
3544       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3545       return RFAILED;
3546    }
3547    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3548
3549    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3550    DU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
3551          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3552    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3553    {
3554       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3555       return RFAILED;
3556    }
3557    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
3558                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3559
3560    searchSpc->duration = NULLP;
3561    searchSpc->monitoringSymbolsWithinSlot = NULLP;
3562    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3563    if(!searchSpc->monitoringSymbolsWithinSlot)
3564    {
3565       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3566       return RFAILED;
3567    }
3568
3569    /* Values taken from reference logs :
3570     * size 2 bytes
3571     * 2 LSBs unsued
3572     * Bit string stores 8000
3573     */
3574    numBytes = 2;
3575    bitsUnused = 2;
3576
3577    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3578    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3579    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
3580          searchSpc->monitoringSymbolsWithinSlot->size);
3581    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3582    {
3583       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3584       return RFAILED;
3585    }
3586
3587    byteIdx = 0;
3588    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
3589                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3590    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3591    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3592
3593    searchSpc->nrofCandidates = NULLP;
3594    DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3595    if(!searchSpc->nrofCandidates)
3596    {
3597       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3598       return RFAILED;
3599    }
3600
3601    searchSpc->nrofCandidates->aggregationLevel1 = \
3602                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3603    searchSpc->nrofCandidates->aggregationLevel2 = \
3604                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3605    searchSpc->nrofCandidates->aggregationLevel4 = \
3606                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3607    searchSpc->nrofCandidates->aggregationLevel8 = \
3608                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3609    searchSpc->nrofCandidates->aggregationLevel16 = \
3610                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3611
3612    searchSpc->searchSpaceType = NULLP;
3613    DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3614    if(!searchSpc->searchSpaceType)
3615    {
3616       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3617       return RFAILED;
3618    }
3619
3620    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3621
3622    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3623    DU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
3624          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3625    if(!searchSpc->searchSpaceType->choice.ue_Specific)
3626    {
3627       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3628       return RFAILED;
3629    }
3630    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
3631                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3632
3633    return ROK;
3634 }/* End BuildSearchSpcToAddModList */
3635
3636 /*******************************************************************
3637  *
3638  * @brief Builds BWP DL dedicated PDCCH config
3639  *
3640  * @details
3641  *
3642  *    Function : BuildBWPDlDedPdcchCfg
3643  *
3644  *    Functionality: Builds BWP DL dedicated PDCCH config
3645  *
3646  * @params[in] struct PDCCH_Config *pdcchCfg
3647  *
3648  * @return ROK     - success
3649  *         RFAILED - failure
3650  *
3651  * ****************************************************************/
3652 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
3653 {
3654    pdcchCfg->controlResourceSetToAddModList = NULLP;
3655    DU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
3656          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3657    if(!pdcchCfg->controlResourceSetToAddModList)
3658    {
3659       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3660       return RFAILED;
3661    }
3662
3663    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
3664    {
3665       return RFAILED;
3666    }
3667
3668    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3669
3670    pdcchCfg->searchSpacesToAddModList = NULLP;
3671    DU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3672          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3673    if(!pdcchCfg->searchSpacesToAddModList)
3674    {
3675       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3676       return RFAILED;
3677    }
3678
3679    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3680    {
3681       return RFAILED;
3682    }
3683
3684    pdcchCfg->searchSpacesToReleaseList = NULLP;
3685    pdcchCfg->downlinkPreemption = NULLP;
3686    pdcchCfg->tpc_PUSCH = NULLP;
3687    pdcchCfg->tpc_PUCCH = NULLP;
3688    pdcchCfg->tpc_SRS = NULLP;
3689
3690    return ROK;
3691 }
3692
3693 /*******************************************************************
3694  *
3695  * @brief Builds DMRS DL PDSCH Mapping type A
3696  *
3697  * @details
3698  *
3699  *    Function : BuildDMRSDLPdschMapTypeA
3700  *
3701  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3702  *
3703  * @params[in]
3704  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3705  * @return ROK     - success
3706  *         RFAILED - failure
3707  *
3708  * ****************************************************************/
3709    uint8_t BuildDMRSDLPdschMapTypeA
3710 (
3711  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3712  )
3713 {
3714    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3715    dmrsDlCfg->choice.setup = NULLP;
3716    DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3717    if(!dmrsDlCfg->choice.setup)
3718    {
3719       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3720       return RFAILED;
3721    }
3722
3723    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3724    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3725    DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3726    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3727    {
3728       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3729       return RFAILED;
3730    }
3731    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3732
3733    dmrsDlCfg->choice.setup->maxLength = NULLP;
3734    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3735    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3736    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3737
3738    return ROK;
3739 }
3740
3741 /*******************************************************************
3742  *
3743  * @brief Builds TCI states to add/modify list
3744  *
3745  * @details
3746  *
3747  *    Function : BuildTCIStatesToAddModList
3748  *
3749  *    Functionality:Builds TCI states to add/modify list
3750  *
3751  * @params[in]
3752  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3753  *
3754  * @return ROK     - success
3755  *         RFAILED - failure
3756  *
3757  * ****************************************************************/
3758 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3759 {
3760    return ROK;
3761 }
3762
3763 /*******************************************************************
3764  *
3765  * @brief Builds PDSCH time domain allocation list
3766  *
3767  * @details
3768  *
3769  *    Function : BuildPdschTimeDomAllocList
3770  *
3771  *    Functionality: Builds PDSCH time domain allocation list
3772  *
3773  * @params[in]
3774  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3775  *
3776  * @return ROK     - success
3777  *         RFAILED - failure
3778  *
3779  * ****************************************************************/
3780    uint8_t BuildPdschTimeDomAllocList
3781 (
3782  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3783  )
3784 {
3785    uint8_t idx;
3786    uint8_t elementCnt;
3787    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3788
3789    timeDomAllocList->present = \
3790                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3791
3792    timeDomAllocList->choice.setup = NULLP;
3793    DU_ALLOC(timeDomAllocList->choice.setup, \
3794          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3795    if(!timeDomAllocList->choice.setup)
3796    {
3797       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3798       return RFAILED;
3799    }
3800
3801    elementCnt = 2;
3802    timeDomAllocList->choice.setup->list.count = elementCnt;
3803    timeDomAllocList->choice.setup->list.size = \
3804                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3805
3806    timeDomAllocList->choice.setup->list.array = NULLP;
3807    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3808          timeDomAllocList->choice.setup->list.size);
3809    if(!timeDomAllocList->choice.setup->list.array)
3810    {
3811       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3812       return RFAILED;
3813    }
3814
3815    for(idx = 0; idx < elementCnt; idx++)
3816    {
3817       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3818       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3819             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3820       if(!timeDomAllocList->choice.setup->list.array[idx])
3821       {
3822          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3823          return RFAILED;
3824       }
3825    }
3826
3827    idx = 0;
3828    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3829    DU_ALLOC(timeDomAlloc->k0, sizeof(long));
3830    if(!timeDomAlloc->k0)
3831    {
3832       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3833       return RFAILED;
3834    }
3835    *(timeDomAlloc->k0) = 0;
3836    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3837    timeDomAlloc->startSymbolAndLength = \
3838                                         calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
3839
3840    idx++;
3841    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3842    DU_ALLOC(timeDomAlloc->k0, sizeof(long));
3843    if(!timeDomAlloc->k0)
3844    {
3845       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3846       return RFAILED;
3847    }
3848    *(timeDomAlloc->k0) = 1;
3849    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3850    timeDomAlloc->startSymbolAndLength = calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
3851
3852    return ROK;
3853 }
3854
3855 /*******************************************************************
3856  *
3857  * @brief Builds PDSCH PRB Bundling type
3858  *
3859  * @details
3860  *
3861  *    Function : BuildPdschPrbBundlingType
3862  *
3863  *    Functionality: Builds PDSCH PRB Bundling type
3864  *
3865  * @params[in]
3866  * struct PDSCH_Config__prb_BundlingType *prbBndlType
3867  *
3868  * @return ROK     - success
3869  *         RFAILED - failure
3870  *
3871  * ****************************************************************/
3872    uint8_t BuildPdschPrbBundlingType
3873 (
3874  struct PDSCH_Config__prb_BundlingType *prbBndlType
3875  )
3876 {
3877    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
3878
3879    prbBndlType->choice.staticBundling = NULLP;
3880    DU_ALLOC(prbBndlType->choice.staticBundling, \
3881          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
3882    if(!prbBndlType->choice.staticBundling)
3883    {
3884       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
3885       return RFAILED;
3886    }
3887    prbBndlType->choice.staticBundling->bundleSize = NULLP;
3888
3889    return ROK;
3890 }
3891
3892 /*******************************************************************
3893  *
3894  * @brief Builds BWP DL dedicated PDSCH config
3895  *
3896  * @details
3897  *
3898  *    Function : BuildBWPDlDedPdschCfg
3899  *
3900  *    Functionality: Builds BWP DL dedicated PDSCH config
3901  *
3902  * @params[in] struct PDSCH_Config *pdschCfg
3903  *
3904  * @return ROK     - success
3905  *         RFAILED - failure
3906  *
3907  * ****************************************************************/
3908 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
3909 {
3910    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
3911
3912    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
3913    DU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
3914          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
3915    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
3916    {
3917       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3918       return RFAILED;
3919    }
3920
3921    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
3922    {
3923       return RFAILED;
3924    }
3925
3926    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
3927    pdschCfg->tci_StatesToAddModList = NULLP;
3928    pdschCfg->tci_StatesToReleaseList = NULLP;
3929    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
3930 #if 0
3931    DU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
3932    if(!pdschCfg->tci_StatesToAddModList)
3933    {
3934       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3935       return RFAILED;
3936    }
3937    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
3938    {
3939       return RFAILED;
3940    }
3941 #endif
3942
3943    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
3944
3945    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
3946    DU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
3947          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
3948    if(!pdschCfg->pdsch_TimeDomainAllocationList)
3949    {
3950       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3951       return RFAILED;
3952    }
3953
3954    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
3955    {
3956       return RFAILED;
3957    }
3958
3959    pdschCfg->pdsch_AggregationFactor = NULLP;
3960    pdschCfg->rateMatchPatternToAddModList = NULLP;
3961    pdschCfg->rateMatchPatternToReleaseList = NULLP;
3962    pdschCfg->rateMatchPatternGroup1 = NULLP;
3963    pdschCfg->rateMatchPatternGroup2 = NULLP;
3964    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
3965    pdschCfg->mcs_Table = NULLP;
3966
3967    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
3968    DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
3969    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
3970    {
3971       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3972       return RFAILED;
3973    }
3974    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
3975
3976    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
3977    {
3978       return RFAILED;
3979    }
3980
3981    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
3982    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
3983    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3984    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3985    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3986    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3987    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
3988
3989    return ROK;
3990 }
3991
3992 /*******************************************************************
3993  *
3994  * @brief Builds intitial DL BWP
3995  * @details
3996  *
3997  *    Function : BuildInitialDlBWP
3998  *
3999  *    Functionality: Builds intitial DL BWP in spCellCfgDed
4000  *
4001  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4002  *
4003  * @return ROK     - success
4004  *         RFAILED - failure
4005  *
4006  * ****************************************************************/
4007 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
4008 {
4009    dlBwp->pdcch_Config = NULLP;
4010    DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
4011    if(!dlBwp->pdcch_Config)
4012    {
4013       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4014       return RFAILED;
4015    }
4016    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
4017
4018    dlBwp->pdcch_Config->choice.setup = NULLP;
4019    DU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
4020    if(!dlBwp->pdcch_Config->choice.setup)
4021    {
4022       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4023       return RFAILED;
4024    }
4025    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
4026    {
4027       return RFAILED;
4028    }
4029
4030    dlBwp->pdsch_Config = NULLP;
4031    DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
4032    if(!dlBwp->pdsch_Config)
4033    {
4034       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4035       return RFAILED;
4036    }
4037    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
4038
4039    dlBwp->pdsch_Config->choice.setup = NULLP;
4040    DU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
4041    if(!dlBwp->pdsch_Config->choice.setup)
4042    {
4043       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4044       return RFAILED;
4045    }
4046
4047    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
4048    {
4049       return RFAILED;
4050    }
4051
4052    dlBwp->sps_Config = NULLP;
4053    dlBwp->radioLinkMonitoringConfig = NULLP;
4054    return ROK;
4055 }
4056
4057 /*******************************************************************
4058  *
4059  * @brief Builds DMRS UL Pusch Mapping type A
4060  *
4061  * @details
4062  *
4063  *    Function : BuildDMRSULPuschMapTypeA
4064  *
4065  *    Functionality: Builds DMRS UL Pusch Mapping type A
4066  *
4067  * @params[in]
4068  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4069  * @return ROK     - success
4070  *         RFAILED - failure
4071  *
4072  * ****************************************************************/
4073    uint8_t BuildDMRSULPuschMapTypeA
4074 (
4075  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4076  )
4077 {
4078    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
4079    dmrsUlCfg->choice.setup= NULLP;
4080    DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
4081    if(!dmrsUlCfg->choice.setup)
4082    {
4083       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4084       return RFAILED;
4085    }
4086
4087    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
4088    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
4089    DU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
4090    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4091    {
4092       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4093       return RFAILED;
4094    }
4095    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
4096
4097    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
4098    dmrsUlCfg->choice.setup->maxLength = NULLP;
4099    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
4100    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
4101          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4102    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4103    {
4104       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4105       return RFAILED;
4106    }
4107
4108    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
4109    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4110          sizeof(long));
4111    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
4112    {
4113       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4114       return RFAILED;
4115    }
4116    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
4117
4118    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
4119    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
4120    return ROK;
4121 }
4122
4123 /*******************************************************************
4124  *
4125  * @brief Build PUSCH time domain allocation list
4126  *
4127  * @details
4128  *
4129  *    Function : BuildPuschTimeDomAllocList
4130  *
4131  *    Functionality: Build PUSCH time domain allocation list
4132  *
4133  * @params[in]
4134  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4135  *
4136  * @return ROK     - success
4137  *         RFAILED - failure
4138  *
4139  * ****************************************************************/
4140    uint8_t BuildPuschTimeDomAllocList
4141 (
4142  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4143  )
4144 {
4145    uint8_t idx;
4146    uint8_t elementCnt;
4147    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
4148
4149    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
4150    timeDomAllocList->choice.setup = NULLP;
4151    DU_ALLOC(timeDomAllocList->choice.setup, \
4152          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4153    if(!timeDomAllocList->choice.setup)
4154    {
4155       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4156       return RFAILED;
4157    }
4158
4159    elementCnt = 2;
4160    timeDomAllocList->choice.setup->list.count = elementCnt;
4161    timeDomAllocList->choice.setup->list.size = \
4162                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
4163    timeDomAllocList->choice.setup->list.array = NULLP;
4164    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
4165          timeDomAllocList->choice.setup->list.size);
4166    if(!timeDomAllocList->choice.setup->list.array)
4167    {
4168       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4169       return RFAILED;
4170    }
4171
4172    for(idx = 0; idx < elementCnt; idx++)
4173    {
4174       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4175       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
4176             sizeof(PUSCH_TimeDomainResourceAllocation_t));
4177       if(!timeDomAllocList->choice.setup->list.array[idx])
4178       {
4179          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4180          return RFAILED;
4181       }
4182    }
4183
4184    idx = 0;
4185    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4186    DU_ALLOC(timeDomAlloc->k2, sizeof(long));
4187    if(!timeDomAlloc->k2)
4188    {
4189       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4190       return RFAILED;
4191    }
4192    *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
4193    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4194    timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
4195
4196    idx++;
4197    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4198    DU_ALLOC(timeDomAlloc->k2, sizeof(long));
4199    if(!timeDomAlloc->k2)
4200    {
4201       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4202       return RFAILED;
4203    }
4204    *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
4205    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4206    timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
4207
4208    return ROK;
4209 }
4210
4211 /*******************************************************************
4212  *
4213  * @brief Builds BWP UL dedicated PUSCH Config
4214  *
4215  * @details
4216  *
4217  *    Function : BuildBWPUlDedPuschCfg
4218  *
4219  *    Functionality:
4220  *      Builds BWP UL dedicated PUSCH Config
4221  *
4222  * @params[in] : PUSCH_Config_t *puschCfg
4223  *
4224  * @return ROK     - success
4225  *         RFAILED - failure
4226  *
4227  * ****************************************************************/
4228 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
4229 {
4230    puschCfg->dataScramblingIdentityPUSCH = NULLP;
4231    DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4232    if(!puschCfg->dataScramblingIdentityPUSCH)
4233    {
4234       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4235       return RFAILED;
4236    }
4237    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
4238
4239    puschCfg->txConfig = NULLP;
4240    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4241    DU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4242          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4243    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4244    {
4245       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4246       return RFAILED;
4247    }
4248
4249    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4250    {
4251       return RFAILED;
4252    }
4253
4254    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4255    puschCfg->pusch_PowerControl = NULLP;
4256    puschCfg->frequencyHopping = NULLP;
4257    puschCfg->frequencyHoppingOffsetLists = NULLP;
4258    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4259
4260    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4261    DU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
4262          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4263    if(!puschCfg->pusch_TimeDomainAllocationList)
4264    {
4265       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4266       return RFAILED;
4267    }
4268
4269    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
4270    {
4271       return RFAILED;
4272    }
4273
4274    puschCfg->pusch_AggregationFactor = NULLP;
4275    puschCfg->mcs_Table = NULLP;
4276    puschCfg->mcs_TableTransformPrecoder = NULLP;
4277    puschCfg->transformPrecoder = NULLP;
4278    DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4279    if(!puschCfg->transformPrecoder)
4280    {
4281       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4282       return RFAILED;
4283    }
4284    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4285
4286    puschCfg->codebookSubset = NULLP;
4287    puschCfg->maxRank = NULLP;
4288    puschCfg->rbg_Size = NULLP;
4289    puschCfg->uci_OnPUSCH = NULLP;
4290    puschCfg->tp_pi2BPSK = NULLP;
4291
4292    return ROK;
4293 }
4294
4295 /*******************************************************************
4296  *
4297  * @brief Builds BWP UL dedicated PUCCH Config
4298  *
4299  * @details
4300  *
4301  *    Function : BuildBWPUlDedPucchCfg
4302  *
4303  *    Functionality:
4304  *      Builds BWP UL dedicated PUCCH Config
4305  *
4306  * @params[in] : PUCCH_Config_t *pucchCfg
4307  *
4308  * @return ROK     - success
4309  *         RFAILED - failure
4310  *
4311  * ****************************************************************/
4312 uint8_t BuildBWPUlDedPucchCfg(PUCCH_Config_t *pucchCfg)
4313 {
4314    uint8_t arrIdx, elementCnt;
4315
4316    DU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
4317    if(pucchCfg->dl_DataToUL_ACK == NULLP)
4318    {
4319       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4320       return RFAILED;
4321    }
4322
4323    elementCnt = 2;
4324    pucchCfg->dl_DataToUL_ACK->list.count = elementCnt;
4325    pucchCfg->dl_DataToUL_ACK->list.size = elementCnt * sizeof(long *);
4326    DU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
4327    if(pucchCfg->dl_DataToUL_ACK->list.array == NULLP)
4328    {
4329       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4330       return RFAILED;
4331    }
4332
4333    for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
4334    {
4335       DU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
4336       if(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx] == NULLP)
4337       {
4338           DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4339           return RFAILED;
4340       }
4341    }
4342
4343    arrIdx = 0;
4344    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx++]) = 1;
4345    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx]) = 2;
4346    return ROK;
4347 }
4348
4349 /*******************************************************************
4350  *
4351  * @brief Fills SRS resource to add/modify list
4352  *
4353  * @details
4354  *
4355  *    Function : BuildSrsRsrcAddModList
4356  *
4357  *    Functionality: Fills SRS resource to add/modify list
4358  *
4359  * @params[in]
4360  * @return ROK     - success
4361  *         RFAILED - failure
4362  *
4363  * ****************************************************************/
4364 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
4365 {
4366    uint8_t   elementCnt;
4367    uint8_t   rsrcIdx;
4368
4369    elementCnt = 1;
4370    resourceList->list.count = elementCnt;
4371    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
4372    resourceList->list.array = NULLP;
4373    DU_ALLOC(resourceList->list.array, resourceList->list.size);
4374    if(!resourceList->list.array)
4375    {
4376       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4377       return RFAILED;
4378    }
4379
4380    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4381    {
4382       DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4383       if(!resourceList->list.array[rsrcIdx])
4384       {
4385          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4386          return RFAILED;
4387       }
4388    }
4389
4390    rsrcIdx = 0;
4391    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
4392    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
4393    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
4394
4395    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
4396    DU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
4397          sizeof(struct SRS_Resource__transmissionComb__n2));
4398    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
4399    {
4400       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4401       return RFAILED;
4402    }
4403    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
4404       = SRS_COMB_OFFSET_N2;
4405    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
4406       = SRS_CYCLIC_SHIFT_N2;
4407
4408    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
4409                                                                       PUSCH_START_SYMBOL;
4410    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
4411                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
4412    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
4413                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
4414
4415    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
4416    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
4417    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
4418    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
4419    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
4420    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
4421                                                                SRS_Resource__groupOrSequenceHopping_neither;
4422
4423    /* Setting resource type to aperiodic for intergration purposes */
4424    resourceList->list.array[rsrcIdx]->resourceType.present = \
4425                                                              SRS_Resource__resourceType_PR_aperiodic;
4426    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
4427    DU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
4428          sizeof(struct SRS_Resource__resourceType__aperiodic));
4429    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
4430    {
4431       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4432       return RFAILED;
4433    }
4434    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
4435
4436    return ROK;
4437 }
4438
4439 /*******************************************************************
4440  *
4441  * @brief Build SRS resource set Add/mod list
4442  *
4443  * @details
4444  *
4445  *    Function : BuildSrsRsrcSetAddModList
4446  *
4447  *    Functionality: Build SRS resource set Add/mod list
4448  *
4449  * @params[in]
4450  * @return ROK     - success
4451  *         RFAILED - failure
4452  *
4453  * ****************************************************************/
4454    uint8_t BuildSrsRsrcSetAddModList
4455 (
4456  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
4457  )
4458 {
4459    uint8_t  elementCnt;
4460    uint8_t  rSetIdx;
4461    uint8_t  rsrcIdx;
4462    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
4463
4464    elementCnt = 1;
4465    rsrcSetList->list.count = elementCnt;
4466    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
4467    rsrcSetList->list.array = NULLP;
4468    DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
4469    if(!rsrcSetList->list.array)
4470    {
4471       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4472       return RFAILED;
4473    }
4474
4475    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4476    {
4477       DU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4478       if(!rsrcSetList->list.array[rSetIdx])
4479       {
4480          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4481          return RFAILED;
4482       }
4483    }
4484
4485    rSetIdx = 0;
4486    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
4487
4488    /* Fill Resource Id list in resource set */
4489    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
4490    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4491          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4492    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4493    {
4494       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4495       return RFAILED;
4496    }
4497
4498    elementCnt = 1;
4499    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4500    rsrcIdList->list.count = elementCnt;
4501    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
4502    rsrcIdList->list.array = NULLP;
4503    DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
4504    if(!rsrcIdList->list.array)
4505    {
4506       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4507       return RFAILED;
4508    }
4509
4510    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4511    {
4512       DU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4513       if(!rsrcIdList->list.array[rsrcIdx])
4514       {
4515          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4516          return RFAILED;
4517       }
4518    }
4519
4520    rsrcIdx = 0;
4521    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
4522
4523    /* Fill resource type */
4524    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
4525                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
4526
4527    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
4528    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4529          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4530    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
4531    {
4532       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4533       return RFAILED;
4534    }
4535    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
4536       = APERIODIC_SRS_RESRC_TRIGGER;
4537
4538    /* TODO : Fill values for below IEs as expected by Viavi */
4539    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
4540    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
4541
4542
4543    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
4544    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
4545    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
4546    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
4547    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
4548
4549    return ROK;
4550 }
4551
4552 /*******************************************************************
4553  *
4554  * @brief Builds BWP UL dedicated SRS Config
4555  *
4556  * @details
4557  *
4558  *    Function : BuildBWPUlDedSrsCfg
4559  *
4560  *    Functionality: Builds BWP UL dedicated SRS Config
4561  *
4562  * @params[in] SRS Config
4563  * @return ROK     - success
4564  *         RFAILED - failure
4565  *
4566  * ****************************************************************/
4567 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
4568 {
4569    srsCfg->srs_ResourceSetToReleaseList = NULLP;
4570    srsCfg->srs_ResourceSetToAddModList = NULLP;
4571    DU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
4572          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4573    if(!srsCfg->srs_ResourceSetToAddModList)
4574    {
4575       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4576       return RFAILED;
4577    }
4578    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
4579    {
4580       return RFAILED;
4581    }
4582
4583    srsCfg->srs_ResourceToReleaseList = NULLP;
4584
4585    /* Resource to Add/Modify list */
4586    srsCfg->srs_ResourceToAddModList = NULLP;
4587    DU_ALLOC(srsCfg->srs_ResourceToAddModList, \
4588          sizeof(struct SRS_Config__srs_ResourceToAddModList));
4589    if(!srsCfg->srs_ResourceToAddModList)
4590    {
4591       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4592       return RFAILED;
4593    }
4594
4595    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
4596    {
4597       return RFAILED;
4598    }
4599
4600    srsCfg->tpc_Accumulation = NULLP;
4601
4602    return ROK;
4603 }
4604
4605
4606
4607 /*******************************************************************
4608  *
4609  * @brief Builds Pusch Serving cell Config
4610  *
4611  * @details
4612  *
4613  *    Function : BuildPuschSrvCellCfg
4614  *
4615  *    Functionality: Builds Pusch Serving cell Config
4616  *
4617  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
4618  *
4619  * @return ROK     - success
4620  *         RFAILED - failure
4621  *
4622  * ****************************************************************/
4623 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
4624 {
4625    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
4626    puschCfg->choice.setup = NULLP;
4627    DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4628    if(!puschCfg->choice.setup)
4629    {
4630       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4631       return RFAILED;
4632    }
4633
4634    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4635    puschCfg->choice.setup->rateMatching = NULLP;
4636    puschCfg->choice.setup->xOverhead = NULLP;
4637    puschCfg->choice.setup->ext1 = NULLP;
4638    DU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
4639    if(!puschCfg->choice.setup->ext1)
4640    {
4641       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4642       return RFAILED;
4643    }
4644
4645    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
4646    DU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
4647    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
4648    {
4649       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4650       return RFAILED;
4651    }
4652    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
4653
4654    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
4655    DU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
4656    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
4657    {
4658       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4659       return RFAILED;
4660    }
4661    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
4662    return ROK;
4663 }
4664
4665 /*******************************************************************
4666  *
4667  * @brief Builds inital UL BWP
4668  *
4669  * @details
4670  *
4671  *    Function : BuildInitialUlBWP
4672  *
4673  *    Functionality: Builds initial UL BWP
4674  *
4675  * @params[in] BWP_UplinkDedicated_t *ulBwp
4676  * @return ROK     - success
4677  *         RFAILED - failure
4678  *
4679  * ****************************************************************/
4680 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4681 {
4682    ulBwp->pucch_Config = NULLP;
4683    DU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
4684    if(!ulBwp->pucch_Config)
4685    {
4686       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4687       return RFAILED;
4688    }
4689
4690    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
4691    ulBwp->pucch_Config->choice.setup = NULLP;
4692    DU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
4693    if(!ulBwp->pucch_Config->choice.setup)
4694    {
4695       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4696       return RFAILED;
4697    }
4698
4699    if(BuildBWPUlDedPucchCfg(ulBwp->pucch_Config->choice.setup) != ROK)
4700    {
4701       return RFAILED;
4702    }
4703
4704    /* Fill BWP UL dedicated PUSCH config */
4705    ulBwp->pusch_Config = NULLP;
4706    DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4707    if(!ulBwp->pusch_Config)
4708    {
4709       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4710       return RFAILED;
4711    }
4712
4713    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
4714    ulBwp->pusch_Config->choice.setup = NULLP;
4715    DU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4716    if(!ulBwp->pusch_Config->choice.setup)
4717    {
4718       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4719       return RFAILED;
4720    }
4721
4722    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
4723    {
4724       return RFAILED;
4725    }
4726
4727    ulBwp->configuredGrantConfig = NULLP;
4728
4729    /* Fill BPW UL dedicated SRS config */
4730    ulBwp->srs_Config = NULLP;
4731    DU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4732    if(!ulBwp->srs_Config)
4733    {
4734       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4735       return RFAILED;
4736    }
4737
4738    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
4739    ulBwp->srs_Config->choice.setup = NULLP;
4740    DU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4741    if(!ulBwp->srs_Config->choice.setup)
4742    {
4743       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4744       return RFAILED;
4745    }
4746
4747    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
4748    {
4749       return RFAILED;
4750    }
4751
4752    ulBwp->beamFailureRecoveryConfig = NULLP;
4753
4754    return ROK;
4755 }
4756
4757 /*******************************************************************
4758  *
4759  * @brief Builds UL config
4760  * @details
4761  *
4762  *    Function : BuildUlCfg
4763  *
4764  *    Functionality: Builds UL config in spCellCfgDed
4765  *
4766  * @params[in] UplinkConfig_t *ulCfg
4767  *
4768  * @return ROK     - success
4769  *         RFAILED - failure
4770  *
4771  * ****************************************************************/
4772 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
4773 {
4774    ulCfg->initialUplinkBWP = NULLP;
4775    DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4776    if(!ulCfg->initialUplinkBWP)
4777    {
4778       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4779       return RFAILED;
4780    }
4781
4782    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
4783    {
4784       return RFAILED;
4785    }
4786
4787    ulCfg->uplinkBWP_ToReleaseList = NULLP;
4788    ulCfg->uplinkBWP_ToAddModList = NULLP;
4789    ulCfg->firstActiveUplinkBWP_Id = NULLP;
4790    DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4791    if(!ulCfg->firstActiveUplinkBWP_Id)
4792    {
4793       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4794       return RFAILED;
4795    }
4796    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
4797
4798    ulCfg->pusch_ServingCellConfig = NULLP;
4799    DU_ALLOC(ulCfg->pusch_ServingCellConfig, \
4800          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4801    if(!ulCfg->pusch_ServingCellConfig)
4802    {
4803       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4804       return RFAILED;
4805    }
4806
4807    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
4808    {
4809       return RFAILED;
4810    }
4811
4812    ulCfg->carrierSwitching = NULLP;
4813    ulCfg->ext1 = NULLP;
4814    return ROK;
4815 }
4816
4817 /*******************************************************************
4818  *
4819  * @brief Builds PDSCH serving cell config
4820  * @details
4821  *
4822  *    Function : BuildPdschSrvCellCfg
4823  *
4824  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
4825  *
4826  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
4827  *
4828  * @return ROK     - success
4829  *         RFAILED - failure
4830  *
4831  * ****************************************************************/
4832 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
4833 {
4834    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
4835    pdschCfg->choice.setup = NULLP;
4836    DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
4837    if(!pdschCfg->choice.setup)
4838    {
4839       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4840       return RFAILED;
4841    }
4842
4843    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4844    pdschCfg->choice.setup->xOverhead = NULLP;
4845    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
4846    DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
4847    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
4848    {
4849       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4850       return RFAILED;
4851    }
4852    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
4853    pdschCfg->choice.setup->pucch_Cell = NULLP;
4854    pdschCfg->choice.setup->ext1 = NULLP;
4855
4856    return ROK;
4857 }
4858
4859 /*******************************************************************
4860  *
4861  * @brief Builds CSI Meas config
4862  * @details
4863  *
4864  *    Function : BuildCsiMeasCfg
4865  *
4866  *    Functionality: Builds CSI Meas config in spCellCfgDed
4867  *
4868  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
4869  *
4870  * @return ROK     - success
4871  *         RFAILED - failure
4872  *
4873  * ****************************************************************/
4874 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
4875 {
4876
4877    return ROK;
4878 }
4879
4880 /*******************************************************************
4881  *
4882  * @brief Builds Spcell config dedicated
4883  * @details
4884  *
4885  *    Function : BuildSpCellCfgDed
4886  *
4887  *    Functionality: Builds sp cell config dedicated in spCellCfg
4888  *
4889  * @params[in] ServingCellConfig_t srvCellCfg
4890  *
4891  * @return ROK     - success
4892  *         RFAILED - failure
4893  *
4894  * ****************************************************************/
4895 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
4896 {
4897    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
4898    DU_ALLOC(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
4899    if(!srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
4900    {
4901       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4902       return RFAILED;
4903    }
4904
4905    srvCellCfg->initialDownlinkBWP = NULLP;
4906    DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
4907    if(!srvCellCfg->initialDownlinkBWP)
4908    {
4909       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4910       return RFAILED;
4911    }
4912
4913    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
4914    {
4915       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
4916       return RFAILED;
4917    }
4918    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
4919    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
4920
4921    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
4922    DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
4923    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
4924    {
4925       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4926       return RFAILED;
4927    }
4928    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4929
4930    srvCellCfg->bwp_InactivityTimer = NULLP;
4931
4932    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
4933    DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
4934    if(!srvCellCfg->defaultDownlinkBWP_Id)
4935    {
4936       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4937       return RFAILED;
4938    }
4939    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4940
4941    srvCellCfg->uplinkConfig = NULLP;
4942    DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
4943    if(!srvCellCfg->uplinkConfig)
4944    {
4945       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4946       return RFAILED;
4947    }
4948
4949    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
4950    {
4951       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
4952       return RFAILED;
4953    }
4954    srvCellCfg->supplementaryUplink = NULLP;
4955    srvCellCfg->pdcch_ServingCellConfig = NULLP;
4956
4957    srvCellCfg->pdsch_ServingCellConfig = NULLP;
4958    DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
4959    if(!srvCellCfg->pdsch_ServingCellConfig)
4960    {
4961       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4962       return RFAILED;
4963    }
4964
4965    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
4966    {
4967       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
4968       return RFAILED;
4969    }
4970
4971    srvCellCfg->csi_MeasConfig = NULLP;
4972 #if 0
4973    DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
4974       if(!srvCellCfg->csi_MeasConfig)
4975       {
4976          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4977          return RFAILED;
4978       }
4979
4980    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
4981    {
4982       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
4983       return RFAILED;
4984    }
4985 #endif
4986    srvCellCfg->sCellDeactivationTimer = NULLP;
4987    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
4988    srvCellCfg->tag_Id = TAG_ID;
4989    srvCellCfg->dummy = NULLP;
4990    srvCellCfg->pathlossReferenceLinking = NULLP;
4991    srvCellCfg->servingCellMO = NULLP;
4992    srvCellCfg->ext1 = NULLP;
4993
4994    return ROK;
4995 }
4996 /*******************************************************************
4997  *
4998  * @brief Builds Spcell config
4999  *
5000  * @details
5001  *
5002  *    Function : BuildSpCellCfg
5003  *
5004  *    Functionality: Builds sp cell config in DuToCuRrcContainer
5005  *
5006  * @params[in] SpCellConfig_t spCellCfg
5007  *
5008  * @return ROK     - success
5009  *         RFAILED - failure
5010  *
5011  * ****************************************************************/
5012 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
5013 {
5014
5015    spCellCfg->servCellIndex = NULLP;
5016    DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
5017    if(!spCellCfg->servCellIndex)
5018    {
5019       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5020       return RFAILED;
5021    }
5022    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
5023
5024    spCellCfg->reconfigurationWithSync = NULLP;
5025    spCellCfg->rlf_TimersAndConstants = NULLP;
5026    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
5027    DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5028    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
5029    {
5030       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5031       return RFAILED;
5032    }
5033    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
5034
5035    spCellCfg->spCellConfigDedicated = NULLP;
5036    DU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5037    if(!spCellCfg->spCellConfigDedicated)
5038    {
5039       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5040       return RFAILED;
5041    }
5042    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
5043    {
5044       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
5045       return RFAILED;
5046    }
5047    return ROK;
5048 }
5049 /*******************************************************************
5050  *
5051  * @brief Builds Phy cell group config
5052  *
5053  * @details
5054  *
5055  *    Function : BuildPhyCellGrpCfg
5056  *
5057  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
5058  *
5059  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
5060  *
5061  * @return ROK     - success
5062  *         RFAILED - failure
5063  *
5064  * ****************************************************************/
5065 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
5066 {
5067    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
5068    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
5069
5070    phyCellGrpCfg->p_NR_FR1 = NULLP;
5071    DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5072    if(!phyCellGrpCfg->p_NR_FR1)
5073    {
5074       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
5075       return RFAILED;
5076    }
5077    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
5078    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
5079    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
5080    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
5081    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
5082    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
5083    phyCellGrpCfg->cs_RNTI = NULLP;
5084    phyCellGrpCfg->ext1 = NULLP;
5085    phyCellGrpCfg->ext2 = NULLP;
5086
5087    return ROK;
5088 }
5089 /*******************************************************************
5090  *
5091  * @brief Builds Mac cell group config
5092  *
5093  * @details
5094  *
5095  *    Function : BuildMacCellGrpCfg
5096  *
5097  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
5098  *
5099  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
5100  *
5101  * @return ROK     - success
5102  *         RFAILED - failure
5103  *
5104  * ****************************************************************/
5105 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
5106 {
5107    macCellGrpCfg->drx_Config = NULLP;
5108    macCellGrpCfg->schedulingRequestConfig = NULLP;
5109    DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5110    if(!macCellGrpCfg->schedulingRequestConfig)
5111    {
5112       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5113       return RFAILED;
5114    }
5115
5116    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
5117    {
5118       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
5119       return RFAILED;
5120    }
5121
5122    macCellGrpCfg->bsr_Config = NULLP;
5123    DU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5124    if(!macCellGrpCfg->bsr_Config)
5125    {
5126       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5127       return RFAILED;
5128    }
5129
5130    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
5131    {
5132       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
5133       return RFAILED;
5134    }
5135
5136    macCellGrpCfg->tag_Config = NULLP;
5137    DU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
5138    if(!macCellGrpCfg->tag_Config)
5139    {
5140       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5141       return RFAILED;
5142    }
5143
5144    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
5145    {
5146       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
5147       return RFAILED;
5148    }
5149
5150    macCellGrpCfg->phr_Config = NULLP;
5151    DU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
5152    if(!macCellGrpCfg->phr_Config)
5153    {
5154       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5155       return RFAILED;
5156    }
5157
5158    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
5159    {
5160       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
5161       return RFAILED;
5162    }
5163
5164    macCellGrpCfg->skipUplinkTxDynamic = false;
5165    macCellGrpCfg->ext1 = NULLP;
5166
5167    return ROK;
5168 }
5169 /*******************************************************************
5170  *
5171  * @brief Frees memeory allocated for SearchSpcToAddModList
5172  *
5173  * @details
5174  *
5175  *    Function : FreeSearchSpcToAddModList
5176  *
5177  *    Functionality: Deallocating memory of SearchSpcToAddModList
5178  *
5179  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
5180  *
5181  * @return void
5182  *
5183  4221 * ****************************************************************/
5184 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
5185 {
5186    uint8_t idx1=0;
5187    uint8_t idx2=0;
5188    struct  SearchSpace *searchSpc=NULLP;
5189
5190    if(searchSpcList->list.array)
5191    {
5192       if(searchSpcList->list.array[idx2])
5193       {
5194          searchSpc = searchSpcList->list.array[idx2];
5195          if(searchSpc->controlResourceSetId)
5196          {
5197             if(searchSpc->monitoringSlotPeriodicityAndOffset)
5198             {
5199                if(searchSpc->monitoringSymbolsWithinSlot)
5200                {
5201                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
5202                   {
5203                      if(searchSpc->nrofCandidates)
5204                      {
5205                         if(searchSpc->searchSpaceType)
5206                         {
5207                            DU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
5208                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
5209                            DU_FREE(searchSpc->searchSpaceType, sizeof(struct
5210                                     SearchSpace__searchSpaceType));
5211                         }
5212                         DU_FREE(searchSpc->nrofCandidates,
5213                               sizeof(struct SearchSpace__nrofCandidates));
5214                      }
5215                      DU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
5216                            searchSpc->monitoringSymbolsWithinSlot->size);
5217                   }
5218                   DU_FREE(searchSpc->monitoringSymbolsWithinSlot,
5219                         sizeof(BIT_STRING_t));
5220                }
5221                DU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
5222                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
5223             }
5224             DU_FREE(searchSpc->controlResourceSetId,
5225                   sizeof(ControlResourceSetId_t));
5226          }
5227       }
5228       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
5229       {
5230          DU_FREE(searchSpcList->list.array[idx1],
5231                sizeof(struct SearchSpace));
5232       }
5233       DU_FREE(searchSpcList->list.array,searchSpcList->list.size);
5234    }
5235 }
5236 /*******************************************************************
5237  *
5238  * @brief Frees memory allocated for PdschTimeDomAllocList
5239  *
5240  * @details
5241  *
5242  *    Function : FreePdschTimeDomAllocList
5243  *
5244  *    Functionality: Deallocating memory of PdschTimeDomAllocList
5245  *
5246  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
5247  *
5248  * @return void
5249  *
5250  * ****************************************************************/
5251 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
5252 {
5253    uint8_t idx1=0;
5254
5255    if(timeDomAllocList->choice.setup)
5256    {
5257       if(timeDomAllocList->choice.setup->list.array)
5258       {
5259          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
5260          {
5261             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1]->k0, sizeof(long));
5262             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
5263                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
5264          }
5265          DU_FREE(timeDomAllocList->choice.setup->list.array, \
5266                timeDomAllocList->choice.setup->list.size);
5267       }
5268       DU_FREE(timeDomAllocList->choice.setup,\
5269             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
5270    }
5271 }
5272 /*******************************************************************
5273  *
5274  * @brief Frees memory allocated for PuschTimeDomAllocList
5275  *
5276  *@details
5277  *
5278  *    Function : FreePuschTimeDomAllocList
5279  *
5280  *    Functionality: Deallocating memory of PuschTimeDomAllocList
5281  *
5282  * @params[in] PUSCH_Config_t *puschCfg
5283  *
5284  * @return void
5285  *
5286  * ****************************************************************/
5287 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
5288 {
5289    uint8_t rsrcListIdx=0;
5290    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
5291
5292    if(puschCfg->pusch_TimeDomainAllocationList)
5293    {
5294       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
5295       if(timeDomAllocList_t->choice.setup)
5296       {
5297          if(timeDomAllocList_t->choice.setup->list.array)
5298          {
5299             for(rsrcListIdx = 0; rsrcListIdx<timeDomAllocList_t->choice.setup->list.count; rsrcListIdx++)
5300             {
5301                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx]->k2, sizeof(long));
5302                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx],\
5303                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
5304             }
5305             DU_FREE(timeDomAllocList_t->choice.setup->list.array, \
5306                   timeDomAllocList_t->choice.setup->list.size);
5307          }
5308          DU_FREE(timeDomAllocList_t->choice.setup, \
5309                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
5310       }
5311       DU_FREE(puschCfg->transformPrecoder, sizeof(long));
5312       DU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
5313             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
5314    }
5315
5316 }
5317 /*******************************************************************
5318  *
5319  * @brief Frees memory allocated for InitialUlBWP
5320  *
5321  * @details
5322  *
5323  *    Function : FreeInitialUlBWP
5324  *
5325  *    Functionality: Deallocating memory of InitialUlBWP
5326  *
5327  * @params[in] BWP_UplinkDedicated_t *ulBwp
5328  *
5329  * @return void
5330  *
5331  * ****************************************************************/
5332 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5333 {
5334    uint8_t  rSetIdx, rsrcIdx, k1Idx;
5335    SRS_Config_t   *srsCfg = NULLP;
5336    PUSCH_Config_t *puschCfg = NULLP;
5337    PUCCH_Config_t *pucchCfg = NULLP;
5338    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
5339    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
5340    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
5341    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
5342
5343    if(ulBwp->pucch_Config)
5344    {
5345       if(ulBwp->pucch_Config->choice.setup)
5346       {
5347           pucchCfg = ulBwp->pucch_Config->choice.setup;
5348           if(pucchCfg->dl_DataToUL_ACK)
5349           {
5350              if(pucchCfg->dl_DataToUL_ACK->list.array)
5351              {
5352                 for(k1Idx = 0; k1Idx < pucchCfg->dl_DataToUL_ACK->list.count; k1Idx++)
5353                 {
5354                    DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[k1Idx], sizeof(long));
5355                 }
5356                 DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
5357              }
5358              DU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
5359           }
5360           DU_FREE(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
5361       }
5362       DU_FREE(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
5363    }
5364
5365    if(ulBwp->pusch_Config)
5366    {
5367       if(ulBwp->pusch_Config->choice.setup)
5368       {
5369          puschCfg=ulBwp->pusch_Config->choice.setup;
5370          if(puschCfg->dataScramblingIdentityPUSCH)
5371          {
5372             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
5373             {
5374                FreePuschTimeDomAllocList(puschCfg);
5375                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
5376                if(dmrsUlCfg->choice.setup)
5377                {
5378                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
5379                   {
5380                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
5381                      {
5382                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
5383                               sizeof(long));
5384                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
5385                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
5386                      }
5387                      DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
5388                            sizeof(long));
5389                   }
5390                   DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
5391                }
5392                DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
5393                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
5394             }
5395             DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
5396          }
5397          DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5398       }
5399       DU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5400
5401       /* Free SRS-Config */
5402       if(ulBwp->srs_Config)
5403       {
5404          if(ulBwp->srs_Config->choice.setup)
5405          {
5406             srsCfg = ulBwp->srs_Config->choice.setup;
5407
5408             /* Free Resource Set to add/mod list */
5409             if(srsCfg->srs_ResourceSetToAddModList)
5410             {
5411                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
5412                if(rsrcSetList->list.array)
5413                {
5414                   rSetIdx = 0;
5415
5416                   /* Free SRS resource Id list in this SRS resource set */
5417                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5418                   {
5419                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5420
5421                      if(rsrcIdList->list.array)
5422                      {
5423                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5424                         {
5425                            DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5426                         }
5427                         DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
5428                      }
5429                      DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5430                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5431                   }
5432
5433                   /* Free resource type info for this SRS resource set */
5434                   DU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5435                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5436
5437                   /* Free memory for each resource set */
5438                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5439                   {
5440                      DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5441                   }
5442                   DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
5443                }
5444                DU_FREE(srsCfg->srs_ResourceSetToAddModList, \
5445                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5446             }
5447
5448             /* Free resource to add/modd list */
5449             if(srsCfg->srs_ResourceToAddModList)
5450             {
5451                resourceList = srsCfg->srs_ResourceToAddModList;
5452                if(resourceList->list.array)
5453                {
5454                   rsrcIdx = 0;
5455                   DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
5456                         sizeof(struct SRS_Resource__transmissionComb__n2));
5457                   DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
5458                         sizeof(struct SRS_Resource__resourceType__aperiodic));
5459
5460                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5461                   {
5462                      DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5463                   }
5464                   DU_FREE(resourceList->list.array, resourceList->list.size);
5465                }
5466                DU_FREE(srsCfg->srs_ResourceToAddModList, \
5467                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
5468             }
5469
5470             DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5471          }
5472          DU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5473       }
5474    }
5475 }
5476 /*******************************************************************
5477  *
5478  * @brief Frees memory allocated for initialUplinkBWP
5479  *
5480  * @details
5481  *
5482  *    Function : FreeinitialUplinkBWP
5483  *
5484  *    Functionality: Deallocating memory of initialUplinkBWP
5485  *
5486  * @params[in] UplinkConfig_t *ulCfg
5487  *
5488  * @return void
5489  *
5490  *
5491  * ****************************************************************/
5492 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
5493 {
5494    BWP_UplinkDedicated_t *ulBwp=NULLP;
5495    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
5496
5497    if(ulCfg->initialUplinkBWP)
5498    {
5499       ulBwp=ulCfg->initialUplinkBWP;
5500       if(ulCfg->firstActiveUplinkBWP_Id)
5501       {
5502          if(ulCfg->pusch_ServingCellConfig)
5503          {
5504             puschCfg=ulCfg->pusch_ServingCellConfig;
5505             if(puschCfg->choice.setup)
5506             {
5507                if(puschCfg->choice.setup->ext1)
5508                {
5509                   DU_FREE(puschCfg->choice.setup->ext1->\
5510                         processingType2Enabled,sizeof(BOOLEAN_t));
5511                   DU_FREE(puschCfg->choice.setup->ext1->\
5512                         maxMIMO_Layers,sizeof(long));
5513                   DU_FREE(puschCfg->choice.setup->ext1, \
5514                         sizeof(struct PUSCH_ServingCellConfig__ext1));
5515                }
5516                DU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5517             }
5518             DU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5519          }
5520          DU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5521       }
5522       FreeInitialUlBWP(ulBwp);
5523       DU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5524    }
5525 }
5526 /*******************************************************************
5527  *
5528  * @brief Frees emmory allocated for BWPDlDedPdschCfg
5529  *
5530  * @details
5531  *
5532  *    Function : FreeBWPDlDedPdschCfg
5533  *
5534  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
5535  *
5536  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5537  *
5538  * @return void
5539  *
5540  *
5541  * ****************************************************************/
5542 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
5543 {
5544    struct PDSCH_Config *pdschCfg=NULLP;
5545    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
5546    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
5547    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
5548
5549    if(dlBwp->pdsch_Config->choice.setup)
5550    {
5551       pdschCfg=dlBwp->pdsch_Config->choice.setup;
5552       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
5553       {
5554          if(pdschCfg->pdsch_TimeDomainAllocationList)
5555          {
5556             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
5557             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
5558             {
5559                prbBndlType=&pdschCfg->prb_BundlingType;
5560                DU_FREE(prbBndlType->choice.staticBundling,\
5561                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
5562                DU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
5563             }
5564             FreePdschTimeDomAllocList(timeDomAllocList);
5565             DU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
5566                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
5567          }
5568          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
5569          if(dmrsDlCfg->choice.setup)
5570          {
5571             DU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
5572                   sizeof(long));
5573             DU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
5574          }
5575          DU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
5576                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
5577       }
5578       DU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
5579    }
5580 }
5581 /*******************************************************************
5582  *
5583  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
5584  *
5585  * @details
5586  *
5587  *    Function : FreeBWPDlDedPdcchCfg
5588  *
5589  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
5590  *
5591  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5592  *
5593  * @return void
5594  *
5595  *
5596  * ****************************************************************/
5597 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
5598 {
5599    uint8_t idx1=0;
5600    uint8_t idx2=0;
5601    struct PDCCH_Config *pdcchCfg=NULLP;
5602    struct ControlResourceSet *controlRSet=NULLP;
5603    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
5604
5605    if(dlBwp->pdcch_Config->choice.setup)
5606    {
5607       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
5608       if(pdcchCfg->controlResourceSetToAddModList)
5609       {
5610          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
5611          if(controlRSetList->list.array)
5612          {
5613             controlRSet = controlRSetList->list.array[idx2];
5614             if(controlRSet)
5615             {
5616                if(controlRSet->frequencyDomainResources.buf)
5617                {
5618                   if(controlRSet->pdcch_DMRS_ScramblingID)
5619                   {
5620                      if(pdcchCfg->searchSpacesToAddModList)
5621                      {
5622                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
5623                         DU_FREE(pdcchCfg->searchSpacesToAddModList, \
5624                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
5625                      }
5626                      DU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
5627                   }
5628                   DU_FREE(controlRSet->frequencyDomainResources.buf, \
5629                         controlRSet->frequencyDomainResources.size);
5630                }
5631             }
5632             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
5633             {
5634                DU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
5635             }
5636             DU_FREE(controlRSetList->list.array, controlRSetList->list.size);
5637          }
5638          DU_FREE(pdcchCfg->controlResourceSetToAddModList, \
5639                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
5640       }
5641       DU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
5642    }
5643 }
5644
5645 /*******************************************************************
5646  *
5647  * @brief Frees emmory allocated for DUToCURRCContainer
5648  *
5649  * @details
5650  *
5651  *    Function : FreeMemDuToCuRrcCont
5652  *
5653  *    Functionality: Deallocating memory of DuToCuRrcContainer
5654  *
5655  * @params[in] DuToCuRRCContainer, DuToCuRRCContainer
5656  *
5657  * @return ROK     - success
5658  *         RFAILED - failure
5659  *
5660  * ****************************************************************/
5661 uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg)
5662 {
5663    uint8_t idx=0;
5664    SpCellConfig_t *spCellCfg=NULLP;
5665    ServingCellConfig_t *srvCellCfg=NULLP;
5666    BWP_DownlinkDedicated_t *dlBwp=NULLP;
5667    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
5668    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
5669    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
5670    struct RLC_Config *rlcConfig=NULLP;
5671    struct LogicalChannelConfig *macLcConfig=NULLP;
5672    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
5673    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
5674    struct TAG_Config *tagConfig=NULLP;
5675    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
5676    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
5677    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
5678
5679    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
5680    if(rlcBearerList)
5681    {
5682       if(rlcBearerList->list.array)
5683       {
5684          for(idx=0; idx<rlcBearerList->list.count; idx++)
5685          {
5686             if(rlcBearerList->list.array[idx])
5687             {
5688                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
5689                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
5690                if(rlcConfig)
5691                {
5692                   if(rlcConfig->choice.am)
5693                   {
5694                      DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5695                      DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5696                      DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
5697                   }
5698                   DU_FREE(rlcConfig, sizeof(struct RLC_Config));
5699                }
5700                DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
5701                if(macLcConfig)
5702                {
5703                   if(macLcConfig->ul_SpecificParameters)
5704                   {
5705                      DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
5706                      DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
5707                      DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
5708                   }
5709                   DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
5710                }
5711                DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
5712             }
5713          }
5714          DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
5715       }
5716       DU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5717    }
5718
5719    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
5720    if(macCellGrpCfg)
5721    {
5722       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
5723       if(schedulingRequestConfig)
5724       {
5725          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
5726          if(schReqList)
5727          {
5728             if(schReqList->list.array)
5729             {
5730                for(idx=0;idx<schReqList->list.count; idx++)
5731                {
5732                   if(schReqList->list.array[idx])
5733                   {
5734                      DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
5735                      DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
5736                   }
5737                }
5738                DU_FREE(schReqList->list.array, schReqList->list.size);
5739             }
5740             DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
5741                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
5742             DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5743       }
5744       if(macCellGrpCfg->bsr_Config)
5745       {
5746          DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5747       }
5748       tagConfig = macCellGrpCfg->tag_Config;
5749       if(tagConfig)
5750       {
5751          tagList = tagConfig->tag_ToAddModList;
5752          if(tagList)
5753          {
5754             if(tagList->list.array)
5755             {
5756                for(idx=0; idx<tagList->list.count; idx++)
5757                {
5758                   DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
5759                }
5760                DU_FREE(tagList->list.array, tagList->list.size);
5761             }
5762             DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
5763          }
5764          DU_FREE(tagConfig, sizeof(struct TAG_Config));
5765       }
5766
5767       phrConfig = macCellGrpCfg->phr_Config;
5768       if(phrConfig)
5769       {
5770          DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
5771          DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
5772       }
5773
5774       DU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
5775    }
5776
5777    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
5778    if(phyCellGrpCfg)
5779    {
5780       DU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5781       DU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
5782    }
5783
5784    spCellCfg = cellGrpCfg->spCellConfig;
5785    if(spCellCfg)
5786    {
5787       if(spCellCfg->servCellIndex)
5788       {
5789          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
5790          {
5791             if(spCellCfg->spCellConfigDedicated)
5792             {
5793                srvCellCfg = spCellCfg->spCellConfigDedicated;
5794                if(srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
5795                {
5796                   if(srvCellCfg->initialDownlinkBWP)
5797                   {
5798                      dlBwp = srvCellCfg->initialDownlinkBWP;
5799                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
5800                      {
5801                         if(srvCellCfg->defaultDownlinkBWP_Id)
5802                         {
5803                            if(srvCellCfg->uplinkConfig)
5804                            {
5805                               if(srvCellCfg->pdsch_ServingCellConfig)
5806                               {
5807                                  pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
5808                                  if(pdschCfg->choice.setup)
5809                                  {
5810                                     DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
5811                                     DU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5812                                  }
5813                                  DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
5814                                           ServingCellConfig__pdsch_ServingCellConfig));
5815                               }
5816                               FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
5817                               DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
5818                            }
5819                            DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
5820                         }
5821                         DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
5822                      }
5823                      if(dlBwp->pdcch_Config)
5824                      {
5825                         if(dlBwp->pdsch_Config)
5826                         {
5827                            FreeBWPDlDedPdschCfg(dlBwp);
5828                            DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
5829                         }
5830                         FreeBWPDlDedPdcchCfg(dlBwp);
5831                         DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
5832                      }
5833                      DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
5834                   }
5835                   DU_FREE(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
5836                }
5837                DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5838             }
5839             DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5840          }
5841          DU_FREE(spCellCfg->servCellIndex, sizeof(long));
5842       }
5843       DU_FREE(spCellCfg,sizeof(SpCellConfig_t));
5844    }
5845    return ROK;
5846 }
5847 /*******************************************************************
5848  *
5849  * @brief Builds DU To CU RRC Container
5850  *
5851  * @details
5852  *
5853  *    Function : BuildDuToCuRrcContainer
5854  *
5855  *    Functionality: Builds DuToCuRrcContainer
5856  *
5857  * @params[in] idx, index in F1AP msg
5858  *             DuToCuRRCContainer, DuToCuRRCContainer
5859  *
5860  * @return ROK     - success
5861  *         RFAILED - failure
5862  *
5863  * ****************************************************************/
5864 uint8_t BuildDuToCuRrcContainer(DUtoCURRCContainer_t *duToCuRrcContainer)
5865 {
5866    uint8_t  ret = ROK;
5867    CellGroupConfigRrc_t  cellGrpCfg;
5868    asn_enc_rval_t        encRetVal;
5869    memset(&cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
5870    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
5871
5872    while(true)
5873    {
5874       cellGrpCfg.cellGroupId = CELL_GRP_ID;
5875
5876       cellGrpCfg.rlc_BearerToAddModList = NULLP;
5877       DU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5878       if(!cellGrpCfg.rlc_BearerToAddModList)
5879       {
5880          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5881          ret = RFAILED;
5882          break;
5883       }
5884       if(BuildRlcBearerToAddModList(cellGrpCfg.rlc_BearerToAddModList) != ROK)
5885       {
5886          DU_LOG("\nERROR  -->  F1AP : BuildRlcBearerToAddModList failed");
5887          ret = RFAILED;
5888          break;
5889       }
5890
5891       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
5892       cellGrpCfg.mac_CellGroupConfig = NULLP;
5893       DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
5894       if(!cellGrpCfg.mac_CellGroupConfig)
5895       {
5896          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5897          ret = RFAILED;
5898          break;
5899       }
5900       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
5901       {
5902          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
5903          ret = RFAILED;
5904          break;
5905       }
5906
5907       cellGrpCfg.physicalCellGroupConfig = NULLP;
5908       DU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
5909       if(!cellGrpCfg.physicalCellGroupConfig)
5910       {
5911          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5912          ret = RFAILED;
5913          break;
5914       }
5915       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
5916       {
5917          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
5918          ret = RFAILED;
5919          break;
5920       }
5921
5922       cellGrpCfg.spCellConfig = NULLP;
5923       DU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
5924       if(!cellGrpCfg.spCellConfig)
5925       {
5926          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5927          ret = RFAILED;
5928          break;
5929       }
5930       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
5931       {
5932          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
5933          ret = RFAILED;
5934          break;
5935       }
5936
5937       cellGrpCfg.sCellToAddModList = NULLP;
5938       cellGrpCfg.sCellToReleaseList = NULLP;
5939       cellGrpCfg.ext1 = NULLP;
5940
5941       /* encode cellGrpCfg into duToCuRrcContainer */
5942       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
5943       memset(encBuf, 0, ENC_BUF_MAX_LEN);
5944       encBufSize = 0;
5945       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
5946       /* Encode results */
5947       if(encRetVal.encoded == ENCODE_FAIL)
5948       {
5949          DU_LOG( "\nERROR  --> F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
5950                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5951          ret = RFAILED;
5952          break;
5953       }
5954       else
5955       {
5956          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
5957          for(int i=0; i< encBufSize; i++)
5958          {
5959             printf("%x",encBuf[i]);
5960          }
5961       }
5962
5963       duToCuRrcContainer->size = encBufSize;
5964       DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
5965       if(!duToCuRrcContainer->buf)
5966       {
5967          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
5968          ret = RFAILED;
5969          break;
5970       }
5971       if(ret == ROK)
5972       {
5973          memcpy(duToCuRrcContainer->buf, encBuf, duToCuRrcContainer->size);
5974       }
5975       break;
5976    }
5977    FreeMemDuToCuRrcCont(&cellGrpCfg);
5978    return ret;
5979 }
5980
5981 /*******************************************************************
5982  *
5983  * @brief Free memory allocated in InitialULRRCMessage
5984  *
5985  * @details
5986  *
5987  *    Function : freeInitUlRrcMsgTransfer
5988  *
5989  *    Functionality: Free memory allocated in InitialULRRCMessage
5990  *
5991  * @params[in]F1AP_PDU_t  *f1apMsg)
5992  *
5993  * @return ROK     - success
5994  *         RFAILED - failure
5995  *
5996  * ****************************************************************/
5997
5998 uint8_t freeInitUlRrcMsgTransfer(F1AP_PDU_t  *f1apMsg)
5999 {
6000    uint8_t ieIdx, arrIdx;
6001    InitialULRRCMessageTransfer_t *initULRRCMsg=NULLP;
6002
6003    if(f1apMsg)
6004    {
6005       if(f1apMsg->choice.initiatingMessage)
6006       {
6007          initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.\
6008             choice.InitialULRRCMessageTransfer;
6009          if(initULRRCMsg->protocolIEs.list.array)
6010          {
6011             for(ieIdx = 0; ieIdx < initULRRCMsg->protocolIEs.list.count; ieIdx++)
6012             {
6013                switch(initULRRCMsg->protocolIEs.list.array[ieIdx]->id)
6014                {
6015                   case ProtocolIE_ID_id_NRCGI:
6016                   {
6017                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf)
6018                      {
6019                         if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf)
6020                         {
6021                            DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf,\
6022                            initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.size);
6023                         }
6024                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf,\
6025                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.size);
6026                      }
6027                      break;
6028                   }
6029                   case ProtocolIE_ID_id_RRCContainer:
6030                   {
6031                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
6032                      {
6033                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,\
6034                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
6035                      }
6036                      break;
6037                   }
6038                   case ProtocolIE_ID_id_DUtoCURRCContainer:
6039                   {
6040                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf)
6041                      {
6042                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf,
6043                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.size);
6044                      }
6045                      break;
6046                   }
6047                   default:
6048                      break;
6049                }
6050              }
6051              for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
6052              {
6053                 if(initULRRCMsg->protocolIEs.list.array[arrIdx])
6054                 {
6055                    DU_FREE(initULRRCMsg->protocolIEs.list.array[arrIdx],\
6056                       sizeof(InitialULRRCMessageTransferIEs_t));
6057                 }
6058              }
6059              DU_FREE(initULRRCMsg->protocolIEs.list.array, initULRRCMsg->protocolIEs.list.size);
6060           }
6061          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
6062       }
6063       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
6064    }
6065    else
6066    {
6067       DU_LOG("\nERROR  -->  DU_APP : Recevied F1ap Pdu is null at freeInitUlRrcMsgTransfer()");
6068       return RFAILED;
6069    }
6070    return ROK;
6071 }
6072
6073 /*******************************************************************
6074  *
6075  * @brief Builds and sends the InitialULRRCMessage
6076  *
6077  * @details
6078  *
6079  *    Function : BuildAndSendInitialRrcMsgTransfer
6080  *
6081  *    Functionality: Constructs the Initial UL RRC Message Transfer and sends
6082  *                   it to the CU through SCTP.
6083  *
6084  * @params[in]
6085  *
6086  * @return ROK     - success
6087  *         RFAILED - failure
6088  *
6089  * ****************************************************************/
6090 uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti,
6091       uint16_t rrcContSize, uint8_t *rrcContainer)
6092 {
6093    uint8_t   ret;
6094    uint8_t   elementCnt;
6095    uint8_t   ieIdx;
6096    asn_enc_rval_t  encRetVal;
6097    F1AP_PDU_t  *f1apMsg = NULLP;
6098    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
6099    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
6100
6101    while(true)
6102    {
6103       DU_LOG("\n INFO   -->  F1AP : Building RRC Setup Request\n");
6104       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
6105       if(f1apMsg == NULLP)
6106       {
6107          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
6108          break;
6109       }
6110       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
6111       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
6112       if(f1apMsg->choice.initiatingMessage == NULLP)
6113       {
6114          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
6115          break;
6116       }
6117       f1apMsg->choice.initiatingMessage->procedureCode =\
6118                                                         ProcedureCode_id_InitialULRRCMessageTransfer;
6119       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
6120       f1apMsg->choice.initiatingMessage->value.present = \
6121                                                          InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
6122       initULRRCMsg =\
6123                     &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
6124       elementCnt = 5;
6125       initULRRCMsg->protocolIEs.list.count = elementCnt;
6126       initULRRCMsg->protocolIEs.list.size = \
6127                                             elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *);
6128       /* Initialize the F1Setup members */
6129       DU_ALLOC(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
6130       if(initULRRCMsg->protocolIEs.list.array == NULLP)
6131       {
6132          DU_LOG(" ERROR  -->  F1AP : Memory allocation for\
6133                RRCSetupRequestMessageTransferIEs failed");
6134          break;
6135       }
6136       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
6137       {
6138          DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx],\
6139                sizeof(InitialULRRCMessageTransferIEs_t));
6140          if(initULRRCMsg->protocolIEs.list.array[ieIdx] == NULLP)
6141          {
6142             break;
6143          }
6144       }
6145       ieIdx = 0;
6146       /*GNB DU UE F1AP ID*/
6147       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6148                                                         ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
6149       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  = Criticality_reject;
6150       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
6151                                                                   InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
6152       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
6153
6154
6155       /*NRCGI*/
6156       ieIdx++;
6157       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6158                                                         ProtocolIE_ID_id_NRCGI;
6159       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  =Criticality_reject;
6160       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
6161                                                                   InitialULRRCMessageTransferIEs__value_PR_NRCGI;
6162
6163       ret =\
6164            BuildNrcgi(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
6165       if(ret!=ROK)
6166       {
6167          break;
6168       }
6169
6170       /*CRNTI*/
6171       ieIdx++;
6172       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6173                                                         ProtocolIE_ID_id_C_RNTI;
6174       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6175       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6176                                                                  InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
6177       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.C_RNTI = crnti;
6178
6179       /*RRCContainer*/
6180       ieIdx++;
6181       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6182                                                         ProtocolIE_ID_id_RRCContainer;
6183       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6184       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6185                                                                  InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
6186
6187       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = rrcContSize;
6188       DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
6189             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size)
6190       if(!initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
6191       {
6192          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
6193          break;
6194
6195       }
6196       memcpy(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, rrcContainer,
6197             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
6198
6199
6200       /*DUtoCURRCContainer*/
6201       ieIdx++;
6202       initULRRCMsg->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCContainer;
6203       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6204       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6205                                                                  InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
6206
6207       ret = BuildDuToCuRrcContainer(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer);
6208       if(ret != ROK)
6209       {
6210          break;
6211       }
6212
6213       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
6214
6215       /* Encode the F1SetupRequest type as APER */
6216       memset(encBuf, 0, ENC_BUF_MAX_LEN);
6217       encBufSize = 0;
6218       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
6219       /* Encode results */
6220       if(encRetVal.encoded == ENCODE_FAIL)
6221       {
6222          DU_LOG( "\nERROR  --> F1AP : Could not encode Initial UL RRC Message Transfer\
6223                structure (at %s)\n",encRetVal.failed_type ? \
6224                encRetVal.failed_type->name : "unknown");
6225          ret = RFAILED;
6226          break;
6227       }
6228       else
6229       {
6230
6231          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for Initial UL RRC\
6232                Message transfer\n");
6233          for(int i=0; i< encBufSize; i++)
6234          {
6235             printf("%x",encBuf[i]);
6236          }
6237       }
6238       /* Sending  msg  */
6239       if(sendF1APMsg() != ROK)
6240       {
6241          DU_LOG("\nERROR  -->  F1AP : Sending Initial UL RRC Message Transfer Failed");
6242          ret = RFAILED;
6243          break;
6244       }
6245       break;
6246    }
6247    freeInitUlRrcMsgTransfer(f1apMsg);
6248    return ret;
6249 }/* End of BuildAndSendInitialRrcMsgTransfer*/
6250
6251 /*****  UE SETUP REQUEST *****/
6252
6253 /*******************************************************************
6254  *
6255  * @brief Free Qos And Snssai Drb Info
6256  *
6257  * @details
6258  *
6259  *    Function : freeDrbQosAndSnssaiInfo
6260  *
6261  *    Functionality: Free Qos And Snssai Drb Info
6262  *
6263  * @params[in] LcCfg *lcCfg,
6264  * @return void
6265  *
6266  * ****************************************************************/
6267 void freeDrbQosAndSnssaiInfo(LcCfg *lcCfg)
6268 {
6269    if(lcCfg->snssai)
6270    {
6271       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6272    }
6273    if(lcCfg->drbQos)
6274    {
6275       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
6276    }
6277 }
6278
6279 /******************************************************************
6280 *
6281 * @brief Function to delete the RLC Lc cfg from UE APP DB
6282 *
6283 * @details
6284 *
6285 *  Function : freeRlcLcCfg
6286 *
6287 *  Functionality: Function to delete the RLC Lc cfg from UE APP DB
6288 *
6289 *
6290  *****************************************************************/
6291
6292 void freeRlcLcCfg(RlcBearerCfg *lcCfg)
6293 {
6294    switch(lcCfg->rlcMode)
6295    {
6296       case RLC_AM :
6297          {
6298             if(lcCfg->u.amCfg)
6299             {
6300                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.amCfg, sizeof(AmBearerCfg));
6301             }
6302             break;
6303          }
6304       case RLC_UM_BI_DIRECTIONAL :
6305          {
6306             if(lcCfg->u.umBiDirCfg)
6307             {
6308                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
6309             }
6310             break;
6311          }
6312       case RLC_UM_UNI_DIRECTIONAL_UL :
6313          {
6314             if(lcCfg->u.umUniDirUlCfg)
6315             {
6316                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
6317             }
6318             break;
6319
6320          }
6321       case RLC_UM_UNI_DIRECTIONAL_DL :
6322          {
6323             if(lcCfg->u.umUniDirDlCfg)
6324             {
6325                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
6326             }
6327             break;
6328          }
6329       default:
6330          DU_LOG("\nERROR  -->  DU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
6331          break;
6332    }
6333    DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6334 }
6335
6336 /*******************************************************************
6337  *
6338  * @brief Function to free MacLcCfg
6339  *
6340  * @details
6341  *
6342  *    Function : freeMacLcCfg
6343  *
6344  *    Functionality: Function to free MacLcCfg
6345  *
6346  * @params[in] LcCfg *lcCfg,
6347  * @return void
6348  *
6349  * ****************************************************************/
6350
6351 void  freeMacLcCfg(LcCfg *lcCfg)
6352 {
6353     /* Deleting DRBQOS */
6354    if(lcCfg->drbQos)
6355    {
6356       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
6357    }
6358    /* Deleting SNSSAI */
6359    if(lcCfg->snssai)
6360    {
6361       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6362    }
6363 }
6364 /*******************************************************************
6365  *
6366  * @brief Free UE NR Capability received in UE Context setup request
6367  *
6368  * @details
6369  *
6370  *    Function : freeAperDecodeUeNrCapability
6371  *
6372  *    Functionality:
6373  *       Free UE NR Capability received in UE Context setup request
6374  *
6375  * @params[in]
6376  * @return ROK     - success
6377  *         RFAILED - failure
6378  *
6379  * ****************************************************************/
6380 void freeAperDecodeUeNrCapability(void *ueNrCapability)
6381 {
6382    uint8_t arrIdx =0;
6383    FeatureSets_t *featureSets =NULLP;
6384    UE_NR_Capability_t *ueNrCap = (UE_NR_Capability_t *)ueNrCapability;
6385
6386    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
6387    {
6388       for(arrIdx = 0; arrIdx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; arrIdx++)
6389       {
6390          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx])
6391             free(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx]);
6392       }
6393       free(ueNrCap->rf_Parameters.supportedBandListNR.list.array);
6394    }
6395
6396    if(ueNrCap->featureSets)
6397    {
6398       featureSets = ueNrCap->featureSets;
6399       if(featureSets->featureSetsDownlinkPerCC)
6400       {
6401          if(featureSets->featureSetsDownlinkPerCC->list.array)
6402          {
6403             for(arrIdx = 0; arrIdx < featureSets->featureSetsDownlinkPerCC->list.count; arrIdx++)
6404             {
6405                if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx])
6406                {
6407                   if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL)
6408                      free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL);
6409                   free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]);
6410                }
6411             }
6412             free(featureSets->featureSetsDownlinkPerCC->list.array);
6413          }
6414          free(featureSets->featureSetsDownlinkPerCC);
6415       }
6416       if(featureSets->featureSetsUplinkPerCC)
6417       {
6418          if(featureSets->featureSetsUplinkPerCC->list.array)
6419          {
6420             for(arrIdx = 0; arrIdx < featureSets->featureSetsUplinkPerCC->list.count; arrIdx++)
6421             {
6422                if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx])
6423                {
6424                   if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL)
6425                      free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL);
6426                   free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]);
6427                }
6428             }
6429             free(featureSets->featureSetsUplinkPerCC->list.array);
6430          }
6431          free(featureSets->featureSetsUplinkPerCC);
6432       }
6433       free(ueNrCap->featureSets);
6434    }
6435 }
6436
6437 /*******************************************************************
6438 *
6439 * @brief Function to free PdcchSearchSpcToAddModList
6440          where memory allocated by aper_decoder
6441 *
6442 * @details
6443 *
6444 *    Function : freeAperDecodePdcchSearchSpcToAddModList
6445 *
6446 *    Functionality: Function to free PdcchSearchSpcToAddModList
6447 *
6448 * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
6449 * @return void
6450 *
6451 * ****************************************************************/
6452
6453 void freeAperDecodePdcchSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
6454 {
6455    uint8_t searchSpcArrIdx=0;
6456    uint8_t searchSpcArrIdx1=0;
6457    struct  SearchSpace *searchSpc=NULLP;
6458
6459
6460    if(searchSpcList->list.array)
6461    {
6462       if(searchSpcList->list.array[searchSpcArrIdx1])
6463       {
6464          searchSpc = searchSpcList->list.array[searchSpcArrIdx1];
6465          if(searchSpc->controlResourceSetId)
6466          {
6467             if(searchSpc->monitoringSlotPeriodicityAndOffset)
6468             {
6469                if(searchSpc->monitoringSymbolsWithinSlot)
6470                {
6471                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
6472                   {
6473                      if(searchSpc->nrofCandidates)
6474                      {
6475                         if(searchSpc->searchSpaceType)
6476                         {
6477                            free(searchSpc->searchSpaceType->choice.ue_Specific);
6478                            free(searchSpc->searchSpaceType);
6479                         }
6480                         free(searchSpc->nrofCandidates);
6481                      }
6482                      free(searchSpc->monitoringSymbolsWithinSlot->buf);
6483                   }
6484                   free(searchSpc->monitoringSymbolsWithinSlot);
6485                }
6486                free(searchSpc->monitoringSlotPeriodicityAndOffset);
6487             }
6488             free(searchSpc->controlResourceSetId);
6489          }
6490       }
6491       for(searchSpcArrIdx = 0; searchSpcArrIdx < searchSpcList->list.count; searchSpcArrIdx++)
6492       {
6493          free(searchSpcList->list.array[searchSpcArrIdx]);
6494       }
6495       free(searchSpcList->list.array);
6496    }
6497 }
6498 /*******************************************************************
6499 *
6500 * @brief Function for free part for the memory allocated by aper_decoder
6501 *
6502 * @details
6503 *
6504 *    Function : freeAperDecodeBWPDlDedPdcchConfig
6505 *
6506 *    Functionality: Function to free BWPDlDedPdcchConfig
6507 *
6508 * @params[in]
6509 * @return void
6510 *
6511 * ****************************************************************/
6512
6513
6514 void freeAperDecodeBWPDlDedPdcchConfig(BWP_DownlinkDedicated_t *dlBwp)
6515 {
6516    uint8_t arrIdx1=0;
6517    uint8_t arrIdx2=0;
6518    struct PDCCH_Config *pdcchCfg=NULLP;
6519    struct ControlResourceSet *controlRSet=NULLP;
6520    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
6521
6522    if(dlBwp->pdcch_Config->choice.setup)
6523    {
6524       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
6525       if(pdcchCfg->controlResourceSetToAddModList)
6526       {
6527          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
6528          if(controlRSetList->list.array)
6529          {
6530             controlRSet = controlRSetList->list.array[arrIdx2];
6531             if(controlRSet)
6532             {
6533                if(controlRSet->frequencyDomainResources.buf)
6534                {
6535                   if(controlRSet->pdcch_DMRS_ScramblingID)
6536                   {
6537                      if(pdcchCfg->searchSpacesToAddModList)
6538                      {
6539                         freeAperDecodePdcchSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
6540                         free(pdcchCfg->searchSpacesToAddModList);
6541                      }
6542                      free(controlRSet->pdcch_DMRS_ScramblingID);
6543                   }
6544                   free(controlRSet->frequencyDomainResources.buf);
6545                }
6546             }
6547             for(arrIdx1 = 0; arrIdx1 <controlRSetList->list.count; arrIdx1++)
6548             {
6549                free(controlRSetList->list.array[arrIdx1]);
6550             }
6551             free(controlRSetList->list.array);
6552          }
6553          free(pdcchCfg->controlResourceSetToAddModList);
6554       }
6555       free(dlBwp->pdcch_Config->choice.setup);
6556    }
6557 }
6558 /*******************************************************************
6559 *
6560 * @brief Function to free PdschTimeDomAllocationList
6561 *     where the memory allocated by aper_decoder
6562 *
6563 * @details
6564 *
6565 *    Function : freeAperDecodePdschTimeDomAllocationList
6566 *
6567 *    Functionality: Function to free PdschTimeDomAllocationList
6568 *
6569 * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
6570 * @return void
6571 *
6572 * ****************************************************************/
6573
6574
6575 void freeAperDecodePdschTimeDomAllocationList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
6576 {
6577    uint8_t arrIdx=0;
6578
6579    if(timeDomAllocList->choice.setup)
6580    {
6581       if(timeDomAllocList->choice.setup->list.array)
6582       {
6583          for(arrIdx = 0; arrIdx <timeDomAllocList->choice.setup->list.count ; arrIdx++)
6584          {
6585             free(timeDomAllocList->choice.setup->list.array[arrIdx]);
6586          }
6587          free(timeDomAllocList->choice.setup->list.array);
6588       }
6589       free(timeDomAllocList->choice.setup);
6590    }
6591 }
6592
6593 /*******************************************************************
6594 *
6595 * @brief Function to free BWPDlDedPdschConfig
6596 *        where the memory allocated by aper_decoder
6597 *
6598 * @details
6599 *
6600 *    Function : freeAperDecodeBWPDlDedPdschConfig
6601 *
6602 *    Functionality: Function to free BWPDlDedPdschConfig
6603 *
6604 * @params[in] BWP_DownlinkDedicated_t *dlBwp
6605 * @return void
6606 *
6607 * ****************************************************************/
6608
6609
6610 void freeAperDecodeBWPDlDedPdschConfig(BWP_DownlinkDedicated_t *dlBwp)
6611 {
6612    struct PDSCH_Config *pdschCfg=NULLP;
6613    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
6614    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
6615    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
6616
6617    if(dlBwp->pdsch_Config->choice.setup)
6618    {
6619       pdschCfg=dlBwp->pdsch_Config->choice.setup;
6620       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
6621       {
6622          if(pdschCfg->pdsch_TimeDomainAllocationList)
6623          {
6624             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
6625             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
6626             {
6627                prbBndlType=&pdschCfg->prb_BundlingType;
6628                free(prbBndlType->choice.staticBundling);
6629                free(pdschCfg->maxNrofCodeWordsScheduledByDCI);
6630             }
6631             freeAperDecodePdschTimeDomAllocationList(timeDomAllocList);
6632             free(pdschCfg->pdsch_TimeDomainAllocationList);
6633          }
6634          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
6635          if(dmrsDlCfg->choice.setup)
6636          {
6637             free(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition);
6638             free(dmrsDlCfg->choice.setup);
6639          }
6640          free(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA);
6641       }
6642       free(dlBwp->pdsch_Config->choice.setup);
6643    }
6644 }
6645 /*******************************************************************
6646 *
6647 * @brief Function to free PuschTimeDomAllocListCfg
6648                  where the memory allocated by aper_decoder
6649 *
6650 * @details
6651 *
6652 *    Function : freeAperDecodePuschTimeDomAllocListCfg
6653 *
6654 *    Functionality: Function to free PuschTimeDomAllocListCfg
6655 *
6656 * @params[in] PUSCH_Config_t *puschCfg
6657 * @return void
6658 *
6659 * ****************************************************************/
6660
6661
6662 void freeAperDecodePuschTimeDomAllocListCfg(PUSCH_Config_t *puschCfg)
6663 {
6664    uint8_t arrIdx=0;
6665    uint8_t arrIdx1=0;
6666    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
6667
6668    if(puschCfg->pusch_TimeDomainAllocationList)
6669    {
6670       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
6671       if(timeDomAllocList_t->choice.setup)
6672       {
6673          if(timeDomAllocList_t->choice.setup->list.array)
6674          {
6675             free(timeDomAllocList_t->choice.setup->list.array[arrIdx1]->k2);
6676             for(arrIdx = 0; arrIdx<timeDomAllocList_t->choice.setup->list.count; arrIdx++)
6677             {
6678                free(timeDomAllocList_t->choice.setup->list.array[arrIdx]);
6679             }
6680             free(timeDomAllocList_t->choice.setup->list.array);
6681          }
6682          free(timeDomAllocList_t->choice.setup);
6683       }
6684       free(puschCfg->transformPrecoder);
6685       free(puschCfg->pusch_TimeDomainAllocationList);
6686    }
6687 }
6688 /*******************************************************************
6689 *
6690 * @brief Function to free InitialUlBWPConfig where memory allocated by aper_decoder
6691 *
6692 * @details
6693 *
6694 *    Function : freeAperDecodeInitialUlBWPConfig
6695 *
6696 *    Functionality: Function to free InitialUlBWPConfig
6697 *
6698 * @params[in]  BWP_UplinkDedicated_t *ulBwp
6699 * @return void
6700 *
6701 * ****************************************************************/
6702
6703
6704 void freeAperDecodeInitialUlBWPConfig(BWP_UplinkDedicated_t *ulBwp)
6705 {
6706    uint8_t  rSetIdx =0;
6707    uint8_t  rsrcIdx =0;
6708    SRS_Config_t   *srsCfg = NULLP;
6709    PUSCH_Config_t *puschCfg = NULLP;
6710    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
6711    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
6712    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
6713    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
6714
6715    if(ulBwp->pusch_Config)
6716    {
6717       if(ulBwp->pusch_Config->choice.setup)
6718       {
6719          puschCfg=ulBwp->pusch_Config->choice.setup;
6720          if(puschCfg->dataScramblingIdentityPUSCH)
6721          {
6722             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
6723             {
6724                freeAperDecodePuschTimeDomAllocListCfg(puschCfg);
6725                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
6726                if(dmrsUlCfg->choice.setup)
6727                {
6728                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
6729                   {
6730                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
6731                      {
6732                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0);
6733                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled);
6734                      }
6735                      free(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition);
6736                   }
6737                   free(dmrsUlCfg->choice.setup);
6738                }
6739                free(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA);
6740             }
6741             free(puschCfg->dataScramblingIdentityPUSCH);
6742          }
6743          free(ulBwp->pusch_Config->choice.setup);
6744       }
6745       free(ulBwp->pusch_Config);
6746
6747       /* Free SRS-Config */
6748       if(ulBwp->srs_Config)
6749       {
6750          if(ulBwp->srs_Config->choice.setup)
6751          {
6752             srsCfg = ulBwp->srs_Config->choice.setup;
6753
6754             /* Free Resource Set to add/mod list */
6755             if(srsCfg->srs_ResourceSetToAddModList)
6756             {
6757                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
6758                if(rsrcSetList->list.array)
6759                {
6760                   rSetIdx = 0;
6761
6762                   /* Free SRS resource Id list in this SRS resource set */
6763                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
6764                   {
6765                      rsrcIdList =
6766                         rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
6767
6768                      if(rsrcIdList->list.array)
6769                      {
6770                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count;
6771                               rsrcIdx++)
6772                         {
6773                            free(rsrcIdList->list.array[rsrcIdx]);
6774                         }
6775                         free(rsrcIdList->list.array);
6776                      }
6777                      free(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList);
6778                   }
6779
6780                   /* Free resource type info for this SRS resource set */
6781
6782                   free(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic);
6783
6784                   /* Free memory for each resource set */
6785                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
6786                   {
6787                      free(rsrcSetList->list.array[rSetIdx]);
6788                   }
6789                   free(rsrcSetList->list.array);
6790                }
6791                free(srsCfg->srs_ResourceSetToAddModList);
6792             }
6793
6794             /* Free resource to add/modd list */
6795             if(srsCfg->srs_ResourceToAddModList)
6796             {
6797                resourceList = srsCfg->srs_ResourceToAddModList;
6798                if(resourceList->list.array)
6799                {
6800                   rsrcIdx = 0;
6801
6802                   free(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2);
6803                   free(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic);
6804
6805                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
6806                   {
6807                      free(resourceList->list.array[rsrcIdx]);
6808                   }
6809                   free(resourceList->list.array);
6810                }
6811                free(srsCfg->srs_ResourceToAddModList);
6812             }
6813
6814             free(ulBwp->srs_Config->choice.setup);
6815          }
6816          free(ulBwp->srs_Config);
6817       }
6818    }
6819 }
6820 /*******************************************************************
6821 *
6822 * @brief Function to free initialUplinkBWPConfig where memory allocated by aper_decoder
6823 *
6824 * @details
6825 *
6826 *    Function : freeAperDecodeinitialUplinkBWPConfig
6827 *
6828 *    Functionality: Function to free initialUplinkBWPConfig
6829 *
6830 * @params[in] UplinkConfig_t *ulCfg
6831 * @return void
6832 *
6833 * ****************************************************************/
6834
6835
6836 void freeAperDecodeinitialUplinkBWPConfig(UplinkConfig_t *ulCfg)
6837 {
6838    BWP_UplinkDedicated_t *ulBwp=NULLP;
6839    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
6840
6841    if(ulCfg->initialUplinkBWP)
6842    {
6843       ulBwp=ulCfg->initialUplinkBWP;
6844       if(ulCfg->firstActiveUplinkBWP_Id)
6845       {
6846          if(ulCfg->pusch_ServingCellConfig)
6847          {
6848             puschCfg=ulCfg->pusch_ServingCellConfig;
6849             if(puschCfg->choice.setup)
6850             {
6851                if(puschCfg->choice.setup->ext1)
6852                {
6853                   free(puschCfg->choice.setup->ext1->processingType2Enabled);
6854                   free(puschCfg->choice.setup->ext1->maxMIMO_Layers);
6855                   free(puschCfg->choice.setup->ext1);
6856                }
6857                free(puschCfg->choice.setup);
6858             }
6859             free(ulCfg->pusch_ServingCellConfig);
6860          }
6861          free(ulCfg->firstActiveUplinkBWP_Id);
6862       }
6863       freeAperDecodeInitialUlBWPConfig(ulBwp);
6864       free(ulCfg->initialUplinkBWP);
6865    }
6866 }
6867
6868 /*******************************************************************
6869  *
6870  * @brief Function to free DuUeCfg
6871  *
6872  * @details
6873  *
6874  *    Function : freeDuUeCfg
6875  *
6876  *    Functionality: Function to free DuUeCfg
6877  *
6878  * @params[in] DuUeCfg *ueCfg
6879  * @return void
6880  *
6881  * ****************************************************************/
6882 void freeDuUeCfg(DuUeCfg *ueCfg)
6883 {
6884    uint8_t lcIdx = 0;
6885    uint8_t arrIdx = 0;
6886    SpCellConfig_t *spCellCfg = NULLP;
6887    ServingCellConfig_t *srvCellCfg = NULLP;
6888    BWP_DownlinkDedicated_t *dlBwp = NULLP;
6889    MAC_CellGroupConfig_t *macCellGrpCfg = NULLP;
6890    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
6891    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList = NULLP;
6892    struct RLC_Config *rlcConfig = NULLP;
6893    struct LogicalChannelConfig *macLcConfig = NULLP;
6894    struct SchedulingRequestConfig *schedulingRequestConfig = NULLP;
6895    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList = NULLP;
6896    struct TAG_Config *tagConfig = NULLP;
6897    struct TAG_Config__tag_ToAddModList *tagList = NULLP;
6898    struct MAC_CellGroupConfig__phr_Config *phrConfig = NULLP;
6899    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg = NULLP;
6900    CellGroupConfigRrc_t *cellGrpCfg = ueCfg->cellGrpCfg;
6901
6902    if(ueCfg->ueNrCapability)
6903    {
6904       freeAperDecodeUeNrCapability(ueCfg->ueNrCapability);
6905       DU_FREE(ueCfg->ueNrCapability, sizeof(UE_NR_Capability_t));
6906       ueCfg->ueNrCapability = NULLP;
6907    }
6908
6909    if(ueCfg->cellGrpCfg)
6910    {
6911
6912       rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6913       if(rlcBearerList)
6914       {
6915          if(rlcBearerList->list.array)
6916          {
6917             for(arrIdx=0; arrIdx<rlcBearerList->list.count; arrIdx++)
6918             {
6919                if(rlcBearerList->list.array[arrIdx])
6920                {
6921                   rlcConfig   = rlcBearerList->list.array[arrIdx]->rlc_Config;
6922                   macLcConfig = rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig;
6923
6924                   if(rlcBearerList->list.array[arrIdx]->servedRadioBearer)
6925                   {
6926                      free(rlcBearerList->list.array[arrIdx]->servedRadioBearer);
6927                   }
6928                   if(rlcConfig)
6929                   {
6930                      if(rlcConfig->choice.am)
6931                      {
6932                         free(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength);
6933                         free(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength);
6934                         free(rlcConfig->choice.am);
6935                      }
6936                      free(rlcBearerList->list.array[arrIdx]->rlc_Config);
6937                   }
6938                   if(macLcConfig)
6939                   {
6940                      if(macLcConfig->ul_SpecificParameters)
6941                      {
6942                         free(macLcConfig->ul_SpecificParameters->schedulingRequestID);
6943                         free(macLcConfig->ul_SpecificParameters->logicalChannelGroup);
6944                         free(macLcConfig->ul_SpecificParameters);
6945                      }
6946                      free(rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig);
6947                   }
6948                   free(rlcBearerList->list.array[arrIdx]);
6949                }
6950             }
6951             free(rlcBearerList->list.array);
6952          }
6953          free(cellGrpCfg->rlc_BearerToAddModList);
6954       }
6955
6956       macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
6957       if(macCellGrpCfg)
6958       {
6959          schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
6960          if(schedulingRequestConfig)
6961          {
6962             schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
6963             if(schReqList)
6964             {
6965                if(schReqList->list.array)
6966                {
6967                   for(arrIdx=0;arrIdx<schReqList->list.count; arrIdx++)
6968                   {
6969                      if(schReqList->list.array[arrIdx])
6970                      {
6971                         free(schReqList->list.array[arrIdx]->sr_ProhibitTimer);
6972                         free(schReqList->list.array[arrIdx]);
6973                      }
6974                   }
6975                   free(schReqList->list.array);
6976                }
6977                free(schedulingRequestConfig->schedulingRequestToAddModList);
6978             }
6979             free(macCellGrpCfg->schedulingRequestConfig);
6980          }
6981          if(macCellGrpCfg->bsr_Config)
6982          {
6983             free(macCellGrpCfg->bsr_Config);
6984          }
6985          tagConfig = macCellGrpCfg->tag_Config;
6986          if(tagConfig)
6987          {
6988             tagList = tagConfig->tag_ToAddModList;
6989             if(tagList)
6990             {
6991                if(tagList->list.array)
6992                {
6993                   for(arrIdx=0; arrIdx<tagList->list.count; arrIdx++)
6994                   {
6995                      free(tagList->list.array[arrIdx]);
6996                   }
6997                   free(tagList->list.array);
6998                }
6999                free(tagConfig->tag_ToAddModList);
7000             }
7001             free(tagConfig);
7002          }
7003
7004          phrConfig = macCellGrpCfg->phr_Config;
7005          if(phrConfig)
7006          {
7007             free(phrConfig->choice.setup);
7008             free(phrConfig);
7009          }
7010
7011          free(macCellGrpCfg);
7012       }
7013
7014       phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
7015       if(phyCellGrpCfg)
7016       {
7017          free(phyCellGrpCfg->p_NR_FR1);
7018          free(phyCellGrpCfg);
7019       }
7020
7021       spCellCfg = cellGrpCfg->spCellConfig;
7022       if(spCellCfg)
7023       {
7024          if(spCellCfg->servCellIndex)
7025          {
7026             if(spCellCfg->rlmInSyncOutOfSyncThreshold)
7027             {
7028                if(spCellCfg->spCellConfigDedicated)
7029                {
7030                   srvCellCfg = spCellCfg->spCellConfigDedicated;
7031                   if(srvCellCfg->initialDownlinkBWP)
7032                   {
7033                      dlBwp = srvCellCfg->initialDownlinkBWP;
7034                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
7035                      {
7036                         if(srvCellCfg->defaultDownlinkBWP_Id)
7037                         {
7038                            if(srvCellCfg->uplinkConfig)
7039                            {
7040
7041                               if(srvCellCfg->pdsch_ServingCellConfig)
7042                               {
7043                                  pdschCfg=
7044                                     srvCellCfg->pdsch_ServingCellConfig;
7045                                  if(pdschCfg->choice.setup)
7046                                  {
7047
7048                                     free(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH);
7049                                     free(pdschCfg->choice.setup);
7050                                  }
7051
7052                                  free(srvCellCfg->pdsch_ServingCellConfig);
7053                               }
7054
7055                               freeAperDecodeinitialUplinkBWPConfig(srvCellCfg->uplinkConfig);
7056                               free(srvCellCfg->uplinkConfig);
7057                            }
7058                            free(srvCellCfg->defaultDownlinkBWP_Id);
7059                         }
7060
7061                         free(srvCellCfg->firstActiveDownlinkBWP_Id);
7062                      }
7063                      if(dlBwp->pdcch_Config)
7064                      {
7065                         if(dlBwp->pdsch_Config)
7066                         {
7067                            freeAperDecodeBWPDlDedPdschConfig(dlBwp);
7068                            free(dlBwp->pdsch_Config);
7069                         }
7070                         freeAperDecodeBWPDlDedPdcchConfig(dlBwp);
7071                         free(dlBwp->pdcch_Config);
7072                      }
7073                      free(srvCellCfg->initialDownlinkBWP);
7074                   }
7075
7076                   free(spCellCfg->spCellConfigDedicated);
7077                }
7078                free(spCellCfg->rlmInSyncOutOfSyncThreshold);
7079             }
7080             free(spCellCfg->servCellIndex);
7081          }
7082          free(spCellCfg);
7083       }
7084       DU_FREE(ueCfg->cellGrpCfg, sizeof(CellGroupConfigRrc_t));
7085       ueCfg->cellGrpCfg = NULLP;
7086    }
7087    if(ueCfg->ambrCfg)
7088    {
7089       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->ambrCfg, sizeof(AmbrCfg));
7090    }
7091    for(lcIdx = 0; lcIdx < ueCfg->numRlcLcs; lcIdx++)
7092    {
7093       freeRlcLcCfg(&ueCfg->rlcLcCfg[lcIdx]);
7094    }
7095    for(lcIdx = 0; lcIdx < ueCfg->numMacLcs; lcIdx++)
7096    {
7097       freeMacLcCfg(&ueCfg->macLcCfg[lcIdx]);
7098    }
7099    for(lcIdx = 0; lcIdx < ueCfg->numDrb; lcIdx++)
7100    {
7101       DU_FREE(ueCfg->upTnlInfo[lcIdx].tnlCfg1, sizeof(GtpTnlCfg));
7102    }
7103 }
7104
7105 /*******************************************************************
7106  *
7107  * @brief Function to free UecontextSetupDb
7108  *
7109  * @details
7110  *
7111  *    Function : freeF1UeDb
7112  *
7113  *    Functionality: Function to free UecontextSetupDb
7114  *
7115  * @params[in] UecontextSetupDb *
7116  * @return void
7117  *
7118  * ****************************************************************/
7119
7120 void freeF1UeDb(F1UeContextSetupDb *f1UeDb)
7121 {
7122
7123    if(f1UeDb->dlRrcMsg)
7124    {
7125       if(f1UeDb->dlRrcMsg->rrcMsgPdu)
7126       {
7127         //DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,\
7128                f1UeDb->dlRrcMsg->rrcMsgPdu, f1UeDb->dlRrcMsg->rrcMsgSize);
7129       }
7130       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
7131    }
7132    freeDuUeCfg(&f1UeDb->duUeCfg);
7133    memset(f1UeDb, 0, sizeof(F1UeContextSetupDb));
7134    DU_FREE(f1UeDb, sizeof(F1UeContextSetupDb));
7135 }
7136
7137 /*******************************************************************
7138  *
7139  * @brief Function to build Am cfg Info
7140  *
7141  * @details
7142  *
7143  *    Function : extractRlcAmCfg
7144  *
7145  *    Functionality: Function to build Am cfg Info
7146  *
7147  * @params[in] AmBearerCfg *
7148  *             void *
7149  *
7150  * @return ROK/RFAILED
7151  *
7152  * ****************************************************************/
7153
7154 void extractRlcAmCfg(AmBearerCfg *amCfgToSet, struct RLC_Config__am *rlcAmCfg)
7155 {
7156    if(rlcAmCfg)
7157    {
7158       /* UL AM */
7159       if(rlcAmCfg->dl_AM_RLC.sn_FieldLength)
7160       {
7161          amCfgToSet->ulAmCfg.snLenUl = *(rlcAmCfg->dl_AM_RLC.sn_FieldLength);
7162          /*TODO: Check the timer value when sent by real CU */
7163          amCfgToSet->ulAmCfg.reAssemTmr = rlcAmCfg->dl_AM_RLC.t_Reassembly;
7164          amCfgToSet->ulAmCfg.statProhTmr = rlcAmCfg->dl_AM_RLC.t_StatusProhibit;
7165       }
7166
7167       /* DL AM */
7168       if(rlcAmCfg->ul_AM_RLC.sn_FieldLength)
7169       {
7170          amCfgToSet->dlAmCfg.snLenDl = *(rlcAmCfg->ul_AM_RLC.sn_FieldLength);
7171          amCfgToSet->dlAmCfg.pollRetxTmr = rlcAmCfg->ul_AM_RLC.t_PollRetransmit;
7172          amCfgToSet->dlAmCfg.pollPdu   = rlcAmCfg->ul_AM_RLC.pollPDU;
7173          amCfgToSet->dlAmCfg.pollByte  = rlcAmCfg->ul_AM_RLC.pollByte;
7174          amCfgToSet->dlAmCfg.maxRetxTh = rlcAmCfg->ul_AM_RLC.maxRetxThreshold;
7175       }
7176    }
7177 }
7178
7179 /*******************************************************************
7180  *
7181  * @brief Function to build Um Bi Info
7182  *
7183  * @details
7184  *
7185  *    Function : extractRlcUmBiCfg
7186  *
7187  *    Functionality: Function to build Um Bi Info
7188  *
7189  * @params[in] UmBiDirBearerCfg *
7190  *             void *
7191  *
7192  * @return ROK/RFAILED
7193  *
7194  * ****************************************************************/
7195
7196 void extractRlcUmBiCfg(UmBiDirBearerCfg *umBiCfgToSet, struct RLC_Config__um_Bi_Directional *rlcBiCfg)
7197 {
7198    if(rlcBiCfg)
7199    {
7200       /* UL UM BI DIR Cfg */
7201       if(rlcBiCfg->dl_UM_RLC.sn_FieldLength)
7202       {
7203          umBiCfgToSet->ulUmCfg.snLenUlUm  = *(rlcBiCfg->dl_UM_RLC.sn_FieldLength);
7204          umBiCfgToSet->ulUmCfg.reAssemTmr = rlcBiCfg->dl_UM_RLC.t_Reassembly;
7205       }
7206
7207       /* DL UM BI DIR Cfg */
7208       if(rlcBiCfg->ul_UM_RLC.sn_FieldLength)
7209          umBiCfgToSet->dlUmCfg.snLenDlUm  = *(rlcBiCfg->ul_UM_RLC.sn_FieldLength);
7210    }
7211 }
7212
7213 /*******************************************************************
7214  *
7215  * @brief Function to build Um Ul Info
7216  *
7217  * @details
7218  *
7219  *    Function : extractRlcUmUlCfg
7220  *
7221  *    Functionality: Function to build Um Ul Info
7222  *
7223  * @params[in] UmUniDirUlBearerCfg *
7224  *             void *
7225  *
7226  * @return ROK/RFAILED
7227  *
7228  * ****************************************************************/
7229
7230 void extractRlcUmUlCfg(UmUniDirUlBearerCfg *umUlCfgToSet, struct RLC_Config__um_Uni_Directional_DL *umUlCfg)
7231 {
7232    if(umUlCfg)
7233    {
7234       if(umUlCfg->dl_UM_RLC.sn_FieldLength)
7235       {
7236          umUlCfgToSet->ulUmCfg.snLenUlUm  = *(umUlCfg->dl_UM_RLC.sn_FieldLength);
7237          umUlCfgToSet->ulUmCfg.reAssemTmr = umUlCfg->dl_UM_RLC.t_Reassembly;
7238       }
7239    }
7240 }
7241
7242 /*******************************************************************
7243  *
7244  * @brief Function to build Um Uni Dl Info
7245  *
7246  * @details
7247  *
7248  *    Function : extractRlcUmDlCfg
7249  *
7250  *    Functionality: Function to build Um Uni Dl Info
7251  *
7252  * @params[in] UmUniDirDlBearerCfg *
7253  *             void *
7254  *
7255  * @return ROK/RFAILED
7256  *
7257  * ****************************************************************/
7258 void extractRlcUmDlCfg(UmUniDirDlBearerCfg *umDlCfgToSet, struct RLC_Config__um_Uni_Directional_UL *umDlCfg)
7259 {
7260    if(umDlCfg)
7261    {
7262       if(umDlCfg->ul_UM_RLC.sn_FieldLength)
7263          umDlCfgToSet->dlUmCfg.snLenDlUm  = *(umDlCfg->ul_UM_RLC.sn_FieldLength);
7264    }
7265 }
7266
7267 /*******************************************************************
7268  *
7269  * @brief Function to extractRlcModeCfg
7270  *
7271  * @details
7272  *
7273  *    Function : extractRlcModeCfg
7274  *
7275  *    Functionality: Function to extractRlcModeCfg
7276  *
7277  * @params[in] RLC_Config_t *
7278  *             RlcBearerCfg *
7279  *             void  *
7280  * @return ROK/RFAILED
7281  *
7282  * ****************************************************************/
7283 void extractRlcModeCfg(uint8_t rlcMode, RlcBearerCfg *rlcDbCfg, RLC_Config_t *lcCfg)
7284 {
7285    if(lcCfg)
7286    {
7287       switch(rlcMode)
7288       {
7289          case RLC_AM :
7290             {
7291                if(lcCfg->choice.am)
7292                {
7293                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.amCfg, sizeof(AmBearerCfg));
7294                   if(rlcDbCfg->u.amCfg)
7295                      extractRlcAmCfg(rlcDbCfg->u.amCfg, lcCfg->choice.am);
7296                }
7297                break;
7298             }
7299          case RLC_UM_BI_DIRECTIONAL :
7300             {
7301                if(lcCfg->choice.um_Bi_Directional)
7302                {
7303                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
7304                   if(rlcDbCfg->u.umBiDirCfg)
7305                      extractRlcUmBiCfg(rlcDbCfg->u.umBiDirCfg, lcCfg->choice.um_Bi_Directional);
7306                }
7307                break;
7308             }
7309          case RLC_UM_UNI_DIRECTIONAL_UL :
7310             {
7311                if(lcCfg->choice.um_Uni_Directional_DL)
7312                {
7313                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
7314                   if(rlcDbCfg->u.umUniDirUlCfg)
7315                      extractRlcUmUlCfg(rlcDbCfg->u.umUniDirUlCfg, lcCfg->choice.um_Uni_Directional_DL);
7316                }
7317                break;
7318             }
7319          case RLC_UM_UNI_DIRECTIONAL_DL :
7320             {
7321                if(lcCfg->choice.um_Uni_Directional_UL)
7322                {
7323                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
7324                   if(rlcDbCfg->u.umUniDirDlCfg)
7325                      extractRlcUmDlCfg(rlcDbCfg->u.umUniDirDlCfg, lcCfg->choice.um_Uni_Directional_UL);
7326                }
7327                break;
7328             }
7329          default:
7330             DU_LOG("\nERROR  -->  DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
7331             break;
7332       }
7333    }
7334 }
7335
7336 /*******************************************************************
7337  *
7338  * @brief Function to extract extractUlLcCfg
7339  *
7340  * @details
7341  *
7342  *    Function : extractUlLcCfg
7343  *
7344  *    Functionality: Function to extract extractUlLcCfg
7345  *
7346  * @params[in] UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg
7347  * @return void
7348  *
7349  * ****************************************************************/
7350
7351 void extractUlLcCfg(UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg)
7352 {
7353    if(ulLcCfg)
7354    {
7355       if(ulLcCfg->ul_SpecificParameters)
7356       {
7357          f1UlLcCfg->priority = \
7358             ulLcCfg->ul_SpecificParameters->priority;
7359       if(ulLcCfg->ul_SpecificParameters->logicalChannelGroup)
7360       {
7361          f1UlLcCfg->lcGroup = \
7362            *(ulLcCfg->ul_SpecificParameters->logicalChannelGroup);
7363       }
7364       if(ulLcCfg->ul_SpecificParameters->schedulingRequestID)
7365       {
7366          f1UlLcCfg->schReqId = \
7367            *(ulLcCfg->ul_SpecificParameters->schedulingRequestID);
7368       }
7369       f1UlLcCfg->pbr = \
7370          ulLcCfg->ul_SpecificParameters->prioritisedBitRate;
7371       f1UlLcCfg->bsd = \
7372          ulLcCfg->ul_SpecificParameters->bucketSizeDuration;
7373       }
7374    }
7375 }
7376
7377 /*******************************************************************
7378 *
7379 * @brief Function to extract Snssai Cfg Info from CU
7380 *
7381 * @details
7382 *
7383 *    Function : extractDrbSnssaiCfg
7384 *
7385 *    Functionality: Function to extract Drb Snssai Cfg Info from CU
7386 *
7387 * @params[in] DRB_Information_t *drbInfo, Snssai  *snssai
7388 * @return ROK/RFAILED
7389 *
7390 * ****************************************************************/
7391
7392 uint8_t extractDrbSnssaiCfg(SNSSAI_t *RecvSnssai, Snssai **snssaiToBeShared)
7393 {
7394    if(!(*snssaiToBeShared))
7395    {
7396       DU_ALLOC_SHRABL_BUF((*snssaiToBeShared), sizeof(Snssai));
7397       if(snssaiToBeShared == NULLP)
7398       {
7399          DU_LOG("\nERROR  -->  DUAPP : extractDrbSnssaiCfg(): Memory failed at allocating for SNSSAI ");
7400          return RFAILED;
7401       }
7402    }
7403    if(RecvSnssai)
7404    {
7405       memcpy(&(*snssaiToBeShared)->sst, RecvSnssai->sST.buf, RecvSnssai->sST.size);
7406       if(RecvSnssai->sD)
7407       {
7408          memcpy((*snssaiToBeShared)->sd, RecvSnssai->sD->buf,  RecvSnssai->sD->size);
7409       }
7410       else
7411       {
7412          DU_LOG("\nERROR  -->  DUAPP : extractDrbSnssaiCfg(): Received Null pointer of Snssai->SD");
7413          return RFAILED;
7414       }
7415    }
7416    return ROK;
7417 }
7418
7419 /*******************************************************************
7420  *
7421  * @brief Function to procRlcLcCfg
7422  *
7423  * @details
7424  *
7425  *    Function : procRlcLcCfg
7426  *
7427  *    Functionality: Function to procRlcLcCfg
7428  *
7429  * @params[in] rbId, lcId, rbType, rlcMod
7430  *             RLC_Config_t *, RlcBearerCfg * ,
7431  * @return void
7432  *
7433  * ****************************************************************/
7434
7435 void procRlcLcCfg(uint8_t rbId, uint8_t lcId, uint8_t rbType, uint8_t rlcMode,\
7436    uint8_t configType, RLC_Config_t *f1RlcCfg, RlcBearerCfg *lcCfg, QoSInformation_t *qoSInformation)
7437 {
7438    DRB_Information_t *drbInfo;
7439
7440    lcCfg->rbId   = rbId;
7441    lcCfg->configType = configType;
7442
7443    if(rbType == RB_TYPE_SRB)
7444    {
7445       lcCfg->rbType = RB_TYPE_SRB;
7446       lcCfg->lcId   = rbId;
7447       lcCfg->lcType = LCH_DCCH;
7448       lcCfg->rlcMode = RLC_AM;
7449    }
7450    else if(rbType == RB_TYPE_DRB)
7451    {
7452       lcCfg->rbType = RB_TYPE_DRB;
7453       lcCfg->lcId   = lcId;
7454       lcCfg->lcType = LCH_DTCH;
7455       lcCfg->rlcMode = rlcMode;
7456    }
7457    if(f1RlcCfg) /* rlc mode config recived */
7458    {
7459       extractRlcModeCfg(lcCfg->rlcMode, lcCfg, f1RlcCfg);
7460    }
7461    if(qoSInformation != NULLP)
7462    {
7463       if(qoSInformation->present == QoSInformation_PR_choice_extension)
7464       {
7465          if(qoSInformation->choice.choice_extension->value.present ==\
7466                QoSInformation_ExtIEs__value_PR_DRB_Information)
7467          {
7468             drbInfo = &qoSInformation->choice.choice_extension->value.choice.DRB_Information;
7469             if(extractDrbSnssaiCfg(&drbInfo->sNSSAI, &lcCfg->snssai) != ROK)
7470             {
7471                DU_LOG("\nERROR  -->  DUAPP: Unable to extract Snssai information at procRlcLcCfg()");
7472                return RFAILED;
7473             }
7474          }
7475       }
7476    }
7477 }
7478
7479 /*******************************************************************
7480  *
7481  * @brief Fills DrbQos Info received by CU
7482  *
7483  * @details
7484  *
7485  *    Function : extractQosInfo
7486  *
7487  *    Functionality: Fills DrbQos Info received  by CU
7488  *
7489  * @params[in] DrbQosInfo *qosToAdd,
7490  *             QoSFlowLevelQoSParameters_t *qosFlowCfg
7491  * @return void
7492  *
7493  * ****************************************************************/
7494
7495 void extractQosInfo(DrbQosInfo *qosToAdd, QoSFlowLevelQoSParameters_t *qosFlowCfg)
7496 {
7497    uint8_t qosCntIdx = 0;
7498    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
7499
7500    qosToAdd->fiveQiType = qosFlowCfg->qoS_Characteristics.present;
7501    qosToAdd->u.nonDyn5Qi.fiveQi     =\
7502                                      qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
7503    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow)
7504    {
7505       qosToAdd->u.nonDyn5Qi.avgWindow = \
7506                                         *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
7507    }
7508    qosToAdd->u.nonDyn5Qi.maxDataBurstVol = \
7509                                            *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
7510    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel)
7511    {
7512       qosToAdd->u.nonDyn5Qi.priorLevel = \
7513                                          *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel);
7514    }
7515    qosToAdd->ngRanRetPri.priorityLevel = \
7516                                          qosFlowCfg->nGRANallocationRetentionPriority.priorityLevel;
7517    qosToAdd->ngRanRetPri.preEmptionCap = \
7518                                          qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionCapability;
7519    qosToAdd->ngRanRetPri.preEmptionVul = \
7520                                          qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionVulnerability;
7521    if(qosFlowCfg->gBR_QoS_Flow_Information)
7522    {
7523       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateDl, \
7524             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.buf, \
7525             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.size);
7526       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateUl, \
7527             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.buf, \
7528             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.size);
7529       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateDl,\
7530             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.buf, \
7531             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.size);
7532       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateUl,\
7533             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.buf, \
7534             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.size);
7535    }
7536    /*Extracting PDU_SESSION_ID*/
7537    qosIeExt = (ProtocolExtensionContainer_4624P74_t *)qosFlowCfg->iE_Extensions;
7538    if(qosIeExt)
7539    {
7540       for(qosCntIdx = 0; qosCntIdx < qosIeExt->list.count; qosCntIdx++)
7541       {
7542          if(qosIeExt->list.array[qosCntIdx]->extensionValue.present == \
7543                QoSFlowLevelQoSParameters_ExtIEs__extensionValue_PR_PDUSessionID)
7544          {
7545             qosToAdd->pduSessionId = qosIeExt->list.array[qosCntIdx]->extensionValue.choice.PDUSessionID;
7546             DU_LOG("\nDEBUG -->  DU_F1AP : extractQosInfo: PDU SessionID:%d",qosToAdd->pduSessionId);
7547          }
7548       }
7549    }
7550    qosToAdd->ulPduSessAggMaxBitRate = 0;
7551 }
7552
7553 /*******************************************************************
7554  *
7555  * @brief Function to extract GTP Tunnel Info from CU
7556  *
7557  * @details
7558  *
7559  *    Function : extractUpTnlInfo
7560  *
7561  *    Functionality: Function to extract GTP Tunnel Info from CU
7562  *
7563  * @params[in] F1AP message
7564  * @return ROK/RFAILED
7565  *
7566  * ****************************************************************/
7567
7568 uint8_t extractUpTnlInfo(uint8_t drbId, uint8_t configType,\
7569    ULUPTNLInformation_ToBeSetup_List_t *tnlInfo, UpTnlCfg *upTnlInfo)
7570 {
7571    uint8_t tnlIdx;
7572    uint32_t ipv4_du = 0;
7573    GTPTunnel_t *gtpTunnel = NULLP;
7574
7575    upTnlInfo->drbId = drbId;
7576    upTnlInfo->configType = configType;
7577 #ifdef O1_ENABLE
7578    cmInetAddr((S8*)g_cfg.DU_IPV4_Addr, &ipv4_du);
7579 #else
7580    cmInetAddr((char *)DU_IP_V4_ADDR, &ipv4_du);
7581 #endif
7582
7583    for(tnlIdx=0; tnlIdx < tnlInfo->list.count; tnlIdx++)
7584    {
7585       if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
7586       {
7587          if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel)
7588          {
7589             gtpTunnel = tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel;
7590             DU_ALLOC(upTnlInfo->tnlCfg1, sizeof(GtpTnlCfg));
7591             if(upTnlInfo->tnlCfg1 == NULLP)
7592             {
7593                DU_LOG("\nERROR  -->  F1AP : extractUpTnlInfo: Failed to allocate mmeory for tunnel cfg 1");
7594                return RFAILED;
7595             }
7596             bitStringToInt(&gtpTunnel->transportLayerAddress, &upTnlInfo->tnlCfg1->ulTnlAddress);
7597             upTnlInfo->tnlCfg1->dlTnlAddress = ipv4_du;
7598             if(gtpTunnel->gTP_TEID.size > 0)
7599             {
7600                teIdStringToInt(gtpTunnel->gTP_TEID.buf, &upTnlInfo->tnlCfg1->teId);
7601             }
7602          }
7603          break;
7604       }
7605    }
7606    return ROK;
7607 }
7608
7609 /*******************************************************************
7610 *
7611 * @brief Function to extract Drb Qos Cfg Info from CU
7612 *
7613 * @details
7614 *
7615 *    Function : extractDrbQosCfg
7616 *
7617 *    Functionality: Function to extract Drb Qos Cfg Info from CU
7618 *
7619 * @params[in] DRB_Information_t *drbInfo, LcCfg *macLcToAdd
7620 * @return ROK/RFAILED
7621 *
7622 * ****************************************************************/
7623
7624 uint8_t extractDrbQosCfg(DRB_Information_t *drbInfo, LcCfg *macLcToAdd )
7625 {
7626    if(!macLcToAdd->drbQos)
7627    {
7628       DU_ALLOC_SHRABL_BUF(macLcToAdd->drbQos, sizeof(DrbQosInfo));
7629       if(macLcToAdd->drbQos == NULLP)
7630       {
7631          DU_LOG("\nERROR  -->  DUAPP:Memory failed at allocating DrbQos at extractDrbQosCfg()");
7632          return RFAILED;
7633       }
7634
7635    }
7636    if(drbInfo->dRB_QoS.qoS_Characteristics.present == QoS_Characteristics_PR_non_Dynamic_5QI)
7637    {
7638       extractQosInfo(macLcToAdd->drbQos, &drbInfo->dRB_QoS);
7639       macLcToAdd->dlLcCfg.lcp = macLcToAdd->drbQos->ngRanRetPri.priorityLevel;
7640    }
7641    if(extractDrbSnssaiCfg(&drbInfo->sNSSAI, &macLcToAdd->snssai) != ROK)
7642    {
7643       DU_LOG("\nERROR  -->  DUAPP: Unable to extract Snssai information  at extractDrbQosCfg()");
7644       return RFAILED;
7645    }
7646    return ROK;
7647 }
7648 /*******************************************************************
7649  *
7650  * @brief Function to extract DRB info received from CU
7651  *
7652  * @details
7653  *
7654  *    Function : extractDrbCfg
7655  *
7656  *    Functionality: Function to extract DRB info received from CU
7657  *
7658  * @params[in] F1AP message
7659  * @return void
7660  *
7661  * ****************************************************************/
7662 uint8_t extractDrbCfg(DRBs_ToBeSetup_Item_t *drbItem, DRBs_ToBeSetupMod_Item_t *drbSetupModItem,\
7663 DRBs_ToBeModified_Item_t *drbModItem,  LcCfg *macLcToAdd, UpTnlCfg *upTnlInfo)
7664 {
7665    DRB_Information_t *drbInfo = NULLP;
7666
7667    if(drbItem != NULLP)
7668    {
7669       if(extractUpTnlInfo(drbItem->dRBID, CONFIG_ADD, &drbItem->uLUPTNLInformation_ToBeSetup_List, upTnlInfo) != ROK)
7670       {
7671          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7672          return RFAILED;
7673       }
7674       if(drbItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7675       {
7676          if(drbItem->qoSInformation.choice.choice_extension->value.present == QoSInformation_ExtIEs__value_PR_DRB_Information)
7677          {
7678             drbInfo = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7679             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7680             {
7681                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7682                return RFAILED;
7683             }
7684          }
7685       }
7686    }
7687    else if(drbSetupModItem != NULLP)
7688    {
7689       if(extractUpTnlInfo(drbSetupModItem->dRBID, CONFIG_ADD, &drbSetupModItem->uLUPTNLInformation_ToBeSetup_List,\
7690       upTnlInfo) != ROK)
7691       {
7692          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7693          return RFAILED;
7694       }
7695       if(drbSetupModItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7696       {
7697          if(drbSetupModItem->qoSInformation.choice.choice_extension->value.present ==\
7698          QoSInformation_ExtIEs__value_PR_DRB_Information)
7699          {
7700             drbInfo = &drbSetupModItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7701             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7702             {
7703                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7704                return RFAILED;
7705             }
7706
7707          }
7708       }
7709    }
7710    else if(drbModItem != NULLP)
7711    {
7712       if(extractUpTnlInfo(drbModItem->dRBID, CONFIG_MOD, &drbModItem->uLUPTNLInformation_ToBeSetup_List,\
7713       upTnlInfo) != ROK)
7714       {
7715          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7716          return RFAILED;
7717       }
7718       if(drbModItem->qoSInformation != NULLP)
7719       {
7720          if(drbModItem->qoSInformation->present == QoSInformation_PR_choice_extension)
7721          {
7722             if(drbModItem->qoSInformation->choice.choice_extension->value.present ==\
7723                   QoSInformation_ExtIEs__value_PR_DRB_Information)
7724             {
7725                drbInfo = &drbModItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information;
7726                if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7727                {
7728                   DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7729                   return RFAILED;
7730                }
7731
7732             }
7733          }
7734       }
7735    }
7736    return ROK;
7737 }
7738
7739 /*******************************************************************
7740  *
7741  * @brief Function to extract RB info received from CU
7742  *
7743  * @details
7744  *
7745  *    Function : extractMacRbCfg
7746  *
7747  *    Functionality: Function to extract RB info received from CU
7748  *
7749  * @params[in] F1AP message
7750  * @return ROK/RFAILED
7751  *
7752  * ****************************************************************/
7753
7754 uint8_t extractMacRbCfg(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbCfg,\
7755 DRBs_ToBeSetupMod_Item_t *drbSetupModCfg,  DRBs_ToBeModified_Item_t *drbModCfg, LogicalChannelConfig_t *ulLcCfg, LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7756 {
7757    if(drbCfg != NULLP)
7758    {
7759       if(extractDrbCfg(drbCfg, NULL, NULL, lcCfg, upTnlInfo) != ROK)
7760       {
7761          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7762          return RFAILED;
7763       }
7764    }
7765    else if(drbSetupModCfg != NULLP)
7766    {
7767       if(extractDrbCfg(NULL, drbSetupModCfg, NULL, lcCfg, upTnlInfo) != ROK)
7768       {
7769          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7770          return RFAILED;
7771       }
7772    }
7773    else if(drbModCfg != NULLP)
7774    {
7775       if(extractDrbCfg(NULL, NULL, drbModCfg, lcCfg, upTnlInfo) != ROK)
7776       {
7777          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7778          return RFAILED;
7779       }
7780    }
7781    else
7782    {
7783       lcCfg->drbQos = NULLP;
7784       lcCfg->snssai = NULLP;
7785       if(lcCfg->lcId == SRB2_LCID)
7786          lcCfg->dlLcCfg.lcp = LC_PRIORITY_3;
7787       else
7788          lcCfg->dlLcCfg.lcp = LC_PRIORITY_1;
7789    }
7790    if(ulLcCfg)
7791    {
7792       lcCfg->ulLcCfgPres = true;
7793       extractUlLcCfg(&lcCfg->ulLcCfg, ulLcCfg);
7794    }
7795    else
7796       lcCfg->ulLcCfgPres = false;
7797    return ROK;
7798 }
7799
7800 /*******************************************************************
7801  *
7802  * @brief Function processing LC config info received from CU
7803  *
7804  * @details
7805  *
7806  *    Function : procMacLcCfg
7807  *
7808  *    Functionality: Function processing LC config info received from CU
7809  *
7810  * @params[in] F1AP message
7811  * @return ROK/RFAILED
7812  *
7813  * ****************************************************************/
7814
7815 uint8_t procMacLcCfg(uint8_t lcId, uint8_t rbType, uint8_t configType, DRBs_ToBeSetup_Item_t *drbItem,\
7816 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, LogicalChannelConfig_t *ulLcCfg,\
7817 LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7818 {
7819    uint8_t ret = ROK;
7820
7821    lcCfg->lcId = lcId;
7822    lcCfg->configType = configType;
7823    if(rbType == RB_TYPE_SRB)
7824    {
7825       ret = extractMacRbCfg(lcId, NULL, NULL, NULL, ulLcCfg, lcCfg, NULL);
7826    }
7827    else if(rbType == RB_TYPE_DRB)
7828    {
7829       if(drbItem != NULL)
7830         ret = extractMacRbCfg(lcId, drbItem, NULL, NULL, ulLcCfg, lcCfg, upTnlInfo);
7831       else if(drbSetupModItem != NULL)
7832         ret = extractMacRbCfg(lcId, NULL, drbSetupModItem, NULL, ulLcCfg, lcCfg, upTnlInfo);
7833       else if(drbModItem != NULL)
7834         ret = extractMacRbCfg(lcId, NULL, NULL, drbModItem, ulLcCfg, lcCfg, upTnlInfo);
7835    }
7836    return ret;
7837 }
7838
7839 /*******************************************************************
7840  *
7841  * @brief Function to extract Rlc cfg To Add/Mod in CellGrp Info
7842  *
7843  * @details
7844  *
7845  *    Function : extractRlcCfgToAddMod
7846  *
7847  *    Functionality: Function to extract Rlc cfg To Add/Mod in CellGrp Info
7848  *
7849  * @params[in] CellGroupConfigRrc__rlc_BearerTo pointer
7850  *             DuUeCfg Pointer
7851  * @return ROK/RFAILED
7852  *
7853  * ****************************************************************/
7854
7855 uint8_t extractRlcCfgToAddMod(struct CellGroupConfigRrc__rlc_BearerToAddModList *lcCfg, DuUeCfg *ueCfgDb)
7856 {
7857   uint8_t idx, rbId, lcId, rlcMode, rbType;
7858   RLC_Config_t *f1RlcCfg = NULLP;
7859   LogicalChannelConfig_t *macUlLcCfg = NULLP;
7860
7861   for(idx = 0; idx < lcCfg->list.count; idx++)
7862   {
7863      lcId = lcCfg->list.array[idx]->logicalChannelIdentity;
7864      if(lcCfg->list.array[idx]->servedRadioBearer)
7865      {
7866         /* RadioBearer for SRB/DRB */
7867         if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7868         RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
7869         {
7870            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.srb_Identity;
7871            rbType = RB_TYPE_SRB;
7872         }
7873         else if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7874         RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
7875         {
7876            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.drb_Identity;
7877            rbType = RB_TYPE_DRB;
7878         }
7879         else
7880         {
7881            DU_LOG("\nERROR  -->  No components present in Bearer config to ADD/MOD");
7882            return RFAILED;
7883         }
7884         /* MAC UL LC Config */
7885         if(lcCfg->list.array[idx]->mac_LogicalChannelConfig)
7886         {
7887            macUlLcCfg = lcCfg->list.array[idx]->mac_LogicalChannelConfig;
7888         }
7889      }
7890      else
7891      {
7892         DU_LOG("\nERROR  -->  DUAPP: Received RadioBearer config is NULL");
7893         return RFAILED;
7894      }
7895      /* RLC Mode Config */
7896      if(lcCfg->list.array[idx]->rlc_Config)
7897      {
7898         rlcMode  = lcCfg->list.array[idx]->rlc_Config->present;
7899         f1RlcCfg = lcCfg->list.array[idx]->rlc_Config;
7900      }
7901
7902      /* Filling RLC/MAC Config*/
7903      memset(&ueCfgDb->macLcCfg[idx], 0, sizeof(LcCfg));
7904      memset(&ueCfgDb->rlcLcCfg[idx], 0, sizeof(RlcBearerCfg));
7905      procRlcLcCfg(rbId, lcId, rbType, rlcMode, CONFIG_UNKNOWN, f1RlcCfg, &(ueCfgDb->rlcLcCfg[idx]), NULLP);
7906      if(procMacLcCfg(lcId, rbType, CONFIG_UNKNOWN, NULL, NULL, NULL, macUlLcCfg, &ueCfgDb->macLcCfg[idx], NULL) != ROK)
7907      {
7908         DU_LOG("\nERROR  -->  DU APP : Failed while filling MAC LC config at extractRlcCfgToAddMod()");
7909         return RFAILED;
7910      }
7911      (ueCfgDb->numRlcLcs)++;
7912      (ueCfgDb->numMacLcs)++;
7913          DU_LOG("\nDEBUG  -> DUAPP: extractRlcCfgToAddMod:RBType:%d, DrbID: %d,lcId:%d, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
7914                             rbType, rbId, lcId, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
7915   }
7916   //TODO: To send the failure cause in UeContextSetupRsp
7917   return ROK;
7918 }
7919
7920 /*******************************************************************
7921  *
7922  * @brief DeAlloc pdsch serv cell config info
7923  *
7924  * @details
7925  *
7926  *    Function : freeMacPdschServCellInfo
7927  *
7928  *    Functionality: DeAlloc pdsch serv cell config info
7929  *
7930  * @params[in] PdschServCellCfg pointer
7931  * @return void
7932  *
7933  * ****************************************************************/
7934
7935 void freeMacPdschServCellInfo(PdschServCellCfg *pdsch)
7936 {
7937    if(pdsch->xOverhead)
7938    {
7939       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->xOverhead, sizeof(PdschXOverhead));
7940    }
7941    if(pdsch->codeBlkGrpFlushInd)
7942    {
7943       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->codeBlkGrpFlushInd, sizeof(bool));
7944    }
7945    if(pdsch->maxCodeBlkGrpPerTb)
7946    {
7947       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
7948    }
7949    if(pdsch->maxMimoLayers)
7950    {
7951       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxMimoLayers, sizeof(uint8_t));
7952    }
7953 }
7954
7955 /*******************************************************************
7956  *
7957  * @brief Free Serving cell Info
7958  *
7959  * @details
7960  *
7961  *    Function : freeMacServingCellInfo
7962  *
7963  *    Functionality: Free Serving cell Info
7964  *
7965  * @params[in] ServCellCfgInfo *srvCellCfg
7966  * @return void
7967  *
7968  * ****************************************************************/
7969 void freeMacServingCellInfo(ServCellCfgInfo *srvCellCfg)
7970 {
7971    uint8_t timeDomRsrcIdx;
7972
7973    if(srvCellCfg->initDlBwp.pdschPresent)
7974    {
7975       for(timeDomRsrcIdx = 0; timeDomRsrcIdx < srvCellCfg->initDlBwp.pdschCfg.numTimeDomRsrcAlloc; timeDomRsrcIdx++)
7976       {
7977          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, \
7978             srvCellCfg->initDlBwp.pdschCfg.timeDomRsrcAllociList[timeDomRsrcIdx].k0, sizeof(uint8_t));
7979       }
7980    }
7981
7982    freeMacPdschServCellInfo(&srvCellCfg->pdschServCellCfg);
7983    if(srvCellCfg->bwpInactivityTmr)
7984    {
7985       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
7986    }
7987
7988    if(srvCellCfg->initUlBwp.pucchPresent)
7989    {
7990       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->initUlBwp.pucchCfg.dlDataToUlAck, sizeof(PucchDlDataToUlAck));
7991    }
7992 }
7993
7994 /*******************************************************************
7995  *
7996  * @brief Free cell Grp Cfg Info
7997  *
7998  * @details
7999  *
8000  *    Function : freeUeReCfgCellGrpInfo
8001  *
8002  *    Functionality: Free cell Grp Cfg Info
8003  *
8004  * @params[in] MacUeCfg*  duUeCfg
8005  * @return void
8006  *
8007  * ****************************************************************/
8008
8009 void freeUeReCfgCellGrpInfo(MacUeCfg *macUeCfg)
8010 {
8011    freeMacServingCellInfo(&macUeCfg->spCellCfg.servCellCfg);
8012 }
8013
8014 /*******************************************************************
8015  *
8016  * @brief Fills Reconfig SchReqReConfig
8017  *
8018  * @details
8019  *
8020  *    Function : extractSchReqReConfig
8021  *
8022  *    Functionality: Fills Reconfig SchReqReConfig
8023  *
8024  * @params[in] SchedulingRequestConfig_t *cuSchedReq
8025  *             SchedReqCfg*  macSchedReq
8026  * @return void
8027  *
8028  * ****************************************************************/
8029 void extractSchReqReConfig(SchedulingRequestConfig_t *cuSchedReq, SchedReqCfg *macSchedReq)
8030 {
8031    uint8_t schReqIdx = 0;
8032    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqListToAdd = NULLP;
8033    struct SchedulingRequestConfig__schedulingRequestToReleaseList *schReqListToRel = NULLP;
8034
8035    if(cuSchedReq->schedulingRequestToAddModList)
8036    {
8037       schReqListToAdd = cuSchedReq->schedulingRequestToAddModList;
8038       if(schReqListToAdd->list.count)
8039       {
8040          macSchedReq->addModListCount = schReqListToAdd->list.count;
8041          for(schReqIdx = 0; schReqIdx < schReqListToAdd->list.count; schReqIdx++)
8042          {
8043             macSchedReq->addModList[schReqIdx].schedReqId = \
8044                schReqListToAdd->list.array[schReqIdx]->schedulingRequestId;
8045             macSchedReq->addModList[schReqIdx].srProhibitTmr = \
8046                *(schReqListToAdd->list.array[schReqIdx]->sr_ProhibitTimer);
8047             macSchedReq->addModList[schReqIdx].srTransMax    =\
8048                schReqListToAdd->list.array[schReqIdx]->sr_TransMax;
8049          }
8050       }
8051    }
8052    /* Scheduling Req To release */
8053    if(cuSchedReq->schedulingRequestToReleaseList)
8054    {
8055       schReqListToRel = cuSchedReq->schedulingRequestToReleaseList;
8056       if(schReqListToRel->list.count)
8057       {
8058          macSchedReq->relListCount = schReqListToRel->list.count;
8059          for(schReqIdx = 0; schReqIdx < schReqListToRel->list.count; schReqIdx++)
8060          {
8061             macSchedReq->relList[schReqIdx] = \
8062                *schReqListToRel->list.array[schReqIdx];
8063          }
8064       }
8065    }
8066 }
8067
8068 /*******************************************************************
8069  *
8070  * @brief Fills TagReconfig
8071  *
8072  * @details
8073  *
8074  *    Function : extractTagReconfig
8075  *
8076  *    Functionality: Fills extractTagReconfig
8077  *
8078  * @params[in] TAG_Config_t *cuTagCfg
8079  *             TagCfg *macTagCfg
8080  * @return void
8081  *
8082  * ****************************************************************/
8083
8084 void extractTagReconfig(TAG_Config_t *cuTagCfg, TagCfg *macTagCfg)
8085 {
8086   uint8_t tagIdx = 0;
8087   struct TAG_Config__tag_ToAddModList  *tagListToAddMod = NULLP;
8088   struct TAG_Config__tag_ToReleaseList *tagListToRel = NULLP;
8089
8090   /* Tag config to AddMod */
8091   if(cuTagCfg->tag_ToAddModList)
8092   {
8093      tagListToAddMod = cuTagCfg->tag_ToAddModList;
8094      if(tagListToAddMod->list.count)
8095      {
8096         macTagCfg->addModListCount = tagListToAddMod->list.count;
8097         for(tagIdx = 0; tagIdx < tagListToAddMod->list.count; tagIdx++)
8098         {
8099            macTagCfg->addModList[tagIdx].tagId =\
8100               tagListToAddMod->list.array[tagIdx]->tag_Id;
8101            macTagCfg->addModList[tagIdx].timeAlignTimer = \
8102
8103               tagListToAddMod->list.array[tagIdx]->timeAlignmentTimer;
8104         }
8105      }
8106   }
8107   /* Tag config to release */
8108   if(cuTagCfg->tag_ToReleaseList)
8109   {
8110      tagListToRel = cuTagCfg->tag_ToReleaseList;
8111      if(tagListToRel->list.count)
8112      {
8113         macTagCfg->relListCount = tagListToRel->list.count;
8114         for(tagIdx = 0; tagIdx < tagListToRel->list.count; tagIdx++)
8115         {
8116            macTagCfg->relList[tagIdx] = *tagListToRel->list.array[tagIdx];
8117         }
8118      }
8119   }
8120 }
8121
8122 /*******************************************************************
8123  *
8124  * @brief Fills PdcchCfg received by CU
8125  *
8126  * @details
8127  *
8128  *    Function : extractPdcchCfg
8129  *
8130  *    Functionality: Fills PdcchCfg received  by CU
8131  *
8132  * @params[in] PDCCH_Config_t *cuPdcchCfg,
8133  *             PdcchConfig *duPdcchCfg
8134  * @return void
8135  *
8136  * ****************************************************************/
8137
8138 void extractPdcchCfg(PDCCH_Config_t *cuPdcchCfg, PdcchConfig *macPdcchCfg)
8139 {
8140    uint8_t cRsetIdx = 0;
8141    uint8_t srchSpcIdx = 0;
8142
8143    struct PDCCH_Config__controlResourceSetToAddModList *cRsetToAddModList = NULLP;
8144    struct PDCCH_Config__controlResourceSetToReleaseList *cRsetToRelList = NULLP;
8145    struct PDCCH_Config__searchSpacesToAddModList *srchSpcToAddModList = NULLP;
8146    struct PDCCH_Config__searchSpacesToReleaseList *srchSpcToRelList = NULLP;
8147
8148
8149    /* Control Resource Set To Add/Mod List */
8150    if(cuPdcchCfg->controlResourceSetToAddModList)
8151    {
8152       cRsetToAddModList = cuPdcchCfg->controlResourceSetToAddModList;
8153       if(cRsetToAddModList->list.count)
8154       {
8155          macPdcchCfg->numCRsetToAddMod = cRsetToAddModList->list.count;
8156          for(cRsetIdx = 0; cRsetIdx < cRsetToAddModList->list.count; cRsetIdx++)
8157          {
8158             macPdcchCfg->cRSetToAddModList[cRsetIdx].cRSetId = \
8159               cRsetToAddModList->list.array[cRsetIdx]->controlResourceSetId;
8160             bitStringToInt(&cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources,\
8161                macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc);
8162             macPdcchCfg->cRSetToAddModList[cRsetIdx].duration = \
8163               cRsetToAddModList->list.array[cRsetIdx]->duration;
8164
8165             macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType = \
8166               cRsetToAddModList->list.array[cRsetIdx]->cce_REG_MappingType.present;
8167             if(macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType == CCE_REG_MAPPINGTYPE_PR_INTERLEAVED)
8168             {
8169                //TODO: handle the case for Interleaved
8170             }
8171             macPdcchCfg->cRSetToAddModList[cRsetIdx].precoderGranularity = \
8172               cRsetToAddModList->list.array[cRsetIdx]->precoderGranularity;
8173             if(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID)
8174             {
8175                macPdcchCfg->cRSetToAddModList[cRsetIdx].dmrsScramblingId= \
8176                   *(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID);
8177             }
8178          }
8179       }
8180
8181    }
8182    /* Control Resource Set To Release List */
8183    if(cuPdcchCfg->controlResourceSetToReleaseList)
8184    {
8185       cRsetToRelList = cuPdcchCfg->controlResourceSetToReleaseList;
8186       if(cRsetToRelList->list.count)
8187       {
8188          macPdcchCfg->numCRsetToRel = cRsetToRelList->list.count;
8189          for(cRsetIdx = 0; cRsetIdx < cRsetToRelList->list.count; cRsetIdx++)
8190          {
8191             macPdcchCfg->cRSetToRelList[cRsetIdx] = *(cRsetToRelList->list.array[cRsetIdx]);
8192          }
8193       }
8194    }
8195
8196    /* Search space To Add/Mod List */
8197    if(cuPdcchCfg->searchSpacesToAddModList)
8198    {
8199       srchSpcToAddModList = cuPdcchCfg->searchSpacesToAddModList;
8200       if(srchSpcToAddModList->list.count)
8201       {
8202          macPdcchCfg->numSearchSpcToAddMod = srchSpcToAddModList->list.count;
8203          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToAddModList->list.count; srchSpcIdx++)
8204          {
8205             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceId =\
8206                srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceId;
8207             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].cRSetId =\
8208                *(srchSpcToAddModList->list.array[srchSpcIdx]->controlResourceSetId);
8209             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset)
8210             {
8211                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset =\
8212                   srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset->present;
8213             }
8214             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot)
8215             {
8216                bitStringToInt(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot,\
8217                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSymbolsWithinSlot);
8218             }
8219             if(srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates)
8220             {
8221               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel1 = \
8222                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel1;
8223               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel2 = \
8224                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel2;
8225               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel4 = \
8226                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel4;
8227
8228               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel8 = \
8229                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel8;
8230
8231               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel16 = \
8232                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel16;
8233             }
8234             if(srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType)
8235             {
8236                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType =\
8237                   srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->present;
8238                if(macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType == SEARCHSPACETYPE_PR_UE_SPECIFIC)
8239                {
8240                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].ueSpecificDciFormat =\
8241                      srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->choice.ue_Specific->dci_Formats;
8242                }
8243
8244             }
8245          }
8246       }
8247    }
8248    /* Search space To Rel List */
8249    if(cuPdcchCfg->searchSpacesToReleaseList)
8250    {
8251       srchSpcToRelList = cuPdcchCfg->searchSpacesToReleaseList;
8252       if(srchSpcToRelList->list.count)
8253       {
8254          macPdcchCfg->numSearchSpcToRel = srchSpcToRelList->list.count;
8255          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToRelList->list.count; srchSpcIdx++)
8256          {
8257             macPdcchCfg->searchSpcToRelList[srchSpcIdx] =\
8258                *(srchSpcToRelList->list.array[srchSpcIdx]);
8259          }
8260       }
8261    }
8262 }
8263
8264 /*******************************************************************
8265  *
8266  * @brief Fills PdschCfg received by CU
8267  *
8268  * @details
8269  *
8270  *    Function : extractPdschCfg
8271  *
8272  *    Functionality: Fills PdschCfg received  by CU
8273  *
8274  * @params[in] PDSCH_Config_t *cuPdschCfg = Information which is send by CU,
8275  *                   which we have stored in F1UeContextSetupDb,
8276  *             PdschConfig *macPdschCfg = Used to Store the information which
8277  *                   needs to send in other layer, as well as this can be the variable
8278  *                   which stores the information in DuCb,
8279  *             PdschConfig *storedPdschCfg =  Null in case of sending the
8280  *                   information to other layer else it will have stored pdsch
8281  *                   configuration in copyOfmacUeCfg.
8282  * @return void
8283  *
8284  * ****************************************************************/
8285
8286 void extractPdschCfg(PDSCH_Config_t *cuPdschCfg, PdschConfig *macPdschCfg, PdschConfig *storedPdschCfg)
8287 {
8288    uint8_t timeDomIdx;
8289    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAlloc = NULLP;
8290
8291    if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
8292    {
8293       if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->present == \
8294             PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup)
8295       {
8296          if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup)
8297          {
8298             macPdschCfg->dmrsDlCfgForPdschMapTypeA.addPos = \
8299                *(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_AdditionalPosition);
8300          }
8301       }
8302    }
8303    macPdschCfg->resourceAllocType = cuPdschCfg->resourceAllocation;
8304    if(cuPdschCfg->pdsch_TimeDomainAllocationList)
8305    {
8306       timeDomAlloc = cuPdschCfg->pdsch_TimeDomainAllocationList;
8307       if(timeDomAlloc->present ==\
8308             PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup)
8309       {
8310          if(timeDomAlloc->choice.setup)
8311          {
8312             macPdschCfg->numTimeDomRsrcAlloc  = timeDomAlloc->choice.setup->list.count;
8313             for(timeDomIdx = 0; timeDomIdx < timeDomAlloc->choice.setup->list.count; timeDomIdx++)
8314             {
8315                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 = NULLP;
8316                if(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0)
8317                {
8318                   if(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 == NULL)
8319                   {
8320                      if(storedPdschCfg)
8321                      {
8322                         if(storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
8323                         {
8324                            macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 =\
8325                            storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0;
8326                         }
8327                         else
8328                         {
8329                            DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
8330                         }
8331                      }
8332                      else
8333                      {
8334                         DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
8335                      }
8336                      if(!macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
8337                      {
8338                         DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for k0 at extractPdschCfg()");
8339                         return RFAILED;
8340                      }
8341                   }
8342                   *(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0) = \
8343                   *(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0);
8344                }
8345                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
8346                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
8347                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
8348                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8349             }
8350          }
8351       }
8352    }
8353    macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
8354    if(cuPdschCfg->maxNrofCodeWordsScheduledByDCI)
8355       macPdschCfg->numCodeWordsSchByDci = *(cuPdschCfg->maxNrofCodeWordsScheduledByDCI);
8356    if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_staticBundling)
8357    {
8358       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
8359       if(cuPdschCfg->prb_BundlingType.choice.staticBundling)
8360       {
8361          if(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize)
8362          {
8363             macPdschCfg->bundlingInfo.StaticBundling.size = \
8364                *(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize);
8365          }
8366       }
8367    }
8368    else if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_dynamicBundling)
8369    {
8370       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
8371    }
8372
8373 }
8374
8375 /*******************************************************************
8376  *
8377  * @brief Fills PdschServingCellCfg received by CU
8378  *
8379  * @details
8380  *
8381  *    Function : extractPdschServingCellCfg
8382  *
8383  *    Functionality: Fills PdschCfg received  by CU
8384  *
8385  * @params[in] PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg,
8386  *             PdschServCellCfg *macUePdschSrvCellCfg
8387  * @return ROK/RFAILED
8388  *
8389  * ****************************************************************/
8390
8391 uint8_t extractPdschServingCellCfg(PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg, PdschServCellCfg *macUePdschSrvCellCfg)
8392 {
8393    if(cuPdschSrvCellCfg->codeBlockGroupTransmission)
8394    {
8395       if(cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup)
8396       {
8397          if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
8398          {
8399             *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
8400                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
8401          }
8402          else
8403          {
8404             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
8405             if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
8406             {
8407                *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
8408                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
8409             }
8410             else
8411             {
8412                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
8413                return RFAILED;
8414             }
8415          }
8416          if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
8417          {
8418             *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
8419                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
8420          }
8421          else
8422          {
8423             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->codeBlkGrpFlushInd , sizeof(bool));
8424             if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
8425             {
8426                *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
8427                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
8428             }
8429             else
8430             {
8431                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
8432                return RFAILED;
8433             }
8434          }
8435       }
8436    }
8437    if(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH)
8438    {
8439       macUePdschSrvCellCfg->numHarqProcForPdsch = *(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH);
8440    }
8441    if(cuPdschSrvCellCfg->ext1)
8442    {
8443       if(cuPdschSrvCellCfg->ext1->maxMIMO_Layers)
8444       {
8445         if(macUePdschSrvCellCfg->maxMimoLayers)
8446         {
8447            *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
8448         }
8449         else
8450         {
8451            DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxMimoLayers, sizeof(uint8_t));
8452            if(macUePdschSrvCellCfg->maxMimoLayers)
8453            {
8454               *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
8455            }
8456            else
8457            {
8458               DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
8459               return RFAILED;
8460            }
8461         }
8462       }
8463    }
8464    if(cuPdschSrvCellCfg->xOverhead)
8465    {
8466       if(macUePdschSrvCellCfg->xOverhead)
8467       {
8468          *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
8469       }
8470       else
8471       {
8472          DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->xOverhead, sizeof(PdschXOverhead));
8473          if(macUePdschSrvCellCfg->xOverhead)
8474          {
8475             *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
8476          }
8477          else
8478          {
8479             DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
8480             return RFAILED;
8481          }
8482       }
8483    }
8484    return ROK;
8485 }
8486
8487 /*******************************************************************
8488  *
8489  * @brief Fills PuschCfg received by CU
8490  *
8491  * @details
8492  *
8493  *    Function : extractPuschCfg
8494  *
8495  *    Functionality: Fills PuschCfg received  by CU
8496  *
8497  * @params[in] BWP_UplinkDedicated__pusch_Config *cuPuschCfg,
8498  *             PuschCfg *macPuschCfg
8499  * @return void
8500  *
8501  * ****************************************************************/
8502
8503 void extractPuschCfg(struct BWP_UplinkDedicated__pusch_Config *cuPuschCfg, PuschCfg *macPuschCfg)
8504 {
8505    uint8_t timeDomIdx = 0;
8506    DMRS_UplinkConfig_t *dmrsUlCfg = NULLP;
8507    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList = NULLP;
8508
8509    if(cuPuschCfg->present == BWP_UplinkDedicated__pusch_Config_PR_setup)
8510    {
8511       if(cuPuschCfg->choice.setup)
8512       {
8513          if(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH)
8514          {
8515              macPuschCfg->dataScramblingId = \
8516                 *(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH);
8517          }
8518          if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA)
8519          {
8520             if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->present == PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup)
8521             {
8522                if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup)
8523                {
8524                   dmrsUlCfg = (cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup);
8525                   if(dmrsUlCfg->dmrs_AdditionalPosition)
8526                   {
8527                      macPuschCfg->dmrsUlCfgForPuschMapTypeA.addPos =\
8528                         *(dmrsUlCfg->dmrs_AdditionalPosition);
8529                   }
8530                   if(dmrsUlCfg->transformPrecodingDisabled)
8531                   {
8532                      if(dmrsUlCfg->transformPrecodingDisabled->scramblingID0)
8533                      {
8534                         macPuschCfg->dmrsUlCfgForPuschMapTypeA.transPrecodDisabled.scramblingId0 = \
8535                            *(dmrsUlCfg->transformPrecodingDisabled->scramblingID0);
8536                      }
8537                   }
8538                }
8539             }
8540          }
8541          /*Res Alloc Type for UL */
8542          if(cuPuschCfg->choice.setup->resourceAllocation)
8543          {
8544             macPuschCfg->resourceAllocType = \
8545                cuPuschCfg->choice.setup->resourceAllocation;
8546          }
8547          if(cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList)
8548          {
8549             timeDomAllocList = cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList;
8550             if(timeDomAllocList->present == PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup)
8551             {
8552                if(timeDomAllocList->choice.setup)
8553                {
8554                   macPuschCfg->numTimeDomRsrcAlloc = timeDomAllocList->choice.setup->list.count;
8555                   for(timeDomIdx = 0; timeDomIdx <timeDomAllocList->choice.setup->list.count; timeDomIdx++)
8556                   {
8557                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].k2 = \
8558                         *(timeDomAllocList->choice.setup->list.array[timeDomIdx]->k2);
8559                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].mappingType = \
8560                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->mappingType;
8561                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbolAndLength = \
8562                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8563                   }
8564                }
8565             }
8566          }
8567          if(cuPuschCfg->choice.setup->transformPrecoder)
8568             macPuschCfg->transformPrecoder = *(cuPuschCfg->choice.setup->transformPrecoder);
8569       }
8570    }
8571 }
8572
8573 /*******************************************************************
8574  *
8575  * @brief Function to fill pucch Power Control
8576  *
8577  * @details
8578  *
8579  *    Function : extractPucchPowerControl
8580  *
8581  *    Functionality: Function to fill pucch Power Control
8582  *
8583  * @params[in] PucchPowerControl *pwrCtrl,
8584  *             struct PUCCH_PowerControl *cuPwrCtrlCfg
8585  * @return void
8586  *
8587  * ****************************************************************/
8588
8589 void extractPucchPowerControl(PucchPowerControl *pwrCtrl, struct PUCCH_PowerControl *cuPwrCtrlCfg)
8590 {
8591    uint8_t arrIdx;
8592
8593    if(cuPwrCtrlCfg->deltaF_PUCCH_f0)
8594       pwrCtrl->deltaF_Format0 = *cuPwrCtrlCfg->deltaF_PUCCH_f0;
8595    if(cuPwrCtrlCfg->deltaF_PUCCH_f1)
8596       pwrCtrl->deltaF_Format1 = *cuPwrCtrlCfg->deltaF_PUCCH_f1;
8597    if(cuPwrCtrlCfg->deltaF_PUCCH_f2)
8598       pwrCtrl->deltaF_Format2 = *cuPwrCtrlCfg->deltaF_PUCCH_f2;
8599    if(cuPwrCtrlCfg->deltaF_PUCCH_f3)
8600       pwrCtrl->deltaF_Format3 = *cuPwrCtrlCfg->deltaF_PUCCH_f3;
8601    if(cuPwrCtrlCfg->deltaF_PUCCH_f4)
8602       pwrCtrl->deltaF_Format4 = *cuPwrCtrlCfg->deltaF_PUCCH_f4;
8603    if(cuPwrCtrlCfg->p0_Set)
8604    {
8605       pwrCtrl->p0SetCount = cuPwrCtrlCfg->p0_Set->list.count;
8606       for(arrIdx=0; arrIdx < pwrCtrl->p0SetCount; arrIdx++)
8607       {
8608          pwrCtrl->p0Set[arrIdx].p0PucchId =\
8609             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Id;
8610          pwrCtrl->p0Set[arrIdx].p0PucchVal =\
8611             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Value;
8612       }
8613    }
8614    if(cuPwrCtrlCfg->pathlossReferenceRSs)
8615    {
8616       pwrCtrl->pathLossRefRSListCount = cuPwrCtrlCfg->pathlossReferenceRSs->list.count;
8617       for(arrIdx = 0; arrIdx < pwrCtrl->pathLossRefRSListCount; arrIdx++)
8618       {
8619          pwrCtrl->pathLossRefRSList[arrIdx].pathLossRefRSId =\
8620             cuPwrCtrlCfg->pathlossReferenceRSs->list.array[arrIdx]->pucch_PathlossReferenceRS_Id;
8621       }
8622    }
8623 }
8624
8625  /*******************************************************************
8626  *
8627  * @brief Function to extractResrcSetToAddModList sent by CU
8628  *
8629  * @details
8630  *
8631  *    Function : extractResrcSetToAddModList
8632  *
8633  *    Functionality: Fucntion to extractResrcSetToAddModList
8634  *
8635  * @params[in] PucchResrcSetCfg pointer,
8636  *             struct PUCCH_Config__resourceSetToAddModList pointer
8637  * @return void
8638  *
8639  * ****************************************************************/
8640
8641 void extractResrcSetToAddModList(PucchResrcSetCfg *macRsrcSetList, struct PUCCH_Config__resourceSetToAddModList *cuRsrcSetList)
8642 {
8643    uint8_t arrIdx, rsrcListIdx;
8644
8645    macRsrcSetList->resrcSetToAddModListCount = cuRsrcSetList->list.count;
8646    for(arrIdx = 0; arrIdx < macRsrcSetList->resrcSetToAddModListCount; arrIdx++)
8647    {
8648       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcSetId     =\
8649          cuRsrcSetList->list.array[arrIdx]->pucch_ResourceSetId;
8650       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount =\
8651          cuRsrcSetList->list.array[arrIdx]->resourceList.list.count;
8652       for(rsrcListIdx = 0; rsrcListIdx < macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount; rsrcListIdx++)
8653       {
8654          macRsrcSetList->resrcSetToAddModList[arrIdx].resrcList[rsrcListIdx] =\
8655             *cuRsrcSetList->list.array[arrIdx]->resourceList.list.array[rsrcListIdx];
8656       }
8657       macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize =\
8658          *cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1;
8659    }
8660 }/* End of extractResrcSetToAddModList */
8661
8662 /*******************************************************************
8663  *
8664  * @brief Fills extractResrcToAddModList sent by CU
8665  *
8666  * @details
8667  *
8668  *    Function : extractResrcToAddModList
8669  *
8670  *    Functionality: Fills extractResrcToAddModList
8671  *
8672  * @params[in] PucchResrcCfg pointer,
8673  *             struct PUCCH_Config__resourceToAddModList pointer
8674  * @return ROk/RFAILED
8675  *
8676  * ****************************************************************/
8677
8678 uint8_t extractResrcToAddModList(PucchResrcCfg *macResrcList, struct PUCCH_Config__resourceToAddModList *cuResrcList)
8679 {
8680    uint8_t arrIdx;
8681
8682    macResrcList->resrcToAddModListCount = cuResrcList->list.count;
8683    for(arrIdx = 0; arrIdx < macResrcList->resrcToAddModListCount; arrIdx++)
8684    {
8685       macResrcList->resrcToAddModList[arrIdx].resrcId      =\
8686         cuResrcList->list.array[arrIdx]->pucch_ResourceId;
8687       macResrcList->resrcToAddModList[arrIdx].startPrb     =\
8688         cuResrcList->list.array[arrIdx]->startingPRB;
8689       if(cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping)
8690       {
8691          macResrcList->resrcToAddModList[arrIdx].intraFreqHop =\
8692            *cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping;
8693       }
8694       if(cuResrcList->list.array[arrIdx]->secondHopPRB)
8695       {
8696          macResrcList->resrcToAddModList[arrIdx].secondPrbHop =\
8697            *cuResrcList->list.array[arrIdx]->secondHopPRB;
8698       }
8699       /* PUCCH RSRC FORMAT */
8700       if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format0)
8701       {
8702          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_0;
8703          if(cuResrcList->list.array[arrIdx]->format.choice.format0)
8704          {
8705             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0, sizeof(PucchFormat0));
8706             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0 == NULLP)
8707             {
8708                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
8709                return RFAILED;
8710             }
8711             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->initialCyclicShift =\
8712                cuResrcList->list.array[arrIdx]->format.choice.format0->initialCyclicShift;
8713             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->numSymbols =\
8714                cuResrcList->list.array[arrIdx]->format.choice.format0->nrofSymbols;
8715             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->startSymbolIdx =\
8716                cuResrcList->list.array[arrIdx]->format.choice.format0->startingSymbolIndex;
8717          }
8718       }
8719       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format1)
8720       {
8721          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_1;
8722          if(cuResrcList->list.array[arrIdx]->format.choice.format1)
8723          {
8724             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1, sizeof(PucchFormat1));
8725             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1 == NULLP)
8726             {
8727                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
8728                return RFAILED;
8729             }
8730             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->initialCyclicShift =\
8731                 cuResrcList->list.array[arrIdx]->format.choice.format1->initialCyclicShift;
8732             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->numSymbols =\
8733                 cuResrcList->list.array[arrIdx]->format.choice.format1->nrofSymbols;
8734             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->startSymbolIdx =\
8735                 cuResrcList->list.array[arrIdx]->format.choice.format1->startingSymbolIndex;
8736             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->timeDomOCC =\
8737                 cuResrcList->list.array[arrIdx]->format.choice.format1->timeDomainOCC;
8738          }
8739       }
8740       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format2)
8741       {
8742          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_2;
8743          if(cuResrcList->list.array[arrIdx]->format.choice.format2)
8744          {
8745             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
8746             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2 == NULLP)
8747             {
8748                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
8749                return RFAILED;
8750             }
8751             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numPrbs =\
8752                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofPRBs;
8753             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numSymbols =\
8754                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofSymbols;
8755             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->startSymbolIdx =\
8756                 cuResrcList->list.array[arrIdx]->format.choice.format2->startingSymbolIndex;
8757          }
8758       }
8759       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format3)
8760       {
8761          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_3;
8762          if(cuResrcList->list.array[arrIdx]->format.choice.format3)
8763          {
8764             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
8765             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3 == NULLP)
8766             {
8767                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
8768                return RFAILED;
8769             }
8770             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numPrbs =\
8771                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofPRBs;
8772             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numSymbols =\
8773                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofSymbols;
8774             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->startSymbolIdx =\
8775                 cuResrcList->list.array[arrIdx]->format.choice.format3->startingSymbolIndex;
8776          }
8777       }
8778       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format4)
8779       {
8780          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_4;
8781          if(cuResrcList->list.array[arrIdx]->format.choice.format4)
8782          {
8783             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4, sizeof(PucchFormat4));
8784             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4 == NULLP)
8785             {
8786                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
8787                return RFAILED;
8788             }
8789             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->numSymbols =\
8790                 cuResrcList->list.array[arrIdx]->format.choice.format4->nrofSymbols;
8791             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occLen =\
8792                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Length;
8793             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occIdx =\
8794                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Index;
8795             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->startSymbolIdx =\
8796                 cuResrcList->list.array[arrIdx]->format.choice.format4->startingSymbolIndex;
8797          }
8798       }
8799    }
8800    return ROK;
8801
8802 }/* End of extractResrcToAddModList */
8803
8804 /*******************************************************************
8805  *
8806  * @brief Fills fillPucchSchedReqPeriodAndOffset sent by CU
8807  *
8808  * @details
8809  *
8810  *    Function : fillPucchSchedReqPeriodAndOffset
8811  *
8812  *    Functionality: To fillPucchSchedReqPeriodAndOffset
8813  *
8814  * @params[in] macPeriodicty,
8815  *     SchedulingRequestResourceConfig__periodicityAndOffset pointer
8816  * @return void
8817  *
8818  * ****************************************************************/
8819
8820 void fillPucchSchedReqPeriodAndOffset(uint8_t macPeriodicty, uint16_t  macOffset,\
8821    struct SchedulingRequestResourceConfig__periodicityAndOffset *cuPeriodicty)
8822 {
8823    macPeriodicty = cuPeriodicty->present;
8824    switch(macPeriodicty)
8825    {
8826       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
8827          {
8828             macOffset     = cuPeriodicty->choice.sym2;
8829             break;
8830          }
8831       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
8832          {
8833             macOffset     = cuPeriodicty->choice.sym6or7;
8834             break;
8835          }
8836       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
8837          {
8838             macOffset     = cuPeriodicty->choice.sl1;
8839             break;
8840          }
8841       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
8842          {
8843             macOffset = cuPeriodicty->choice.sl2;
8844             break;
8845          }
8846       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
8847          {
8848             macOffset = cuPeriodicty->choice.sl4;
8849             break;
8850          }
8851       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
8852          {
8853             macOffset = cuPeriodicty->choice.sl5;
8854             break;
8855          }
8856       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
8857          {
8858             macOffset = cuPeriodicty->choice.sl8;
8859             break;
8860          }
8861       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
8862          {
8863             macOffset = cuPeriodicty->choice.sl10;
8864             break;
8865          }
8866       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
8867          {
8868             macOffset = cuPeriodicty->choice.sl16;
8869             break;
8870          }
8871       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
8872          {
8873             macOffset = cuPeriodicty->choice.sl20;
8874             break;
8875          }
8876       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
8877          {
8878             macOffset = cuPeriodicty->choice.sl40;
8879             break;
8880          }
8881       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
8882          {
8883             macOffset = cuPeriodicty->choice.sl80;
8884             break;
8885          }
8886       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
8887          {
8888             macOffset = cuPeriodicty->choice.sl160;
8889             break;
8890          }
8891       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
8892          {
8893             macOffset = cuPeriodicty->choice.sl320;
8894             break;
8895          }
8896       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
8897          {
8898             macOffset = cuPeriodicty->choice.sl640;
8899             break;
8900          }
8901       default :
8902          DU_LOG("\nERROR  -->  F1AP : Invalid periodicity %d", macPeriodicty);
8903    }
8904 }
8905
8906 /*******************************************************************
8907  *
8908  * @brief Function to extractPucchFormatCfg sent by CU
8909  *
8910  * @details
8911  *
8912  *    Function : extractPucchFormatCfg
8913  *
8914  *    Functionality: Function to extractPucchFormatCfg
8915  *
8916  * @params[in] PucchFormatCfg pointer,
8917  *             PUCCH_FormatConfig_t pointer
8918  * @return void
8919  *
8920  * ****************************************************************/
8921
8922 void extractPucchFormatCfg(PucchFormatCfg *macFormatCfg, PUCCH_FormatConfig_t *cuFormatCfg)
8923  {
8924     if(cuFormatCfg->interslotFrequencyHopping)
8925        macFormatCfg->interSlotFreqHop = *cuFormatCfg->interslotFrequencyHopping;
8926     if(cuFormatCfg->additionalDMRS)
8927        macFormatCfg->addDmrs = *cuFormatCfg->additionalDMRS;
8928     if(cuFormatCfg->maxCodeRate)
8929        macFormatCfg->maxCodeRate = *cuFormatCfg->maxCodeRate;
8930     if(cuFormatCfg->nrofSlots)
8931        macFormatCfg->numSlots = *cuFormatCfg->nrofSlots;
8932     if(cuFormatCfg->pi2BPSK)
8933        macFormatCfg->pi2BPSK = *cuFormatCfg->pi2BPSK;
8934     if(cuFormatCfg->simultaneousHARQ_ACK_CSI)
8935        macFormatCfg->harqAckCSI = *cuFormatCfg->simultaneousHARQ_ACK_CSI;
8936  }/* End of extractPucchFormatCfg */
8937
8938 /*******************************************************************
8939  *
8940  * @brief Function to extractSchedReqCfgToAddMod sent by CU
8941  *
8942  * @details
8943  *
8944  *    Function : extractSchedReqCfgToAddMod
8945  *
8946  *    Functionality: Function to extractSchedReqCfgToAddMod
8947  *
8948  * @params[in] PucchSchedReqCfg pointer,
8949  *      PUCCH_Config__schedulingRequestResourceToAddModList pointer
8950  * @return void
8951  *
8952  * ****************************************************************/
8953
8954 void extractSchedReqCfgToAddMod(PucchSchedReqCfg *macSchedReqCfg, struct PUCCH_Config__schedulingRequestResourceToAddModList *cuSchedReqList)
8955 {
8956    uint8_t arrIdx;
8957
8958    macSchedReqCfg->schedAddModListCount = cuSchedReqList->list.count;
8959    for(arrIdx = 0; arrIdx <  macSchedReqCfg->schedAddModListCount; arrIdx++)
8960    {
8961       macSchedReqCfg->schedAddModList[arrIdx].resrcId =\
8962          cuSchedReqList->list.array[arrIdx]->schedulingRequestResourceId;
8963       macSchedReqCfg->schedAddModList[arrIdx].requestId =\
8964          cuSchedReqList->list.array[arrIdx]->schedulingRequestID;
8965       if(cuSchedReqList->list.array[arrIdx]->periodicityAndOffset)
8966       {
8967          fillPucchSchedReqPeriodAndOffset(macSchedReqCfg->schedAddModList[arrIdx].periodicity,\
8968             macSchedReqCfg->schedAddModList[arrIdx].offset, cuSchedReqList->list.array[arrIdx]->periodicityAndOffset);
8969       }
8970       if(cuSchedReqList->list.array[arrIdx]->resource)
8971       {
8972          macSchedReqCfg->schedAddModList[arrIdx].resrc =\
8973             *cuSchedReqList->list.array[arrIdx]->resource;
8974       }
8975    }
8976
8977 }/* End of extractSchedReqCfgToAddMod */
8978
8979  /*******************************************************************
8980  *
8981  * @brief Fills PucchCfg received by CU
8982  *
8983  * @details
8984  *
8985  *    Function : extractPucchCfg
8986  *
8987  *    Functionality: Fills PucchCfg received  by CU
8988  *
8989  * @params[in] BWP_UplinkDedicated__pucch_Config *cuPucchCfg = Information which
8990  *                is send by CU, which we have stored in F1UeContextSetupDb,
8991  *             PucchCfg *macPucchCfg = Used to Store the information which
8992  *                needs to send in other layer, as well as this can be the variable
8993  *                which stores the information in DuCb,
8994  *             PucchCfg *storedPucchCfg = Null in case of sending the
8995  *                information to other layer else it will have Pucch Cfg which
8996  *                we have stored in copyOfmacUeCfg.
8997  * @return ROK/RFAILED
8998  *
8999  * ****************************************************************/
9000
9001 uint8_t extractPucchCfg(struct BWP_UplinkDedicated__pucch_Config *cuPucchCfg, PucchCfg *macPucchCfg,\
9002 PucchCfg *storedPucchCfg)
9003 {
9004    uint8_t arrIdx;
9005
9006    if(cuPucchCfg->present == BWP_UplinkDedicated__pucch_Config_PR_setup)
9007    {
9008       if(cuPucchCfg->choice.setup)
9009       {
9010          /* Resource Set Cfg */
9011          if(cuPucchCfg->choice.setup->resourceSetToAddModList)
9012          {
9013             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrcSet, sizeof(PucchResrcSetCfg));
9014             if(macPucchCfg->resrcSet == NULLP)
9015             {
9016                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
9017                return RFAILED;
9018             }
9019             memset(macPucchCfg->resrcSet, 0, sizeof(PucchResrcSetCfg));
9020             extractResrcSetToAddModList(macPucchCfg->resrcSet, cuPucchCfg->choice.setup->resourceSetToAddModList);
9021          }
9022
9023          /* Resource Cfg */
9024          if(cuPucchCfg->choice.setup->resourceToAddModList)
9025          {
9026             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrc, sizeof(PucchResrcCfg));
9027             if(macPucchCfg->resrc == NULLP)
9028             {
9029                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
9030                return RFAILED;
9031             }
9032             memset(macPucchCfg->resrc, 0, sizeof(PucchResrcCfg));
9033             extractResrcToAddModList(macPucchCfg->resrc, cuPucchCfg->choice.setup->resourceToAddModList);
9034          }
9035
9036          /* Format 1 Cfg */
9037          if(cuPucchCfg->choice.setup->format1)
9038          {
9039             DU_ALLOC_SHRABL_BUF(macPucchCfg->format1, sizeof(PucchFormatCfg));
9040             if(macPucchCfg->format1 == NULLP)
9041             {
9042                DU_LOG("\nERROR --> F1AP : Failed to extract format 1 Cfg in  extractPucchCfg()");
9043                return RFAILED;
9044             }
9045             memset(macPucchCfg->format1, 0, sizeof(PucchFormatCfg));
9046             extractPucchFormatCfg(macPucchCfg->format1,\
9047                cuPucchCfg->choice.setup->format1->choice.setup);
9048          }
9049
9050          /* Format 2 Cfg */
9051          if(cuPucchCfg->choice.setup->format2)
9052          {
9053             DU_ALLOC_SHRABL_BUF(macPucchCfg->format2, sizeof(PucchFormatCfg));
9054             if(macPucchCfg->format2 == NULLP)
9055             {
9056                DU_LOG("\nERROR --> F1AP : Failed to extract format 2 Cfg in  extractPucchCfg()");
9057                return RFAILED;
9058             }
9059             memset(macPucchCfg->format2, 0, sizeof(PucchFormatCfg));
9060             extractPucchFormatCfg(macPucchCfg->format2,\
9061                cuPucchCfg->choice.setup->format2->choice.setup);
9062          }
9063
9064          /* Format 3 Cfg */
9065          if(cuPucchCfg->choice.setup->format3)
9066          {
9067             DU_ALLOC_SHRABL_BUF(macPucchCfg->format3, sizeof(PucchFormatCfg));
9068             if(macPucchCfg->format3 == NULLP)
9069             {
9070                DU_LOG("\nERROR --> F1AP : Failed to extract format 3 Cfg in  extractPucchCfg()");
9071                return RFAILED;
9072             }
9073             memset(macPucchCfg->format3, 0, sizeof(PucchFormatCfg));
9074             extractPucchFormatCfg(macPucchCfg->format3,\
9075                cuPucchCfg->choice.setup->format3->choice.setup);
9076          }
9077
9078          /* Format 4 Cfg */
9079          if(cuPucchCfg->choice.setup->format4)
9080          {
9081             DU_ALLOC_SHRABL_BUF(macPucchCfg->format4, sizeof(PucchFormatCfg));
9082             if(macPucchCfg->format4 == NULLP)
9083             {
9084                DU_LOG("\nERROR --> F1AP : Failed to extract format 4 Cfg in  extractPucchCfg()");
9085                return RFAILED;
9086             }
9087             memset(macPucchCfg->format4, 0, sizeof(PucchFormatCfg));
9088             extractPucchFormatCfg(macPucchCfg->format4,\
9089                cuPucchCfg->choice.setup->format4->choice.setup);
9090          }
9091
9092          /* Sched Req List */
9093          if(cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList)
9094          {
9095             DU_ALLOC_SHRABL_BUF(macPucchCfg->schedReq, sizeof(PucchSchedReqCfg));
9096             if(macPucchCfg->schedReq == NULLP)
9097             {
9098                DU_LOG("\nERROR --> F1AP : Failed to extract schedReqCfg in  extractPucchCfg()");
9099                return RFAILED;
9100             }
9101             memset(macPucchCfg->schedReq, 0, sizeof(PucchSchedReqCfg));
9102             extractSchedReqCfgToAddMod(macPucchCfg->schedReq,\
9103             cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList);
9104          }
9105
9106          /*TODO: Add support for  Spatial Info */
9107
9108          /* MultiCsiCfg */
9109          if(cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList)
9110          {
9111             DU_ALLOC_SHRABL_BUF(macPucchCfg->multiCsiCfg, sizeof(PucchMultiCsiCfg));
9112             if(macPucchCfg->multiCsiCfg == NULLP)
9113             {
9114                DU_LOG("\nERROR --> F1AP : Failed to extract multiCsiCfg in  extractPucchCfg()");
9115                return RFAILED;
9116             }
9117             memset(macPucchCfg->multiCsiCfg, 0, sizeof(PucchMultiCsiCfg));
9118             macPucchCfg->multiCsiCfg->multiCsiResrcListCount = cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.count;
9119             for(arrIdx =0; arrIdx < macPucchCfg->multiCsiCfg->multiCsiResrcListCount; arrIdx++)
9120             {
9121                macPucchCfg->multiCsiCfg->multiCsiResrcList[arrIdx] =\
9122                  *cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.array[arrIdx];
9123             }
9124          }
9125
9126          /* Dl_DataToUL_ACK */
9127          if(cuPucchCfg->choice.setup->dl_DataToUL_ACK)
9128     {
9129        if(storedPucchCfg)
9130        {
9131           if(storedPucchCfg->dlDataToUlAck)
9132           {
9133              macPucchCfg->dlDataToUlAck = storedPucchCfg->dlDataToUlAck;
9134           }
9135           else
9136           {
9137             DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
9138           }
9139        }
9140        else
9141        {
9142           DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
9143        }
9144        if(macPucchCfg->dlDataToUlAck == NULLP)
9145        {
9146           DU_LOG("\nERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
9147           return RFAILED;
9148        }
9149        memset(macPucchCfg->dlDataToUlAck, 0, sizeof(PucchDlDataToUlAck));
9150        macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount = cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.count;
9151        for(arrIdx = 0; arrIdx < macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount; arrIdx++)
9152        {
9153           macPucchCfg->dlDataToUlAck->dlDataToUlAckList[arrIdx] =\
9154           *cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.array[arrIdx];
9155        }
9156          }
9157
9158          /* Power Control */
9159          if(cuPucchCfg->choice.setup->pucch_PowerControl)
9160          {
9161             DU_ALLOC_SHRABL_BUF(macPucchCfg->powerControl, sizeof(PucchPowerControl));
9162             if(macPucchCfg->powerControl == NULLP)
9163             {
9164                DU_LOG("\nERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
9165                return RFAILED;
9166             }
9167             extractPucchPowerControl(macPucchCfg->powerControl,\
9168                cuPucchCfg->choice.setup->pucch_PowerControl);
9169          }
9170       }
9171    }
9172    return ROK;
9173 }
9174
9175 /*******************************************************************
9176  *
9177  * @brief Fills ServingCellReconfig received by CU
9178  *
9179  * @details
9180  *
9181  *    Function : extractSpCellDedicatedCfg
9182  *
9183  *    Functionality: Fills ServingCellReconfig received  by CU
9184  *
9185  * @params[in] ServingCellConfig_t *cuSrvCellCfg = Information which is send by
9186  *                  CU, which we have stored in F1UeContextSetupDb,
9187  *             ServCellCfgInfo *macSrvCellCfg = Used to Store the information
9188  *                  which  needs to send in other layer, as well as this can be the
9189  *                  variable which stores the information in DuCb,
9190  *             ServCellCfgInfo *storedSrvCellCfg = Null in case of sending the
9191  *                  information to other layer else it will have ServCellCfgInfo which
9192  *                  we have stored in copyOfmacUeCfg.
9193  * @return ROK/RFAILD
9194  *
9195  * ****************************************************************/
9196 uint8_t extractSpCellDedicatedCfg(ServingCellConfig_t *cuSrvCellCfg, ServCellCfgInfo *macSrvCellCfg,\
9197 ServCellCfgInfo *storedSrvCellCfg)
9198 {
9199    uint8_t ret = ROK;
9200    BWP_DownlinkDedicated_t *dlBwp = NULLP;
9201    BWP_UplinkDedicated_t   *ulBwp = NULLP;
9202
9203    if(cuSrvCellCfg->initialDownlinkBWP)
9204    {
9205       dlBwp = ((BWP_DownlinkDedicated_t *)(cuSrvCellCfg->initialDownlinkBWP));
9206       if(dlBwp->pdcch_Config)
9207       {
9208          if(dlBwp->pdcch_Config->choice.setup)
9209          {
9210             macSrvCellCfg->initDlBwp.pdcchPresent = true;
9211             extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
9212          }
9213       }
9214       if(dlBwp->pdsch_Config)
9215       {
9216          if(dlBwp->pdsch_Config->choice.setup)
9217          {
9218             macSrvCellCfg->initDlBwp.pdschPresent = true;
9219
9220             if(storedSrvCellCfg)
9221             {
9222                if(!storedSrvCellCfg->initDlBwp.pdschPresent)
9223                {
9224                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
9225                }
9226                else
9227                {
9228                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg,\
9229                         &storedSrvCellCfg->initDlBwp.pdschCfg);
9230                }
9231             }
9232             else
9233             {
9234                extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
9235             }
9236          }
9237       }
9238    }
9239    if(cuSrvCellCfg->firstActiveDownlinkBWP_Id)
9240       macSrvCellCfg->firstActvDlBwpId = *(cuSrvCellCfg->firstActiveDownlinkBWP_Id);
9241    if(cuSrvCellCfg->defaultDownlinkBWP_Id)
9242       macSrvCellCfg->defaultDlBwpId = *(cuSrvCellCfg->defaultDownlinkBWP_Id);
9243    if(cuSrvCellCfg->bwp_InactivityTimer)
9244    {
9245       if(macSrvCellCfg->bwpInactivityTmr)
9246       {
9247          memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
9248       }
9249       else
9250       {
9251          macSrvCellCfg->bwpInactivityTmr = NULLP;
9252          DU_ALLOC_SHRABL_BUF(macSrvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
9253          if(macSrvCellCfg->bwpInactivityTmr)
9254          {
9255             memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
9256          }
9257          else
9258          {
9259             DU_LOG("\nERROR  --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
9260             return RFAILED;
9261          }
9262       }
9263    }
9264    if(cuSrvCellCfg->pdsch_ServingCellConfig)
9265    {
9266       if(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup)
9267       {
9268          ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
9269          if(ret == RFAILED)
9270          {
9271             DU_LOG("\nERROR --> F1AP : Failed at extractPdschServingCellCfg()");
9272             return RFAILED;
9273          }
9274       }
9275    }
9276    if(cuSrvCellCfg->uplinkConfig)
9277    {
9278       if(cuSrvCellCfg->uplinkConfig->initialUplinkBWP)
9279       {
9280          ulBwp = ((BWP_UplinkDedicated_t *)(cuSrvCellCfg->uplinkConfig->initialUplinkBWP));
9281          if(ulBwp->pusch_Config)
9282          {
9283             macSrvCellCfg->initUlBwp.puschPresent = true;
9284             extractPuschCfg(ulBwp->pusch_Config, &macSrvCellCfg->initUlBwp.puschCfg);
9285          }
9286          if(ulBwp->pucch_Config)
9287          {
9288             macSrvCellCfg->initUlBwp.pucchPresent = true;
9289             memset(&macSrvCellCfg->initUlBwp.pucchCfg, 0, sizeof(PucchCfg));
9290             if(storedSrvCellCfg)
9291             {
9292                if(!storedSrvCellCfg->initUlBwp.pucchPresent)
9293                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
9294                else
9295                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg,\
9296                   &storedSrvCellCfg->initUlBwp.pucchCfg);
9297             }
9298             else
9299             {
9300                extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
9301             }
9302          }
9303       }
9304       if(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id)
9305          macSrvCellCfg->firstActvUlBwpId = *(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id);
9306    }
9307    return ret;
9308 }
9309 /*******************************************************************
9310  *
9311  * @brief Fills Reconfig Cell group Info received by CU
9312  *
9313  * @details
9314  *
9315  *    Function : extractUeReCfgCellInfo
9316  *
9317  *    Functionality: Fills Reconfig Cell group Info received by CU
9318  *
9319  * @params[in] CellGroupConfigRrc_t *cellGrp = CellGroupConfigRrc_t information which
9320  *                       is send by CU, which we have stored in F1UeContextSetupDb
9321  *             MacUeCfg *MacUeCfg = Used to Store the information,
9322  *                      which needs to send in other layer, as well as this can be
9323  *                      the variable which stores the information in DuCb,
9324  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
9325  *                      information to other layer else it will have copyOfmacUeCfg
9326  *                      which we have stored in F1UeContextSetupDb.
9327  *
9328  * @return ROK/RFAILED
9329  *
9330  * ****************************************************************/
9331 uint8_t extractUeReCfgCellInfo(CellGroupConfigRrc_t *cellGrp, MacUeCfg *macUeCfg, MacUeCfg *storedMacUeCfg)
9332 {
9333    uint8_t ret = ROK;
9334    MAC_CellGroupConfig_t     *macCellGroup = NULLP;
9335    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
9336    SpCellConfig_t            *spcellCfg = NULLP;
9337    ServingCellConfig_t       *servCellCfg = NULLP;
9338
9339    if(cellGrp)
9340    {
9341       /* Fill MacCell Group Reconfig  */
9342       if(cellGrp->mac_CellGroupConfig)
9343       {
9344          macUeCfg->macCellGrpCfgPres = true;
9345          macCellGroup = ((MAC_CellGroupConfig_t *)(cellGrp->mac_CellGroupConfig));
9346          if(macCellGroup->schedulingRequestConfig)
9347          {
9348             extractSchReqReConfig(macCellGroup->schedulingRequestConfig, &macUeCfg->macCellGrpCfg.schReqCfg);
9349          }
9350          if(macCellGroup->tag_Config)
9351          {
9352             extractTagReconfig(macCellGroup->tag_Config, &macUeCfg->macCellGrpCfg.tagCfg);
9353          }
9354          if(macCellGroup->bsr_Config)
9355          {
9356             macUeCfg->macCellGrpCfg.bsrTmrCfg.periodicTimer = macCellGroup->bsr_Config->periodicBSR_Timer;
9357             macUeCfg->macCellGrpCfg.bsrTmrCfg.retxTimer     = macCellGroup->bsr_Config->retxBSR_Timer;
9358             if(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer)
9359             {
9360                macUeCfg->macCellGrpCfg.bsrTmrCfg.srDelayTimer  =\
9361                *(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer);
9362             }
9363          }
9364          if(macCellGroup->phr_Config)
9365          {
9366             if(macCellGroup->phr_Config->present == MAC_CellGroupConfig__phr_Config_PR_setup)
9367             {
9368                macUeCfg->macCellGrpCfg.phrCfgSetupPres = true;
9369                if(macCellGroup->phr_Config->choice.setup)
9370                {
9371                   macUeCfg->macCellGrpCfg.phrCfg.periodicTimer     = \
9372                   macCellGroup->phr_Config->choice.setup->phr_PeriodicTimer;
9373                   macUeCfg->macCellGrpCfg.phrCfg.prohibitTimer     = \
9374                   macCellGroup->phr_Config->choice.setup->phr_ProhibitTimer;
9375                   macUeCfg->macCellGrpCfg.phrCfg.txPowerFactor     = \
9376                   macCellGroup->phr_Config->choice.setup->phr_Tx_PowerFactorChange;
9377                   macUeCfg->macCellGrpCfg.phrCfg.multiplePHR       = \
9378                   macCellGroup->phr_Config->choice.setup->multiplePHR;
9379                   macUeCfg->macCellGrpCfg.phrCfg.dummy             = \
9380                   macCellGroup->phr_Config->choice.setup->dummy;
9381                   macUeCfg->macCellGrpCfg.phrCfg.phrType2OtherCell = \
9382                   macCellGroup->phr_Config->choice.setup->phr_Type2OtherCell;
9383                   macUeCfg->macCellGrpCfg.phrCfg.phrOtherCG        = \
9384                   macCellGroup->phr_Config->choice.setup->phr_ModeOtherCG;
9385                }
9386             }
9387          }
9388       }
9389       /* Fill Physical Cell Group Reconfig */
9390       if(cellGrp->physicalCellGroupConfig)
9391       {
9392          macUeCfg->phyCellGrpCfgPres = true;
9393          phyCellGrpCfg = ((PhysicalCellGroupConfig_t *)(cellGrp->physicalCellGroupConfig));
9394          if(phyCellGrpCfg->p_NR_FR1)
9395          {
9396             if(*(phyCellGrpCfg->p_NR_FR1) != macUeCfg->phyCellGrpCfg.pNrFr1)
9397                macUeCfg->phyCellGrpCfg.pNrFr1 = *(phyCellGrpCfg->p_NR_FR1);
9398          }
9399          macUeCfg->phyCellGrpCfg.pdschHarqAckCodebook = phyCellGrpCfg->pdsch_HARQ_ACK_Codebook;
9400       }
9401       /* Fill SpCell Reconfig */
9402       if(cellGrp->spCellConfig)
9403       {
9404          macUeCfg->spCellCfgPres = true;
9405          spcellCfg = ((SpCellConfig_t *)(cellGrp->spCellConfig));
9406          if(spcellCfg->servCellIndex)
9407          {
9408             macUeCfg->spCellCfg.servCellIdx = *(spcellCfg->servCellIndex);
9409          }
9410          /* Fill Serving cell Reconfig info */
9411          if(cellGrp->spCellConfig->spCellConfigDedicated)
9412          {
9413             servCellCfg = ((ServingCellConfig_t *)(cellGrp->spCellConfig->spCellConfigDedicated));
9414             if(storedMacUeCfg)
9415             {
9416                if(!storedMacUeCfg->spCellCfgPres)
9417                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
9418                else
9419                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg,\
9420                         &storedMacUeCfg->spCellCfg.servCellCfg);
9421             }
9422             else
9423             {
9424                ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
9425             }
9426             if(ret == RFAILED)
9427             {
9428                DU_LOG("\nERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
9429             }
9430          }
9431       }
9432    }
9433    return ret;
9434 }
9435 /*******************************************************************
9436 *
9437 * @brief free the memory allocated by decoder
9438 *
9439 * @details
9440 *
9441 *    Function : freeAperDecodeNrcgi
9442 *
9443 *    Functionality: Free Nrcgi values
9444 *
9445 * @params[in] NRCGI_t *nrcgi
9446 * @return void
9447 *
9448 * ****************************************************************/
9449
9450
9451 void freeAperDecodeNrcgi(NRCGI_t *nrcgi)
9452 {
9453     if(nrcgi->pLMN_Identity.buf != NULLP)
9454     {
9455        free(nrcgi->pLMN_Identity.buf);
9456     }
9457     if(nrcgi->nRCellIdentity.buf != NULLP)
9458     {
9459        free(nrcgi->nRCellIdentity.buf);
9460     }
9461 }
9462 /*******************************************************************
9463 *
9464 * @brief free the memory allocated by decoder
9465 *
9466 * @details
9467 *
9468 *    Function : freeAperDecodeCuToDuInfo
9469 *
9470 *    Functionality:  Free Cu To Du Information
9471 *
9472 * @params[in] CUtoDURRCInformation_t *rrcMsg
9473 * @return void
9474 *
9475 * ****************************************************************/
9476
9477
9478 void freeAperDecodeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
9479 {
9480    uint8_t ieIdx =0;
9481    uint8_t arrIdx =0;
9482
9483    if(rrcMsg->uE_CapabilityRAT_ContainerList)
9484    {
9485       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
9486          free(rrcMsg->uE_CapabilityRAT_ContainerList->buf);
9487       free(rrcMsg->uE_CapabilityRAT_ContainerList);
9488    }
9489
9490    if(rrcMsg->iE_Extensions)
9491    {
9492       if(rrcMsg->iE_Extensions->list.array)
9493       {
9494          for(ieIdx= 0; ieIdx < rrcMsg->iE_Extensions->list.count; ieIdx++)
9495          {
9496             if(rrcMsg->iE_Extensions->list.array[ieIdx])
9497             {
9498                switch(rrcMsg->iE_Extensions->list.array[ieIdx]->id)
9499                {
9500                   case ProtocolIE_ID_id_CellGroupConfig:
9501                      if(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
9502                      {
9503                         free(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf);
9504                      }
9505                      break;
9506                   default:
9507                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
9508                            rrcMsg->iE_Extensions->list.array[ieIdx]->id);
9509                      break;
9510                }
9511             }
9512          }
9513          for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
9514          {
9515             free(rrcMsg->iE_Extensions->list.array[arrIdx]);
9516          }
9517          free(rrcMsg->iE_Extensions->list.array);
9518
9519       }
9520
9521       free(rrcMsg->iE_Extensions);
9522    }
9523 }
9524 /*******************************************************************
9525 *
9526 * @brief free the memory allocated by decoder
9527 *
9528 * @details
9529 *
9530 *    Function : freeAperDecodeSplCellList
9531 *
9532 *    Functionality: Free Spl Cell List
9533                     where memory allocated by aper_decoder
9534 *
9535 * @params[in]  SCell_ToBeSetup_List_t *spCellLst
9536 * @return void
9537 *
9538 * ****************************************************************/
9539
9540
9541 void freeAperDecodeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
9542 {
9543     uint8_t  cellIdx =0;
9544
9545     if(spCellLst->list.array != NULLP)
9546     {
9547        for(cellIdx=0; cellIdx<spCellLst->list.count; cellIdx++)
9548        {
9549           if(cellIdx==0&&spCellLst->list.array[cellIdx]!=NULLP)
9550           {
9551              freeAperDecodeNrcgi(&spCellLst->list.array[cellIdx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
9552           }
9553           if(spCellLst->list.array[cellIdx]!=NULLP)
9554           {
9555              free(spCellLst->list.array[cellIdx]);
9556           }
9557        }
9558        free(spCellLst->list.array);
9559     }
9560 }
9561 /*******************************************************************
9562 *
9563 * @brief free the memory allocated by decoder
9564 *
9565 * @details
9566 *
9567 *    Function : freeAperDecodeSRBSetup
9568 *
9569 *    Functionality: added free part for the memory allocated by aper_decoder
9570 *
9571 * @params[in] SRBs_ToBeSetup_List_t *srbSet
9572 * @return void
9573 *
9574 ****************************************************************/
9575
9576
9577 void freeAperDecodeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
9578 {
9579     uint8_t srbIdx =0;
9580     if(srbSet->list.array != NULLP)
9581     {
9582        for(srbIdx=0; srbIdx<srbSet->list.count; srbIdx++)
9583        {
9584           if(srbSet->list.array[srbIdx]!=NULLP)
9585           {
9586              free(srbSet->list.array[srbIdx]);
9587           }
9588        }
9589        free(srbSet->list.array);
9590     }
9591 }
9592
9593 /*******************************************************************
9594 *
9595 * @brief free the memory allocated by decoder
9596 *
9597 * @details
9598 *
9599 *    Function : freeAperDecodeULTnlInfo
9600 *
9601 *    Functionality: added free part for the memory allocated by aper_decoder
9602 *
9603 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
9604 * @return void
9605 *
9606 * ****************************************************************/
9607
9608
9609 void freeAperDecodeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
9610 {
9611    uint8_t ulIdx=0;
9612    if(ulInfo->list.array != NULLP)
9613    {
9614       for(ulIdx=0; ulIdx<ulInfo->list.count; ulIdx++)
9615       {
9616          if(ulIdx==0&&ulInfo->list.array[ulIdx]!=NULLP)
9617          {
9618             if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
9619             {
9620                if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9621                      transportLayerAddress.buf != NULLP)
9622                {
9623                   if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
9624                         !=NULLP)
9625                   {
9626                      free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf);
9627                   }
9628                   free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9629                         transportLayerAddress.buf);
9630                }
9631                free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel);
9632             }
9633          }
9634          if(ulInfo->list.array[ulIdx]!=NULLP)
9635          {
9636             free(ulInfo->list.array[ulIdx]);
9637          }
9638       }
9639       free(ulInfo->list.array);
9640    }
9641 }
9642 /*******************************************************************
9643 *
9644 * @brief free the memory allocated by decoder
9645 *
9646 * @details
9647 *
9648 *    Function : freeAperDecodeDRBSetup
9649 *
9650 *    Functionality: free DRBSetup which is allocated by decoder
9651 *
9652 * @params[in]  DRBs_ToBeSetup_List_t *drbSet
9653 * @return void
9654 *
9655 * ****************************************************************/
9656
9657 void freeAperDecodeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
9658 {
9659    DRBs_ToBeSetup_Item_t *drbSetItem = NULLP;
9660    uint8_t  flowIdx =0;
9661    uint8_t  drbIdx =0;
9662
9663    if(drbSet->list.array != NULLP)
9664    {
9665       for(drbIdx=0; drbIdx<drbSet->list.count; drbIdx++)
9666       {
9667          if(drbIdx==0&&drbSet->list.array[drbIdx] != NULLP)
9668          {
9669             drbSetItem =&drbSet->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
9670             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
9671             {
9672                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9673                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
9674                {
9675                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9676                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9677                   {
9678                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9679                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9680                      {
9681
9682                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
9683                         {
9684
9685                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
9686                            {
9687
9688                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->\
9689                                     buf!=NULLP)
9690                               {
9691
9692                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
9693                                        flows_Mapped_To_DRB_List.list.array != NULLP)
9694                                  {
9695
9696                                     for(flowIdx=0;flowIdx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9697                                           DRB_Information.flows_Mapped_To_DRB_List.list.count; flowIdx++)
9698                                     {
9699
9700                                        if(flowIdx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9701                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9702                                        {
9703                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9704                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9705                                                 qoSFlowLevelQoSParameters.\
9706                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
9707                                           {
9708                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9709                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9710                                                    qoSFlowLevelQoSParameters.\
9711                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9712                                              {
9713
9714                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9715                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9716                                                       qoSFlowLevelQoSParameters.\
9717                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9718                                                 {
9719
9720
9721                                                    free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9722                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9723                                                          qoSFlowLevelQoSParameters.\
9724                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9725                                                 }
9726
9727                                                 free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9728                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9729                                                       qoSFlowLevelQoSParameters.\
9730                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9731                                              }
9732
9733                                              free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9734
9735                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9736                                                    qoSFlowLevelQoSParameters.\
9737                                                    qoS_Characteristics.choice.non_Dynamic_5QI);
9738                                           }
9739                                        }
9740                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9741                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9742                                        {
9743
9744                                           free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9745                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]);
9746                                        }
9747                                     }
9748
9749                                     free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9750                                           DRB_Information.flows_Mapped_To_DRB_List.list.array);
9751                                  }
9752
9753                                  free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9754                                        DRB_Information.sNSSAI.sD->buf);
9755                               }
9756
9757                               free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD);
9758                            }
9759
9760                            free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf);
9761
9762                         }
9763
9764                         free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9765
9766                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9767                      }
9768
9769                      free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9770                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9771                   }
9772
9773                   free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9774                         qoS_Characteristics.choice.non_Dynamic_5QI);
9775                }
9776                free(drbSetItem->qoSInformation.choice.choice_extension);
9777             }
9778             freeAperDecodeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
9779             if(drbSetItem->uLConfiguration)
9780             {
9781                free(drbSetItem->uLConfiguration);
9782             }
9783          }
9784          if(drbSet->list.array[drbIdx]!=NULLP)
9785          {
9786             free(drbSet->list.array[drbIdx]);
9787          }
9788       }
9789       free(drbSet->list.array);
9790    }
9791 }
9792
9793
9794 /*******************************************************************
9795  *
9796  * @brief builds Mac Cell Cfg
9797  *
9798  * @details
9799  *
9800  *    Function : procUeReCfgCellInfo
9801  *
9802  *    Functionality: builds Mac Cell Cfg
9803  *
9804  * @params[in] MacUeCfg *macUeCfgToSend = Used to Store the information which
9805  *                       needs to send in other layer, as well as this can be
9806  *                       the variable which stores the information in DuCb.
9807  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
9808  *                       information to other layer else it will have copyOfmacUeCfg
9809  *                       which we have stored in F1UeContextSetupDb
9810  *             void *cellInfo = CellGroupConfigRrc_t information which is send
9811  *                        by CU, which we have stored in F1UeContextSetupDb
9812  *
9813  * @return void
9814  *
9815  * ****************************************************************/
9816 uint8_t procUeReCfgCellInfo(MacUeCfg *macUeCfgToSend,MacUeCfg *storedMacUeCfg, void *cellInfo)
9817 {
9818    uint8_t ret = ROK;
9819    CellGroupConfigRrc_t *cellGrp = NULLP;
9820
9821    if(cellInfo)
9822    {
9823       cellGrp = (CellGroupConfigRrc_t *)cellInfo;
9824       ret = extractUeReCfgCellInfo(cellGrp, macUeCfgToSend, storedMacUeCfg);
9825       if(ret == RFAILED)
9826          DU_LOG("\nERROR  -->  F1AP : Failed at procUeReCfgCellInfo()");
9827    }
9828    if(ret == RFAILED)
9829    {
9830       freeUeReCfgCellGrpInfo(macUeCfgToSend);
9831    }
9832    return ret;
9833 }
9834
9835 /*******************************************************************
9836  *
9837  * @brief Filling modulation info in mac ue cfg
9838  *
9839  * @details
9840  *
9841  *    Function : duFillModulationDetails
9842  *
9843  *    Functionality: Filling modulation info in mac ue cfg
9844  *
9845  * @params[in] MAC UE Config to be updated
9846  *             Current UE configuration
9847  *             UE NR capability from CU
9848  * @return ROK     - success
9849  *         RFAILED - failure
9850  *
9851  * ****************************************************************/
9852 void duFillModulationDetails(MacUeCfg *ueCfg, MacUeCfg *oldUeCfg, void *ueCap)
9853 {
9854    UE_NR_Capability_t *ueNrCap=NULLP;
9855
9856    if(!ueCap)
9857    {
9858       memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9859       memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9860    }
9861    else
9862    {
9863       ueNrCap = (UE_NR_Capability_t *)ueCap;
9864
9865       /* Filling DL modulation info */
9866       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsDownlinkPerCC && \
9867          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0] && \
9868          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL)
9869       {
9870          switch(*(ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL))
9871          {
9872             case ModulationOrder_qpsk:
9873                {
9874                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
9875                   break;
9876                }
9877             case ModulationOrder_qam16:
9878                {
9879                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM16;
9880                   break;
9881                }
9882             case ModulationOrder_qam64:
9883                {
9884                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM64;
9885                   ueCfg->dlModInfo.mcsIndex = PDSCH_MCS_INDEX;
9886                   ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64;
9887                   break;
9888                }
9889             case ModulationOrder_qam256:
9890                {
9891                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM256;
9892                   break;
9893                }
9894             default:
9895                {
9896                   DU_LOG("\nERROR  -->  DU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
9897                   memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9898                   break;
9899                }
9900          }
9901       }
9902       else
9903       {
9904          memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9905       }
9906
9907       /* Filling UL modulation info */
9908       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsUplinkPerCC && \
9909          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0] && \
9910          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL)
9911       {
9912          switch(*(ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL))
9913          {
9914             case ModulationOrder_qpsk:
9915                {
9916                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
9917                   break;
9918                }
9919             case ModulationOrder_qam16:
9920                {
9921                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM16;
9922                   ueCfg->ulModInfo.mcsIndex = PUSCH_MCS_INDEX;
9923                   ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64;
9924                   break;
9925                }
9926             case ModulationOrder_qam64:
9927                {
9928                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM64;
9929                   break;
9930                }
9931             case ModulationOrder_qam256:
9932                {
9933                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM256;
9934                   break;
9935                }
9936             default:
9937                {
9938                   DU_LOG("\nERROR  -->  DU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
9939                   memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9940                   break;
9941                }
9942          }
9943       }
9944       else
9945       {
9946          memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9947       }
9948    }
9949 }
9950
9951 /*******************************************************************
9952  *
9953  * @brief Function to extract cellGrp Info present in cutoDu cont
9954  *
9955  * @details
9956  *
9957  *    Function : extractCellGrpInfo
9958  *
9959  *    Functionality: Function to extract cellGrp Info present
9960  *                   in cutoDu cont
9961  *
9962  * @params[in] ProtocolExtensionContainer_4624P16_t pointer
9963  *
9964  * @return CellGroupConfigRrc_t *
9965  *
9966  * ****************************************************************/
9967
9968 CellGroupConfigRrc_t *extractCellGrpInfo(ProtocolExtensionContainer_4624P16_t *protocolIeExtn,\
9969       DuUeCfg *ueCfgDb)
9970 {
9971    uint8_t idx2 =0;
9972    uint16_t id =0;
9973    uint16_t recvBufLen =0;
9974    CellGroupConfigRrc_t *cellGrpCfg = NULLP;
9975    CUtoDURRCInformation_ExtIEs_t *extIeInfo = NULLP;
9976    asn_dec_rval_t rval; /* Decoder return value */
9977    memset(&rval, 0, sizeof(asn_dec_rval_t));
9978
9979    if(protocolIeExtn)
9980    {
9981       for(idx2 = 0; idx2 < protocolIeExtn->list.count; idx2++)
9982       {
9983          extIeInfo = ((CUtoDURRCInformation_ExtIEs_t *)(protocolIeExtn->list.array[idx2]));
9984          id = extIeInfo->id;
9985          switch(id)
9986          {
9987             case ProtocolIE_ID_id_CellGroupConfig:
9988             {
9989                recvBufLen = extIeInfo->extensionValue.choice.CellGroupConfig.size;
9990                /* decoding the CellGroup Buf received */
9991                DU_ALLOC(cellGrpCfg, sizeof(CellGroupConfigRrc_t));
9992                if(cellGrpCfg)
9993                {
9994                   memset(cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
9995                   rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfg,
9996                      extIeInfo->extensionValue.choice.CellGroupConfig.buf, recvBufLen, 0, 0);
9997                   if(rval.code == RC_FAIL || rval.code == RC_WMORE)
9998                   {
9999                      DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
10000                      return NULLP;
10001                   }
10002                   xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfg);
10003                   if(extractRlcCfgToAddMod(cellGrpCfg->rlc_BearerToAddModList, ueCfgDb))
10004                      return NULLP;
10005                }
10006                break;
10007             }
10008             default:
10009                DU_LOG("\nERROR  -->  F1AP : Invalid IE received CUtoDURRCInformation:%d at decodeCellGrpCfg()", id);
10010                break;
10011          }
10012       }
10013    }
10014    return cellGrpCfg;
10015 }
10016
10017 /*******************************************************************
10018  *
10019  * @brief Fills Srb List received by CU
10020  *
10021  * @details
10022  *
10023  *    Function : procSrbListToSetup
10024  *
10025  *    Functionality: Fills Srb List received  by CU
10026  *
10027  * @params[in] SRBs_ToBeSetup_Item_t *cuSrbItem
10028  *             LcCfg pointer
10029  *             RlcBearerCfg pointer
10030  * @return void
10031  *
10032  * ****************************************************************/
10033 uint8_t procSrbListToSetup(SRBs_ToBeSetup_Item_t * srbItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd)
10034 {
10035
10036    /* Filling RLC INFO */
10037    procRlcLcCfg(srbItem->sRBID, srbItem->sRBID, RB_TYPE_SRB, RLC_AM, CONFIG_ADD, NULL, rlcLcToAdd, NULL);
10038
10039    /* Filling MAC INFO */
10040    if(procMacLcCfg(srbItem->sRBID, RB_TYPE_SRB, CONFIG_ADD, NULL,NULL, NULL, NULL, macLcToAdd, NULL)  != ROK)
10041    {
10042       DU_LOG("\nERROR  -->  F1AP : Failed at MAC LC Cfg in procSrbListToSetup()");
10043       return RFAILED;
10044    }
10045
10046    return ROK;
10047 }
10048
10049
10050
10051 /*******************************************************************
10052  *
10053  * @brief extract Srb List received by CU
10054  *
10055  * @details
10056  *
10057  *    Function : extractSrbListToSetup
10058  *
10059  *    Functionality: extract Srb List received by CU
10060  *                   for both MAC and RLC
10061  *
10062  * @params[in] SRBs_ToBeSetup_Item_t pointer
10063  *             DuUeCfg pointer
10064  * @return ROK/RFAIED
10065  *
10066  * ****************************************************************/
10067
10068 uint8_t extractSrbListToSetup(SRBs_ToBeSetup_List_t *srbCfg, DuUeCfg *ueCfgDb)
10069 {
10070    uint8_t ret, srbIdx;
10071    SRBs_ToBeSetup_Item_t *srbItem = NULLP;
10072
10073    if(srbCfg)
10074    {
10075       for(srbIdx = 0; srbIdx < srbCfg->list.count; srbIdx++)
10076       {
10077          srbItem = &srbCfg->list.array[srbIdx]->value.choice.SRBs_ToBeSetup_Item;
10078          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
10079          {
10080             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in MAC");
10081             ret = RFAILED;
10082             break;
10083          }
10084          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
10085          {
10086             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in RLC");
10087             ret = RFAILED;
10088             break;
10089          }
10090          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
10091          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
10092          ret = procSrbListToSetup(srbItem, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
10093             &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs]);
10094          ueCfgDb->numRlcLcs++;
10095          ueCfgDb->numMacLcs++;
10096          DU_LOG("\nDEBUG --> DUAPP: extractSrbListToSetup: SRBID: %d [RLC,MAC,NumDrb]:[%x,%x,%x]",\
10097                             srbItem->sRBID, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
10098          if(ret == RFAILED)
10099          {
10100             DU_LOG("\nERROR  -->  F1AP:  Failed at extractSrbListToSetup()");
10101             break;
10102          }
10103       }
10104    }
10105    else
10106       ret = RFAILED;
10107
10108    return ret;
10109 }
10110
10111 /*******************************************************************
10112  *
10113  * @brief Fills Drb List received by CU
10114  *
10115  * @details
10116  *
10117  *    Function : procDrbListToSetupMod
10118  *
10119  *    Functionality: Fills Drb List received by CU
10120  *                   for both MAC and RLC
10121  *
10122  * @params[in] DRBs_ToBeSetup_Item_t , DRBs_ToBeSetupMod_Item_t,
10123  *             DRBs_ToBeModified_Item_t , lcId, LcCfg pointer,
10124  *             RlcBearerCfg , UpTnlCfg, RlcUeCfg
10125  * @return void
10126  *
10127  * ****************************************************************/
10128
10129 uint8_t procDrbListToSetupMod(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbItem,\
10130 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd, UpTnlCfg *upTnlInfo, RlcUeCfg *storedRlcUeCfg)
10131 {
10132    uint8_t cfgIdx = 0;
10133    RlcMode rlcModeInfo;
10134
10135    if(drbItem != NULLP)
10136    {
10137       /* Filling RLC INFO */
10138       procRlcLcCfg(drbItem->dRBID, lcId, RB_TYPE_DRB, drbItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd, &drbItem->\
10139       qoSInformation);
10140
10141       /* Filling MAC INFO */
10142       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, drbItem, NULL, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
10143       {
10144          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
10145          return RFAILED;
10146       }
10147    }
10148    else if(drbSetupModItem != NULLP)
10149    {
10150       procRlcLcCfg(drbSetupModItem->dRBID, lcId, RB_TYPE_DRB, drbSetupModItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd,
10151       &drbSetupModItem->qoSInformation);
10152
10153       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, NULL, drbSetupModItem, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
10154       {
10155          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
10156          return RFAILED;
10157       }
10158    }
10159    else if(drbModItem != NULLP)
10160    {
10161       /* Drb to Mod IEs doesnot have rlcMode to be modified
10162        * in ASN. Hence no change in RLC configurations */
10163       if(storedRlcUeCfg != NULLP)
10164       {
10165          for(cfgIdx = 0; cfgIdx < storedRlcUeCfg->numLcs; cfgIdx++)
10166          {
10167             if(storedRlcUeCfg->rlcLcCfg[cfgIdx].lcId == lcId)
10168             {
10169                rlcModeInfo = storedRlcUeCfg->rlcLcCfg[cfgIdx].rlcMode;
10170                break;
10171             }
10172          }
10173       }
10174
10175       procRlcLcCfg(drbModItem->dRBID, lcId, RB_TYPE_DRB, rlcModeInfo, CONFIG_MOD, NULL, rlcLcToAdd, drbModItem->qoSInformation);
10176       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_MOD, NULL, NULL, drbModItem, NULL, macLcToAdd, upTnlInfo) != ROK)
10177       {
10178          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
10179          return RFAILED;
10180       }
10181    }
10182    return ROK;
10183 }
10184
10185 /*******************************************************************
10186  *
10187  * @brief extract Drb List received by CU
10188  *
10189  * @details
10190  *
10191  *    Function : extractDrbListToSetupMod
10192  *
10193  *    Functionality: extract Drb List received by CU
10194  *                   for both MAC and RLC
10195  *
10196  * @params[in] DRBs_ToBeSetup_Item_t pointer
10197  *             DuUeCfg pointer
10198  * @return ROK/RFAIED
10199  *
10200  * ****************************************************************/
10201
10202 uint8_t extractDrbListToSetupMod(DRBs_ToBeSetup_List_t *drbCfg, DRBs_ToBeSetupMod_List_t *drbSetupModCfg,\
10203  DRBs_ToBeModified_List_t *drbModCfg, uint8_t drbCount, DuUeCfg *ueCfgDb, uint32_t *drbBitMap, RlcUeCfg *rlcUeCfg)
10204 {
10205    uint8_t ret, drbIdx, lcId = 0;
10206    DRBs_ToBeSetup_Item_t *drbItem = NULLP;
10207    DRBs_ToBeSetupMod_ItemIEs_t *drbSetupModItem = NULLP;
10208    DRBs_ToBeModified_ItemIEs_t *drbModItem = NULLP;
10209
10210    ret = ROK;
10211    if(drbCount > 0)
10212    {
10213       for(drbIdx = 0; drbIdx < drbCount; drbIdx++)
10214       {
10215          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
10216          {
10217             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in MAC at extractDrbListToSetupMod()");
10218             ret = RFAILED;
10219             break;
10220          }
10221          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
10222          {
10223             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in RLC at extractDrbListToSetupMod()");
10224             ret = RFAILED;
10225             break;
10226          }
10227          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
10228          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
10229
10230          if(drbModCfg != NULLP)
10231          {
10232             drbModItem = (DRBs_ToBeModified_ItemIEs_t *) drbModCfg->list.array[drbIdx];
10233             lcId = fetchLcId(drbModItem->value.choice.DRBs_ToBeModified_Item.dRBID);
10234             if(lcId < MIN_DRB_LCID)
10235             {
10236                DU_LOG("\nERROR  --> F1AP : Failed fetching LCID %d in extractDrbListToSetupMod() for Modified List", lcId);
10237                break;
10238             }
10239             ret = procDrbListToSetupMod(lcId, NULL, NULL, &(drbModItem->value.choice.DRBs_ToBeModified_Item),\
10240             &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs],\
10241             &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
10242             if(ret == RFAILED)
10243             {
10244                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for Modified List");
10245                break;
10246             }
10247
10248          }
10249          else
10250          {
10251             lcId = getDrbLcId(drbBitMap);
10252             if(lcId == RFAILED)
10253             {
10254                DU_LOG("\nERROR  -->  F1AP :  InCorrect LCID extractDrbListToSetupMod()");
10255                ret = RFAILED;
10256                break;
10257             }
10258             if(drbCfg != NULL)
10259             {
10260                drbItem = &drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
10261                ret = procDrbListToSetupMod(lcId, drbItem, NULL, NULL, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
10262                      &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
10263                if(ret == RFAILED)
10264                {
10265                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetup List");
10266                   break;
10267                }
10268             }
10269             else if(drbSetupModCfg != NULL)
10270             {
10271                drbSetupModItem = (DRBs_ToBeSetupMod_ItemIEs_t *) drbSetupModCfg->list.array[drbIdx];
10272                ret = procDrbListToSetupMod(lcId, NULL, &(drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item), NULL,\
10273                      &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs],\
10274                      &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
10275                if(ret == RFAILED)
10276                {
10277                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetupMod List");
10278                   break;
10279                }
10280             }
10281          }
10282          ueCfgDb->numRlcLcs++;
10283          ueCfgDb->numMacLcs++;
10284          ueCfgDb->numDrb++;
10285
10286          DU_LOG("\nDEBUG --> DUAPP: extractDrbListToSetupMod:lcId:%x ,BitMap:%x, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
10287                             lcId,*drbBitMap, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
10288          if(ret == RFAILED)
10289          {
10290             DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod()");
10291             break;
10292          }
10293       }
10294    }
10295    else
10296       ret = RFAILED;
10297
10298    return ret;
10299 }
10300
10301 /*******************************************************************
10302  *
10303  * @brief Function to extract Dl RRC Msg received from CU
10304  *
10305  * @details
10306  *
10307  *    Function : extractDlRrcMsg
10308  *
10309  *    Functionality: Function to extract Dl RRC Msg received from CU
10310  *
10311  * @params[in] F1AP message
10312  * @return ROK     - success
10313  *         RFAILED - failure
10314  *
10315  * ****************************************************************/
10316
10317 uint8_t extractDlRrcMsg(uint32_t gnbDuUeF1apId, uint32_t gnbCuUeF1apId, \
10318    F1DlRrcMsg *dlRrcMsg, RRCContainer_t *rrcContainer)
10319 {
10320    uint8_t ret = ROK;
10321    dlRrcMsg->rrcMsgSize = rrcContainer->size;
10322    if(dlRrcMsg->rrcMsgSize > 0)
10323    {
10324       DU_ALLOC_SHRABL_BUF(dlRrcMsg->rrcMsgPdu, dlRrcMsg->rrcMsgSize);
10325       if(!dlRrcMsg->rrcMsgPdu)
10326       {
10327          DU_LOG("\nERROR  --> DU APP : Memory allocation failed for RRC Msg in extractDlRrcMsg()");
10328          ret = RFAILED;
10329       }
10330       else
10331       {
10332          dlRrcMsg->gnbDuUeF1apId = gnbDuUeF1apId;
10333          dlRrcMsg->gnbCuUeF1apId = gnbCuUeF1apId;
10334          dlRrcMsg->srbId = SRB1_LCID;
10335          memcpy(dlRrcMsg->rrcMsgPdu, rrcContainer->buf, dlRrcMsg->rrcMsgSize);
10336       }
10337    }
10338    return ret;
10339 }
10340
10341 /*******************************************************************
10342  *
10343  * @brief Extract UE capability info
10344  *
10345  * @details
10346  *
10347  *    Function : extractUeCapability
10348  *
10349  *    Functionality: Extract UE capability info and stores in ue Cb
10350  *
10351  * @params[in] Octet string of UE capability RAT container list
10352  * @return ROK     - success
10353  *         RFAILED - failure
10354  *
10355  * ****************************************************************/
10356 UE_NR_Capability_t *extractUeCapability(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf, DuUeCb *ueCb)
10357 {
10358    uint8_t  idx;
10359    uint16_t recvBufLen;
10360    asn_dec_rval_t rval;
10361    UE_NR_Capability_t  *ueNrCap = NULLP;
10362    UE_CapabilityRAT_ContainerListRRC_t  *ueCapRatContList = NULLP;
10363
10364    /* Decoding UE Capability RAT Container List */
10365    recvBufLen = ueCapablityListBuf->size;
10366    DU_ALLOC(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10367    if(!ueCapRatContList)
10368    {
10369       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
10370       return NULLP;
10371    }
10372    memset(ueCapRatContList, 0, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10373    memset(&rval, 0, sizeof(asn_dec_rval_t));
10374    rval = aper_decode(0, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, (void **)&ueCapRatContList,
10375           ueCapablityListBuf->buf, recvBufLen, 0, 0);
10376    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10377    {
10378       DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
10379       return NULLP;
10380    }
10381    xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, ueCapRatContList);
10382
10383    /* Free encoded buffer after decoding */
10384
10385    for(idx = 0; idx < ueCapRatContList->list.count; idx++)
10386    {
10387       if(ueCapRatContList->list.array[idx]->rat_Type == RAT_Type_nr)
10388       {
10389          /* Decoding UE NR Capability */
10390           recvBufLen = ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.size;
10391           DU_ALLOC(ueNrCap, sizeof(UE_NR_Capability_t));
10392           if(!ueNrCap)
10393           {
10394              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
10395              DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10396              return NULLP;
10397           }
10398           memset(ueNrCap, 0, sizeof(UE_NR_Capability_t));
10399           memset(&rval, 0, sizeof(asn_dec_rval_t));
10400           rval = aper_decode(0, &asn_DEF_UE_NR_Capability, (void **)&ueNrCap,
10401                  ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf, recvBufLen, 0, 0);
10402           if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10403           {
10404              DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
10405              return NULLP;
10406           }
10407           xer_fprint(stdout, &asn_DEF_UE_NR_Capability, ueNrCap);
10408
10409           /* Free encoded buffer after decoding */
10410           free(ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf);
10411       }
10412       free(ueCapRatContList->list.array[idx]);
10413    }
10414
10415    /* Free Memory*/
10416    free(ueCapRatContList->list.array);
10417    DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10418    return ueNrCap;
10419 }
10420
10421 /*******************************************************************
10422 *
10423 * @brief free UE context setup request from CU
10424 *
10425 * @details
10426 *
10427 *    Function : freeAperDecodeF1UeContextSetupReq
10428 *
10429 *    Functionality: freeing part for the memory allocated by aper_decoder
10430 *
10431 * @params[in] F1AP message
10432 * @return ROK     - success
10433 *         RFAILED - failure
10434 *
10435 * ****************************************************************/
10436 void freeAperDecodeF1UeContextSetupReq(UEContextSetupRequest_t   *ueSetReq)
10437 {
10438    uint8_t ieIdx = 0;
10439
10440    if(ueSetReq->protocolIEs.list.array != NULLP)
10441    {
10442       for(ieIdx = 0; ieIdx < ueSetReq->protocolIEs.list.count; ieIdx++)
10443       {
10444          if(ueSetReq->protocolIEs.list.array[ieIdx])
10445          {
10446             switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
10447             {
10448                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10449                   break;
10450                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10451                   break;
10452                case ProtocolIE_ID_id_SpCell_ID:
10453                   freeAperDecodeNrcgi(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
10454                   break;
10455                case ProtocolIE_ID_id_ServCellIndex:
10456                   break;
10457                case ProtocolIE_ID_id_SpCellULConfigured:
10458                   break;
10459                case ProtocolIE_ID_id_CUtoDURRCInformation:
10460
10461                   freeAperDecodeCuToDuInfo(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation);
10462                   break;
10463                case ProtocolIE_ID_id_SCell_ToBeSetup_List:
10464
10465                   freeAperDecodeSplCellList(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SCell_ToBeSetup_List);
10466                   break;
10467                case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
10468
10469                   freeAperDecodeSRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List);
10470                   break;
10471                case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
10472
10473                   freeAperDecodeDRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List);
10474                   break;
10475                case ProtocolIE_ID_id_RRCContainer:
10476                   {
10477
10478                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf != NULLP)
10479                      {
10480
10481                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
10482                      }
10483                      break;
10484                   }
10485                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10486                   break;
10487                case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
10488                   {
10489                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf)
10490                      {
10491                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf);
10492                      }
10493                      break;
10494                   }
10495                default:
10496                   DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld " ,ueSetReq->protocolIEs.list.array[ieIdx]->id);
10497             }
10498             free(ueSetReq->protocolIEs.list.array[ieIdx]);
10499          }
10500       }
10501       free(ueSetReq->protocolIEs.list.array);
10502    }
10503 }
10504 /*******************************************************************
10505  *
10506  * @brief Process UE context setup request from CU
10507  *
10508  * @details
10509  *
10510  *    Function : procF1UeContextSetupReq
10511  *
10512  *    Functionality: Process UE context setup request from CU
10513  *
10514  * @params[in] F1AP message
10515  * @return ROK     - success
10516  *         RFAILED - failure
10517  *
10518  * ****************************************************************/
10519 uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
10520 {
10521    uint8_t  ret=0, ieIdx=0, ueIdx=0, cellIdx=0;
10522    bool ueCbFound = false;
10523    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0, bitRateSize=0;
10524    DuUeCb   *duUeCb = NULL;
10525    UEContextSetupRequest_t   *ueSetReq = NULL;
10526    DRBs_ToBeSetup_List_t *drbCfg = NULL;
10527
10528    ret = ROK;
10529
10530    ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
10531    for(ieIdx=0; (ieIdx < ueSetReq->protocolIEs.list.count && ret == ROK); ieIdx++)
10532    {
10533       switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
10534       {
10535          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10536             {
10537                gnbCuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
10538                break;
10539             }
10540          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10541             {
10542                gnbDuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
10543                break;
10544             }
10545          case ProtocolIE_ID_id_ServCellIndex:
10546             {
10547                cellIdx = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.ServCellIndex;
10548                for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
10549                {
10550                   if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
10551                         (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
10552                   {
10553                      ueCbFound = true;
10554                      duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
10555                      DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
10556                      if(duUeCb->f1UeDb)
10557                      {
10558                         memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
10559                         duUeCb->f1UeDb->actionType = UE_CTXT_SETUP;
10560                         duUeCb->f1UeDb->cellIdx = cellIdx;
10561                      }
10562                      else
10563                      {
10564                         DU_LOG("\nERROR  -->  F1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
10565                         ret = RFAILED;
10566                      }
10567                      break;
10568                   }
10569                   else
10570                      ueCbFound = false;
10571
10572                }
10573                if(!ueCbFound)
10574                {
10575                   DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
10576                   ret = RFAILED;
10577                }
10578                break;
10579             }
10580          case ProtocolIE_ID_id_SpCellULConfigured:
10581             /* Indicates whether the gNB-CU requests the gNB-DU to configure the uplink as no UL,
10582                UL, SUL or UL+SUL for the indicated cell for the UE */
10583             break;
10584          case ProtocolIE_ID_id_CUtoDURRCInformation:
10585             {
10586                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.uE_CapabilityRAT_ContainerList)
10587                {
10588                   duUeCb->f1UeDb->duUeCfg.ueNrCapability = \
10589                   extractUeCapability(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.\
10590                   uE_CapabilityRAT_ContainerList, duUeCb);
10591                }
10592                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.iE_Extensions)
10593                {
10594                   duUeCb->f1UeDb->duUeCfg.cellGrpCfg = extractCellGrpInfo(ueSetReq->protocolIEs.list.array[ieIdx]->\
10595                         value.choice.CUtoDURRCInformation.iE_Extensions, &duUeCb->f1UeDb->duUeCfg);
10596                   if(!duUeCb->f1UeDb->duUeCfg.cellGrpCfg)
10597                   {
10598                      DU_LOG("\nERROR  -->  F1AP: Failed to extract cell Grp Info");
10599                      //TODO: Update the failure cause in ue context Setup Response
10600                      ret = RFAILED;
10601                   }
10602                }
10603                break;
10604             }
10605          case ProtocolIE_ID_id_SCell_ToBeSetup_List:
10606             {
10607                DU_LOG("\nINFO   -->  DU_APP: Received SCell_ToBeSetup_List but  Not processing the list");
10608                break;
10609             }
10610          case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
10611             {
10612                if(extractSrbListToSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List,\
10613                &duUeCb->f1UeDb->duUeCfg))
10614                {
10615                   DU_LOG("\nERROR  -->  DU APP : Failed at extractSrbListToSetup()");
10616                   //TODO: Update the failure cause in ue context Setup Response
10617                   ret = RFAILED;
10618                }
10619                break;
10620             }
10621          case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
10622             {
10623                   drbCfg = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List;
10624
10625                   if(extractDrbListToSetupMod(drbCfg, NULL, NULL, drbCfg->list.count, &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, NULLP))
10626                   {
10627                      DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod()");
10628                      //TODO: Update the failure cause in ue context Setup Response
10629                      ret = RFAILED;
10630                   }
10631                break;
10632             }
10633          case ProtocolIE_ID_id_RRCContainer:
10634             {
10635                /* Filling Dl RRC Msg Info */
10636                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
10637                if(!duUeCb->f1UeDb->dlRrcMsg)
10638                {
10639                   DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
10640                   ret = RFAILED;
10641                }
10642                else
10643                {
10644                   duUeCb->f1UeDb->dlRrcMsgPres = true;
10645                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
10646                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
10647                         &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer);
10648                }
10649                break;
10650             }
10651          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10652             {
10653                if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
10654                {
10655                   duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
10656                }
10657                else
10658                {
10659                   DU_LOG("\nERROR  -->  Ignoring delivery report, since rrcContainer is not present");
10660                }
10661                break;
10662             }
10663          case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
10664             {
10665                /* MaximumBitRate Uplink */
10666                bitRateSize = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.size;
10667                if(bitRateSize > 0)
10668                {
10669                   DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.ambrCfg, bitRateSize);
10670                   if(!duUeCb->f1UeDb->duUeCfg.ambrCfg)
10671                   {
10672                      DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
10673                      ret = RFAILED;
10674                   }
10675                   else
10676                   {
10677                      memset(duUeCb->f1UeDb->duUeCfg.ambrCfg, 0, sizeof(AmbrCfg));
10678                      memcpy(&duUeCb->f1UeDb->duUeCfg.ambrCfg->ulBr,
10679                            ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf, bitRateSize);
10680                   }
10681                }
10682                else
10683                   ret = RFAILED;
10684                break;
10685             }
10686          default:
10687             {
10688                break;
10689             }
10690       }
10691    }
10692    if(ret == RFAILED)
10693    {
10694       /*TODO : Negative case*/
10695       // BuildAndSendUeContextSetupRsp(cellId,ueIdx);
10696       DU_LOG("\nERROR  -->  F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
10697    }
10698    else
10699       ret = duProcUeContextSetupRequest(duUeCb);
10700
10701    freeAperDecodeF1UeContextSetupReq(ueSetReq);
10702    return ret;
10703
10704 }
10705 /*******************************************************************
10706  * @brief Free the memory allocated for Dl Tunnel Info
10707  *
10708  * @details
10709  *
10710  *    Function : freeDlTnlInfo
10711  *
10712  *    Functionality:
10713  *       Free the memory allocated for Dl Tunnel Info
10714  *
10715  * @params[in] DLUPTNLInformation_ToBeSetup_List_t *
10716  * @return void
10717  *
10718  * ****************************************************************/
10719
10720 void freeDlTnlInfo(DLUPTNLInformation_ToBeSetup_List_t *tnlInfo)
10721 {
10722    uint8_t arrIdx = 0;
10723
10724    if(tnlInfo)
10725    {
10726       for(arrIdx=0; arrIdx < tnlInfo->list.count; arrIdx++)
10727       {
10728          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf,\
10729                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
10730          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf,\
10731                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
10732          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
10733          DU_FREE(tnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
10734       }
10735       DU_FREE(tnlInfo->list.array, tnlInfo->list.size);
10736    }
10737 }
10738
10739 /*******************************************************************
10740  * @brief Free the memory allocated for DRB setup List
10741  *
10742  * @details
10743  *
10744  *    Function : freeDrbSetupList
10745  *
10746  *    Functionality:
10747  *       Free the memory allocated for DRB setup list
10748  *
10749  * @params[in] DRBs_Setup_List_t *
10750  * @return void
10751  *
10752  * ****************************************************************/
10753 void freeDrbSetupList(DRBs_Setup_List_t *drbSetupList)
10754 {
10755    uint8_t arrIdx = 0;
10756    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
10757
10758    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
10759    {
10760       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
10761       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
10762       DU_FREE(drbSetupList->list.array[arrIdx],  sizeof(DRBs_Setup_Item_t));
10763    }
10764    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
10765 }
10766
10767 /*******************************************************************
10768  * @brief Free the memory allocated for UE Setup response
10769  *
10770  * @details
10771  *
10772  *    Function : FreeUeContextSetupRsp
10773  *
10774  *    Functionality:
10775  *       Free the memory allocated for UE Setup response
10776  *
10777  * @params[in] F1AP PDU for UE setup response
10778  * @return ROK     - success
10779  *         RFAILED - failure
10780  *
10781  * ****************************************************************/
10782 void FreeUeContextSetupRsp(F1AP_PDU_t *f1apMsg)
10783 {
10784    uint8_t idx;
10785    UEContextSetupResponse_t *ueSetRsp = NULLP;
10786
10787    if(f1apMsg)
10788    {
10789       if(f1apMsg->choice.successfulOutcome)
10790       {
10791          ueSetRsp = &f1apMsg->choice.successfulOutcome->value.choice.\
10792                     UEContextSetupResponse;
10793          if(ueSetRsp->protocolIEs.list.array)
10794          {
10795             for(idx = 0; idx < ueSetRsp->protocolIEs.list.count; idx++)
10796             {
10797                if(ueSetRsp->protocolIEs.list.array[idx])
10798                {
10799                   switch(ueSetRsp->protocolIEs.list.array[idx]->id)
10800                   {
10801                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10802                         break;
10803                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10804                         break;
10805                      case ProtocolIE_ID_id_DUtoCURRCInformation:
10806                         {
10807                            CellGroupConfig_t *cellGrpCfg = NULLP;
10808                            cellGrpCfg  = &ueSetRsp->protocolIEs.list.array[idx]->value.choice.\
10809                                          DUtoCURRCInformation.cellGroupConfig;
10810                            if(cellGrpCfg->buf != NULLP)
10811                            {
10812                               DU_FREE(cellGrpCfg->buf, cellGrpCfg->size);
10813                               cellGrpCfg = NULLP;
10814                            }
10815                            break;
10816                         }
10817                     case ProtocolIE_ID_id_DRBs_Setup_List:
10818                         {
10819                            freeDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
10820                            break;
10821                         }
10822                      default:
10823                         DU_LOG("\nERROR  -->  DUAPP: Invalid Id %ld at FreeUeContextSetupRsp()",\
10824                         ueSetRsp->protocolIEs.list.array[idx]->id);
10825                         break;
10826                   }
10827                   DU_FREE(ueSetRsp->protocolIEs.list.array[idx],\
10828                         sizeof(UEContextSetupResponseIEs_t));
10829                }
10830             }
10831             DU_FREE(ueSetRsp->protocolIEs.list.array, \
10832                   ueSetRsp->protocolIEs.list.size);
10833          }
10834          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
10835       }
10836       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10837    }
10838 }
10839
10840 /*******************************************************************
10841  *
10842  * @brief Builds Ue context Setup Rsp DU To CU Info
10843  *
10844  * @details
10845  *
10846  *    Function : EncodeUeCntxtDuToCuInfo
10847  *
10848  *    Functionality: Builds Ue context Setup Rsp DU To CU Info
10849  *
10850  * @params[in] CellGroupConfig_t *, CellGroupConfigRrc_t *
10851  *
10852  * @return ROK     - success
10853  *         RFAILED - failure
10854  *
10855  ******************************************************************/
10856
10857 uint8_t EncodeUeCntxtDuToCuInfo(CellGroupConfig_t *duToCuCellGrp, CellGroupConfigRrc_t *duCellGrpCfg)
10858 {
10859    asn_enc_rval_t        encRetVal;
10860
10861    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, duCellGrpCfg);
10862    memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
10863    encBufSize = 0;
10864    encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, duCellGrpCfg, PrepFinalEncBuf, encBuf);
10865    /* Encode results */
10866    if(encRetVal.encoded == ENCODE_FAIL)
10867    {
10868       DU_LOG( "\nERROR  -->  F1AP : Could not encode UeCntxtDuToCuInfo (at %s)\n",\
10869             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10870       return RFAILED;
10871    }
10872    else
10873    {
10874       DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
10875       for(int i=0; i< encBufSize; i++)
10876       {
10877          printf("%x",encBuf[i]);
10878       }
10879    }
10880    duToCuCellGrp->size = encBufSize;
10881    DU_ALLOC(duToCuCellGrp->buf, duToCuCellGrp->size);
10882    if(!duToCuCellGrp->buf)
10883    {
10884       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in UeCntxtDuToCuInfo");
10885    }
10886    memcpy(duToCuCellGrp->buf, encBuf, duToCuCellGrp->size);
10887    return ROK;
10888 }
10889
10890 /*******************************************************************
10891  *
10892  * @brief Fills Dl Gtp tunnel Info
10893  *
10894  * @details
10895  *
10896  *    Function : fillGtpTunnelforDl
10897  *
10898  *    Functionality: Fills Dl Gtp tunnel Info
10899  *
10900  * @params[in]
10901  *
10902  * @return ROK     - success
10903  *         RFAILED - failure
10904  *
10905  * ****************************************************************/
10906
10907 uint8_t fillGtpTunnelforDl(GTPTunnel_t *gtpDl, GtpTnlCfg *gtpUeCfg)
10908 {
10909    uint8_t bufSize = 0;
10910
10911    gtpDl->transportLayerAddress.size    = 4*sizeof(uint8_t);
10912    DU_ALLOC(gtpDl->transportLayerAddress.buf, gtpDl->transportLayerAddress.size);
10913    if(gtpDl->transportLayerAddress.buf == NULLP)
10914    {
10915       return RFAILED;
10916    }
10917    memcpy(gtpDl->transportLayerAddress.buf, &gtpUeCfg->dlTnlAddress, gtpDl->transportLayerAddress.size);
10918
10919    /*GTP TEID*/
10920    gtpDl->gTP_TEID.size = 4 * sizeof(uint8_t);
10921    DU_ALLOC(gtpDl->gTP_TEID.buf, gtpDl->gTP_TEID.size);
10922    if(gtpDl->gTP_TEID.buf == NULLP)
10923    {
10924       return RFAILED;
10925    }
10926    bufSize = 3; /*forming an Octect String*/
10927    fillTeIdString(bufSize, gtpUeCfg->teId, gtpDl->gTP_TEID.buf);
10928
10929    return ROK;
10930 }
10931
10932 /*******************************************************************
10933  *
10934  * @brief Fills DL Tunnel Setup List
10935  *
10936  * @details
10937  *
10938  *    Function : fillDlTnlSetupList
10939  *
10940  *    Functionality: Fills the DL Tunnel Setup List
10941  *
10942  * @params[in]
10943  *
10944  * @return ROK     - success
10945  *         RFAILED - failure
10946  *
10947  * ****************************************************************/
10948
10949 uint8_t fillDlTnlSetupList(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo, UpTnlCfg *tnlCfg)
10950 {
10951    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
10952
10953    eleCount = 1;
10954    dlTnlInfo->list.count = eleCount;
10955    dlTnlInfo->list.size = (eleCount * sizeof(DLUPTNLInformation_ToBeSetup_Item_t *));
10956
10957    /* Initialize the DL Tnl Setup List Members */
10958    DU_ALLOC(dlTnlInfo->list.array, dlTnlInfo->list.size);
10959    if(dlTnlInfo->list.array == NULLP)
10960    {
10961       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL Tnl Setup List in fillDlTnlSetupList()");
10962       ret = RFAILED;
10963    }
10964    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
10965    {
10966       DU_ALLOC(dlTnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
10967       if(dlTnlInfo->list.array[arrIdx] == NULLP)
10968       {
10969          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDlTnlSetupList()", arrIdx);
10970          return RFAILED;
10971       }
10972       dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
10973       DU_ALLOC(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
10974       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel == NULLP)
10975       {
10976          DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL tunnel info in fillDlTnlSetupList()");
10977          return RFAILED;
10978       }
10979       ret = fillGtpTunnelforDl(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel,\
10980                tnlCfg->tnlCfg1);
10981       if(ret != ROK)
10982          break;
10983    }
10984    return ret;
10985 }
10986
10987 /*******************************************************************
10988  *
10989  * @brief Fills the Drb Setup List for Ue Context Setup Response
10990  *
10991  * @details
10992  *
10993  *    Function : fillDrbSetupList
10994  *
10995  *    Functionality: Fills the Drb Setup List for Ue Context Setup Response
10996  *
10997  * @params[in]
10998  *
10999  * @return ROK     - success
11000  *         RFAILED - failure
11001  *
11002  * ****************************************************************/
11003 uint8_t fillDrbSetupList(DRBs_Setup_List_t *drbSetupList, DuUeCfg *ueCfg)
11004 {
11005    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
11006    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
11007
11008    eleCount = ueCfg->numDrb;
11009    drbSetupList->list.count = eleCount;
11010    drbSetupList->list.size = \
11011         (eleCount * sizeof(DRBs_Setup_Item_t *));
11012
11013    /* Initialize the Drb Setup List Members */
11014    DU_ALLOC(drbSetupList->list.array, drbSetupList->list.size);
11015    if(drbSetupList->list.array == NULLP)
11016    {
11017       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DRB Setup List in fillDrbSetupList()");
11018       ret = RFAILED;
11019    }
11020
11021    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
11022    {
11023       DU_ALLOC(drbSetupList->list.array[arrIdx], sizeof(DRBs_Setup_Item_t));
11024       if(drbSetupList->list.array[arrIdx] == NULLP)
11025       {
11026          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDrbSetupList()", arrIdx);
11027          return RFAILED;
11028       }
11029       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
11030       drbItemIe->id = ProtocolIE_ID_id_DRBs_Setup_Item;
11031       drbItemIe->criticality = Criticality_reject;
11032       drbItemIe->value.present = DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item;
11033       drbItemIe->value.choice.DRBs_Setup_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
11034       ret = fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List,\
11035           &ueCfg->upTnlInfo[arrIdx]);
11036       if(ret != ROK)
11037          break;
11038    }
11039    return ret;
11040 }
11041
11042 /*******************************************************************
11043  *
11044  * @brief Builds and sends the UE Setup Response
11045  *
11046  * @details
11047  *
11048  *    Function : BuildAndSendUeContextSetupRsp
11049  *
11050  *    Functionality: Constructs the UE Setup Response and sends
11051  *                   it to the DU through SCTP.
11052  *
11053  * @params[in] uint8_t cellId,uint8_t ueIdx
11054  *
11055  * @return ROK     - success
11056  *         RFAILED - failure
11057  *
11058  * ****************************************************************/
11059 uint8_t BuildAndSendUeContextSetupRsp(uint8_t cellId,uint8_t ueIdx)
11060 {
11061    uint8_t   idx, ret, cellIdx, elementCnt;
11062    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
11063    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
11064    asn_enc_rval_t  encRetVal;        /* Encoder return value */
11065    F1AP_PDU_t               *f1apMsg = NULLP;
11066    UEContextSetupResponse_t *ueSetRsp = NULLP;
11067    CellGroupConfigRrc_t     *cellGrpCfg = NULLP;
11068    DuUeCb                   *ueCb = NULLP;
11069
11070    DU_LOG("\n INFO   -->  F1AP : Building UE Context Setup Response for cellId %d, ueIdx %d\n", cellId, ueIdx);
11071
11072    while(true)
11073    {
11074       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11075       if(f1apMsg == NULLP)
11076       {
11077          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11078          ret = RFAILED;
11079          break;
11080       }
11081
11082       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
11083       DU_ALLOC(f1apMsg->choice.successfulOutcome,
11084             sizeof(SuccessfulOutcome_t));
11085       if(f1apMsg->choice.successfulOutcome == NULLP)
11086       {
11087          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
11088          ret = RFAILED;
11089          break;
11090       }
11091
11092       f1apMsg->choice.successfulOutcome->procedureCode = \
11093                                                          ProcedureCode_id_UEContextSetup;
11094       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
11095       f1apMsg->choice.successfulOutcome->value.present = \
11096                                                          SuccessfulOutcome__value_PR_UEContextSetupResponse;
11097
11098       ueSetRsp =
11099          &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
11100       elementCnt = 4;
11101       ueSetRsp->protocolIEs.list.count = elementCnt;
11102       ueSetRsp->protocolIEs.list.size = \
11103                                         elementCnt * sizeof(UEContextSetupResponse_t *);
11104
11105       /* Initialize the UESetup members */
11106       DU_ALLOC(ueSetRsp->protocolIEs.list.array, \
11107             ueSetRsp->protocolIEs.list.size);
11108       if(ueSetRsp->protocolIEs.list.array == NULLP)
11109       {
11110          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
11111          ret = RFAILED;
11112          break;
11113       }
11114
11115       for(idx=0; idx<elementCnt; idx++)
11116       {
11117          DU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
11118                sizeof(UEContextSetupResponseIEs_t));
11119          if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
11120          {
11121             DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
11122             ret = RFAILED;
11123             break;
11124          }
11125       }
11126       /* Fetching Ue Cb Info*/
11127       GET_CELL_IDX(cellId, cellIdx);
11128       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
11129       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
11130       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
11131
11132       idx = 0;
11133       /*GNB CU UE F1AP ID*/
11134       ueSetRsp->protocolIEs.list.array[idx]->id = \
11135                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11136       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11137       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
11138                                                              UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
11139       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
11140
11141       /*GNB DU UE F1AP ID*/
11142       idx++;
11143       ueSetRsp->protocolIEs.list.array[idx]->id = \
11144                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11145       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11146       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
11147                                                              UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
11148       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
11149
11150
11151       /*DUtoCURRC Information */
11152       idx++;
11153       ueSetRsp->protocolIEs.list.array[idx]->id  = \
11154                                                    ProtocolIE_ID_id_DUtoCURRCInformation;
11155       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11156       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
11157                                                             UEContextSetupResponseIEs__value_PR_DUtoCURRCInformation;
11158       if(ueCb->f1UeDb)
11159       {
11160          if(ueCb->f1UeDb->duUeCfg.cellGrpCfg)
11161          {
11162             cellGrpCfg = (CellGroupConfigRrc_t*)ueCb->f1UeDb->duUeCfg.cellGrpCfg;
11163             ret = EncodeUeCntxtDuToCuInfo(&ueSetRsp->protocolIEs.list.array[idx]->value.\
11164                      choice.DUtoCURRCInformation.cellGroupConfig, cellGrpCfg);
11165             if(ret == RFAILED)
11166             {
11167                DU_LOG("\nERROR  -->  F1AP : Failed to EncodeUeCntxtDuToCuInfo in BuildAndSendUeContextSetupRsp()");
11168                freeF1UeDb(ueCb->f1UeDb);
11169                ueCb->f1UeDb = NULLP;
11170                break;
11171             }
11172          }
11173       }
11174       else
11175       {
11176          DU_LOG("\nERROR  -->  F1AP : Failed to form DUtoCU RRCInfo at BuildAndSendUeContextSetupRsp()");
11177          ret = RFAILED;
11178          break;
11179       }
11180
11181       /* Drb Setup List */
11182       idx++;
11183       ueSetRsp->protocolIEs.list.array[idx]->id  = \
11184                                  ProtocolIE_ID_id_DRBs_Setup_List;
11185       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11186       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
11187                                  UEContextSetupResponseIEs__value_PR_DRBs_Setup_List;
11188       ret = fillDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List,\
11189                &ueCb->f1UeDb->duUeCfg);
11190       if(ret == RFAILED)
11191       {
11192          DU_LOG("\nERROR  -->  F1AP : Failed to fillDrbSetupList in BuildAndSendUeContextSetupRsp()");
11193          freeF1UeDb(ueCb->f1UeDb);
11194          ueCb->f1UeDb = NULLP;
11195          break;
11196       }
11197
11198        /* Free UeContext Db created during Ue context Req */
11199        freeF1UeDb(ueCb->f1UeDb);
11200        ueCb->f1UeDb = NULLP;
11201
11202       /* TODO: To send Drb list */
11203       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11204
11205       /* Encode the UE context setup response type as APER */
11206       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
11207       encBufSize = 0;
11208       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11209             encBuf);
11210       /* Encode results */
11211       if(encRetVal.encoded == ENCODE_FAIL)
11212       {
11213          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Response structure (at %s)\n",\
11214                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11215          ret = RFAILED;
11216          break;
11217       }
11218       else
11219       {
11220          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Setup Response\n");
11221          for(int i=0; i< encBufSize; i++)
11222          {
11223             printf("%x",encBuf[i]);
11224          }
11225       }
11226
11227       /* Sending  msg  */
11228       if(sendF1APMsg()  != ROK)
11229       {
11230          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Response failed");
11231          ret = RFAILED;
11232          break;
11233       }
11234       break;
11235    }
11236    FreeUeContextSetupRsp(f1apMsg);
11237    return ret;
11238 }/* End of BuildAndSendUeContextSetupRsp */
11239 /*******************************************************************
11240 *
11241 * @brief  Build And Send Ue Context Rsp
11242 *
11243 * @details
11244 *
11245 *    Function : BuildAndSendUeCtxtRsp
11246 *
11247 *    Functionality : Build And Send Ue Context Rsp
11248
11249 * @params[in]
11250 * @return sucess = ROK
11251 *         failure = RFAILED
11252 *
11253 * ****************************************************************/
11254 uint8_t BuildAndSendUeCtxtRsp(uint8_t cellId, uint8_t ueIdx)
11255 {
11256    uint8_t cellIdx = 0, actionType = 0;
11257
11258    GET_CELL_IDX(cellId, cellIdx);
11259    actionType = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].f1UeDb->actionType;
11260
11261    switch(actionType)
11262    {
11263       case UE_CTXT_SETUP:
11264          {
11265             BuildAndSendUeContextSetupRsp(cellId,ueIdx);
11266             break;
11267          }
11268       case UE_CTXT_MOD:
11269          {
11270             BuildAndSendUeContextModRsp(cellId, ueIdx);
11271             break;
11272          }
11273       default:
11274          DU_LOG("ERROR  -->  F1AP: Invalid Action Type %d at BuildAndSendUeCtxtRsp()", actionType);
11275          break;
11276
11277    }
11278    return ROK;
11279 }
11280
11281 /*******************************************************************
11282  *
11283  * @brief deallocating the memory of  F1reset msg
11284  *
11285  * @details
11286  *
11287  *    Function : FreeF1ResetReq
11288  *
11289  *    Functionality :
11290  *         - freeing memory of F1reset request msg
11291  *
11292  * @params[in]
11293  * @return void
11294  *
11295  *
11296  * ****************************************************************/
11297 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
11298 {
11299    uint8_t idx =0 ;
11300    Reset_t *f1ResetMsg;
11301
11302    if(f1apMsg)
11303    {
11304       if(f1apMsg->choice.initiatingMessage)
11305       {
11306          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11307
11308          if(f1ResetMsg->protocolIEs.list.array)
11309          {
11310             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
11311             {
11312                if(f1ResetMsg->protocolIEs.list.array[idx])
11313                {
11314                   DU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
11315                }
11316             }
11317             DU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
11318          }
11319          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11320       }
11321       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11322    }
11323 }
11324 /*******************************************************************
11325  *
11326  * @brief Build and Send F1reset request
11327  *
11328  * @details
11329  *
11330  *    Function : BuildAndSendF1ResetReq
11331  *
11332  *    Functionality:
11333  *         - Build and Send F1reset request msg
11334  *
11335  * @params[in]
11336  * @return ROK     - success
11337  *         RFAILED - failure
11338  *
11339  * ****************************************************************/
11340 uint8_t BuildAndSendF1ResetReq()
11341 {
11342    uint8_t          elementCnt=0;
11343    uint8_t          idx=0;
11344    uint8_t          ret= RFAILED;
11345    Reset_t          *f1ResetMsg = NULLP;
11346    F1AP_PDU_t       *f1apMsg = NULLP;
11347    asn_enc_rval_t   encRetVal;
11348    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset request \n");
11349    do
11350    {
11351       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11352       if(f1apMsg == NULLP)
11353       {
11354          break;
11355       }
11356       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
11357       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11358       if(f1apMsg->choice.initiatingMessage == NULLP)
11359       {
11360          break;
11361       }
11362       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
11363       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
11364       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
11365
11366       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11367
11368       elementCnt = 3;
11369       f1ResetMsg->protocolIEs.list.count = elementCnt;
11370       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
11371
11372       /* Initialize the F1Setup members */
11373       DU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
11374       if(f1ResetMsg->protocolIEs.list.array == NULLP)
11375       {
11376          break;
11377       }
11378       for(idx=0; idx<elementCnt; idx++)
11379       {
11380          DU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
11381          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
11382          {
11383             break;
11384          }
11385       }
11386
11387       /*TransactionID*/
11388       idx=0;
11389       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
11390       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11391       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
11392       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
11393
11394       /*Cause*/
11395       idx++;
11396       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
11397       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
11398       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
11399       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
11400       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
11401
11402       /*Reset Type*/
11403       idx++;
11404       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
11405       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11406       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
11407       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
11408       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
11409
11410       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11411
11412       /* Encode the F1SetupRequest type as APER */
11413       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11414       encBufSize = 0;
11415       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11416             encBuf);
11417
11418       /* Encode results */
11419       if(encRetVal.encoded == ENCODE_FAIL)
11420       {
11421          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
11422                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11423          break;
11424       }
11425       else
11426       {
11427          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1Reset\n");
11428          for(idx=0; idx< encBufSize; idx++)
11429          {
11430             printf("%x",encBuf[idx]);
11431          }
11432       }
11433
11434       if(sendF1APMsg() != ROK)
11435       {
11436          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
11437          break;
11438       }
11439
11440       ret = ROK;
11441       break;
11442    }while(true);
11443
11444    FreeF1ResetReq(f1apMsg);
11445    return ret;
11446 }
11447 /*******************************************************************
11448  *
11449  * @brief Build And Send F1ResetAck
11450  *
11451  * @details
11452  *
11453  *    Function : BuildAndSendF1ResetAck
11454  *
11455  *    Functionality:
11456  *         - Build And Send  F1ResetRSP
11457  *
11458  * @return ROK     - success
11459  *         RFAILED - failure
11460  *
11461  * ****************************************************************/
11462 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
11463 {
11464    uint8_t idx;
11465    ResetAcknowledge_t *f1ResetAck;
11466
11467    if(f1apMsg)
11468    {
11469       if(f1apMsg->choice.successfulOutcome)
11470       {
11471          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
11472
11473          if(f1ResetAck->protocolIEs.list.array)
11474          {
11475             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
11476             {
11477                if(f1ResetAck->protocolIEs.list.array[idx])
11478                {
11479                   DU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
11480                }
11481             }
11482             DU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
11483          }
11484          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11485       }
11486       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11487    }
11488 }
11489
11490 /*******************************************************************
11491  *
11492  * @brief Build And Send F1ResetAck
11493  *
11494  * @details
11495  *
11496  *    Function : BuildAndSendF1ResetAck
11497  *
11498  *    Functionality:
11499  *         - Build And Send  F1ResetRSP
11500  *
11501  *  @params[in]
11502  * @return ROK     - success
11503  *         RFAILED - failure
11504  *
11505  * ****************************************************************/
11506 uint8_t BuildAndSendF1ResetAck()
11507 {
11508    uint8_t                idx = 0;
11509    uint8_t                elementCnt = 0;
11510    uint8_t                ret = RFAILED;
11511    F1AP_PDU_t             *f1apMsg = NULL;
11512    ResetAcknowledge_t     *f1ResetAck = NULLP;
11513    asn_enc_rval_t         encRetVal;
11514    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset Acknowledgment \n");
11515
11516    do{
11517       /* Allocate the memory for F1ResetRequest_t */
11518       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11519       if(f1apMsg == NULLP)
11520       {
11521          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11522          break;
11523       }
11524
11525       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
11526
11527       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11528       if(f1apMsg->choice.successfulOutcome == NULLP)
11529       {
11530          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11531          break;
11532       }
11533       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
11534       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
11535       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
11536
11537       elementCnt = 1;
11538
11539       f1ResetAck->protocolIEs.list.count = elementCnt;
11540       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
11541
11542       DU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
11543       if(f1ResetAck->protocolIEs.list.array == NULLP)
11544       {
11545          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
11546          break;
11547       }
11548
11549       for(idx=0; idx<elementCnt; idx++)
11550       {
11551          DU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
11552          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
11553          {
11554             break;
11555          }
11556       }
11557       /*TransactionID*/
11558       idx = 0;
11559       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
11560       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11561       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
11562       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
11563
11564       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11565
11566       /* Encode the F1SetupRequest type as UPER */
11567       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11568       encBufSize = 0;
11569       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
11570
11571       /* Check encode results */
11572       if(encRetVal.encoded == ENCODE_FAIL)
11573       {
11574          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
11575                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11576          break;
11577       }
11578       else
11579       {
11580          DU_LOG("\nDUBUG   -->  F1AP : Created APER encoded buffer for F1ResetAck\n");
11581          for(int i=0; i< encBufSize; i++)
11582          {
11583             printf("%x",encBuf[i]);
11584          }
11585       }
11586       /* Sending msg */
11587       if(sendF1APMsg() != ROK)
11588       {
11589          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Acknowledgement failed");
11590          break;
11591       }
11592
11593       ret = ROK;
11594       break;
11595    }while(true);
11596
11597    FreeF1ResetAck(f1apMsg);
11598    return ret;
11599 }
11600 /******************************************************************
11601 *
11602 * @brief free F1 reset msg allocated by aper_decoder
11603 *
11604 * @details
11605 *
11606 *    Function : freeAperDecodeF1ResetMsg
11607 *
11608 *    Functionality: free F1 reset msg allocated by aper_decoder
11609 *
11610 * @params[in] Reset_t *f1ResetMsg
11611 * @return void
11612 *
11613 * ****************************************************************/
11614
11615 void freeAperDecodeF1ResetMsg(Reset_t *f1ResetMsg)
11616 {
11617    uint8_t ieIdx =0;
11618    if(f1ResetMsg->protocolIEs.list.array)
11619    {
11620       for(ieIdx=0 ;ieIdx < f1ResetMsg->protocolIEs.list.count ; ieIdx++)
11621       {
11622          if(f1ResetMsg->protocolIEs.list.array[ieIdx])
11623          {
11624             free(f1ResetMsg->protocolIEs.list.array[ieIdx]);
11625          }
11626       }
11627       free(f1ResetMsg->protocolIEs.list.array);
11628    }
11629 }
11630
11631 /******************************************************************
11632  *
11633  * @brief Processes DL RRC Message Transfer  sent by CU
11634  *
11635  * @details
11636  *
11637  *    Function : procF1ResetReq
11638  *
11639  *    Functionality: Processes DL RRC Message Transfer sent by CU
11640  *
11641  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11642  * @return ROK     - success
11643  *         RFAILED - failure
11644  *
11645  * ****************************************************************/
11646 uint8_t procF1ResetReq(F1AP_PDU_t *f1apMsg)
11647 {
11648    /* we are currently not supporting Ue release. right now we are supporting only init case of fireset */
11649    uint8_t       ieIdx = 0;
11650    uint8_t        ret = ROK;
11651    Reset_t       *f1ResetMsg = NULLP;
11652
11653    DU_LOG("\nINFO   -->  Processing F1 reset request");
11654    f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11655
11656    for(ieIdx=0; ieIdx<f1ResetMsg->protocolIEs.list.count; ieIdx++)
11657    {
11658       switch(f1ResetMsg->protocolIEs.list.array[ieIdx]->id)
11659       {
11660          case ProtocolIE_ID_id_TransactionID:
11661             break;
11662
11663          case ProtocolIE_ID_id_Cause:
11664             break;
11665
11666          case ProtocolIE_ID_id_ResetType:
11667             {
11668                break;
11669             }
11670
11671          default:
11672             break;
11673       }
11674    }
11675    ret = BuildAndSendF1ResetAck();
11676    DU_LOG("\nINFO   -->  UE release is not supported for now");
11677
11678    freeAperDecodeF1ResetMsg(f1ResetMsg);
11679
11680    return ret;
11681 }
11682
11683 /*******************************************************************
11684  *
11685  * @brief free the RRC delivery report
11686  *
11687  * @details
11688  *
11689  *    Function : freeRrcDeliveryReport
11690  *
11691  *    Functionality: free the RRC delivery report
11692  *
11693  * @params[in]
11694  * @return ROK     - success
11695  *         RFAILED - failure
11696  *
11697  * ****************************************************************/
11698 void freeRrcDeliveryReport(F1AP_PDU_t  *f1apMsg )
11699 {
11700    uint8_t idx=0;
11701    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11702
11703    if(f1apMsg)
11704    {
11705       if(f1apMsg->choice.initiatingMessage)
11706       {
11707          rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11708          if(rrcDeliveryReport->protocolIEs.list.array)
11709          {
11710             for(idx =0 ;idx <rrcDeliveryReport->protocolIEs.list.count ;
11711                   idx++)
11712             {
11713                if(rrcDeliveryReport->protocolIEs.list.array[idx])
11714                {
11715                   DU_FREE(rrcDeliveryReport->protocolIEs.list.array[idx],
11716                         sizeof(RRCDeliveryReportIEs_t));
11717                }
11718             }
11719             DU_FREE(rrcDeliveryReport->protocolIEs.list.array,
11720                   rrcDeliveryReport->protocolIEs.list.size);
11721          }
11722          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11723       }
11724       DU_FREE(f1apMsg,
11725             sizeof(F1AP_PDU_t));
11726    }
11727 }
11728
11729 /*******************************************************************
11730 *
11731 * @brief Builds and sends the RRC delivery report
11732 *
11733 * @details
11734 *
11735 *    Function : BuildAndSendRrcDeliveryReport
11736 *
11737 *    Functionality: Builds and sends the RRC delivery report
11738 *
11739 * @params[in]
11740 *
11741 * @return ROK     - success
11742 *         RFAILED - failure
11743 *
11744 * ****************************************************************/
11745 uint8_t BuildAndSendRrcDeliveryReport(uint32_t gnbCuUeF1apId, \
11746    uint32_t gnbDuUeF1apId, RrcDeliveryReport *rrcDelivery)
11747 {
11748    uint8_t             ret = RFAILED;
11749    uint8_t             idx    = 0;
11750    uint8_t             idx1   = 0;
11751    uint8_t             elementCnt = 0;
11752    F1AP_PDU_t          *f1apMsg = NULLP;
11753    asn_enc_rval_t      encRetVal;
11754    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11755
11756    do{
11757
11758       DU_LOG("\nINFO   -->  F1AP : Building RRC delivery Message Transfer Message\n");
11759       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11760       if(f1apMsg == NULLP)
11761       {
11762          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11763          break;
11764       }
11765       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
11766       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11767       if(f1apMsg->choice.initiatingMessage == NULLP)
11768       {
11769          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU  failed");
11770          break;
11771       }
11772       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_RRCDeliveryReport;
11773       f1apMsg->choice.initiatingMessage->criticality   = Criticality_ignore;
11774       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RRCDeliveryReport;
11775
11776       rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11777       elementCnt = 4;
11778       rrcDeliveryReport->protocolIEs.list.count = elementCnt;
11779       rrcDeliveryReport->protocolIEs.list.size = elementCnt * sizeof(RRCDeliveryReportIEs_t *);
11780
11781       /* Initialize the F1Setup members */
11782       DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array, rrcDeliveryReport->protocolIEs.list.size);
11783       if(rrcDeliveryReport->protocolIEs.list.array == NULLP)
11784       {
11785          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRC Delivery  failed");
11786          break;
11787       }
11788       for(idx =0 ;idx <elementCnt; idx++)
11789       {
11790          DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array[idx], sizeof(RRCDeliveryReportIEs_t));
11791          if(rrcDeliveryReport->protocolIEs.list.array[idx] == NULLP)
11792          {
11793             break;
11794          }
11795       }
11796
11797       idx1 = 0;
11798
11799       /*GNB CU UE F1AP ID*/
11800       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11801       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
11802       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_CU_UE_F1AP_ID;
11803       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
11804
11805       /*GNB DU UE F1AP ID*/
11806       idx1++;
11807       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11808       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
11809       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_DU_UE_F1AP_ID;
11810       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
11811
11812       /*RRC delivery status*/
11813       idx1++;
11814       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_RRCDeliveryStatus;
11815       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
11816       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_RRCDeliveryStatus;
11817       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.delivery_status =\
11818       rrcDelivery->rrcDeliveryStatus.deliveryStatus;
11819       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.triggering_message =\
11820       rrcDelivery->rrcDeliveryStatus.triggeringMessage;
11821
11822       /* SRB ID */
11823       idx1++;
11824       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
11825       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
11826       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_SRBID;
11827       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.SRBID =  rrcDelivery->srbId;
11828
11829       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11830
11831       /* Encode the RRC DELIVERY REPORT type as APER */
11832       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11833       encBufSize = 0;
11834       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11835             encBuf);
11836
11837       /* Encode results */
11838       if(encRetVal.encoded == ENCODE_FAIL)
11839       {
11840          DU_LOG("\nERROR  -->  F1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
11841                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11842          break;
11843       }
11844       else
11845       {
11846          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for RRC Delivery Msg \n");
11847          for(idx=0; idx< encBufSize; idx++)
11848          {
11849             printf("%x",encBuf[idx]);
11850          }
11851       }
11852
11853       /* Sending msg */
11854       if(sendF1APMsg() != ROK)
11855       {
11856          DU_LOG("\nERROR  -->  F1AP : Sending RRC delivery  msg request failed");
11857          break;
11858       }
11859       ret = ROK;
11860       break;
11861
11862    }while(true);
11863
11864    freeRrcDeliveryReport(f1apMsg);
11865    return ret;
11866 }
11867
11868 /*******************************************************************
11869  *
11870  * @brief Processes cells to be activated
11871  *
11872  * @details
11873  *
11874  *    Function : extractCellsToBeActivated
11875  *
11876  *    Functionality:
11877  *      - Processes cells to be activated list received in F1SetupRsp
11878  *
11879  * @params[in] void
11880  * @return ROK     - success
11881  *         RFAILED - failure
11882  *
11883  * ****************************************************************/
11884
11885 uint8_t extractCellsToBeActivated(Cells_to_be_Activated_List_t cellsToActivate)
11886 {
11887    uint8_t  ret = ROK;
11888    uint16_t idx, nci, pci = 0;
11889    Cells_to_be_Activated_List_Item_t cell;
11890
11891    for(idx=0; idx<cellsToActivate.list.count; idx++)
11892    {
11893       nci = 0;
11894       cell = cellsToActivate.list.array[idx]->value.choice.Cells_to_be_Activated_List_Item;
11895       bitStringToInt(&cell.nRCGI.nRCellIdentity, &nci);
11896
11897       if(cell.nRPCI)
11898       {
11899          pci = *cell.nRPCI;
11900       }
11901       ret = duProcCellsToBeActivated(cell.nRCGI.pLMN_Identity.buf, nci, pci);
11902    }
11903    return ret;
11904 }
11905 /******************************************************************
11906 *
11907 * @brief Processes F1 Setup Response allocated by aper_decoder
11908 *
11909 * @details
11910 *
11911 *    Function : freeF1SetupRsp
11912 *
11913 *    Functionality: free F1 Setup Response allocated by aper_decoder
11914 *
11915 * @params[in] F1SetupResponse_t *f1SetRspMsg
11916 * @return void
11917 *
11918 * ****************************************************************/
11919
11920 void freeAperDecodeF1SetupRsp(F1SetupResponse_t *f1SetRspMsg)
11921 {
11922    uint8_t ieIdx =0;
11923    uint8_t arrIdx =0;
11924    Cells_to_be_Activated_List_t *cellToActivate =NULLP;
11925    RRC_Version_t      *rrcVer =NULLP;
11926
11927    if(f1SetRspMsg->protocolIEs.list.array)
11928    {
11929       for(ieIdx=0; ieIdx<f1SetRspMsg->protocolIEs.list.count; ieIdx++)
11930       {
11931          if(f1SetRspMsg->protocolIEs.list.array[ieIdx])
11932          {
11933             switch(f1SetRspMsg->protocolIEs.list.array[ieIdx]->id)
11934             {
11935                case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11936                   {
11937                      cellToActivate =
11938                         &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.Cells_to_be_Activated_List;
11939                      if(cellToActivate->list.array)
11940                      {
11941                         for(arrIdx=0; arrIdx<cellToActivate->list.count ; arrIdx++)
11942                         {
11943                            if(cellToActivate->list.array[arrIdx])
11944                            {
11945
11946                               if(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.\
11947                               pLMN_Identity.buf)
11948                               {
11949                                  if(cellToActivate->list.array[0]->value.choice.\
11950                                        Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf)
11951                                  {
11952                                     free(cellToActivate->list.array[0]->value.choice.\
11953                                           Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf);
11954                                  }
11955
11956                                  free(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
11957                                        nRCGI.pLMN_Identity.buf);
11958                               }
11959                               free(cellToActivate->list.array[arrIdx]);
11960                            }
11961                         }
11962                         free(cellToActivate->list.array);
11963                      }
11964                      break;
11965                   }
11966                case ProtocolIE_ID_id_TransactionID:
11967                   {
11968                      break;
11969                   }
11970                case ProtocolIE_ID_id_gNB_CU_Name:
11971                   {
11972                      free(f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_Name.buf);
11973                      break;
11974                   }
11975                case ProtocolIE_ID_id_GNB_CU_RRC_Version:
11976                   {
11977                      rrcVer = &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
11978                      if(rrcVer->latest_RRC_Version.buf)
11979                      {
11980                         if(rrcVer->iE_Extensions)
11981                         {
11982                            if(rrcVer->iE_Extensions->list.array)
11983                            {
11984                               if(rrcVer->iE_Extensions->list.array[0])
11985                               {
11986                                  if(rrcVer->iE_Extensions->list.\
11987                                        array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf)
11988                                  {
11989                                     free(rrcVer->iE_Extensions->list.\
11990                                           array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf);
11991                                  }
11992                                  free(rrcVer->iE_Extensions->list.array[0]);
11993                               }
11994                               free(rrcVer->iE_Extensions->list.array);
11995                            }
11996                            free(rrcVer->iE_Extensions);
11997                         }
11998                         free(rrcVer->latest_RRC_Version.buf);
11999                      }
12000                      break;
12001
12002                   }
12003                default:
12004                   {
12005                      DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
12006                            f1SetRspMsg->protocolIEs.list.array[ieIdx]->id);
12007                   }
12008             }
12009             free(f1SetRspMsg->protocolIEs.list.array[ieIdx]);
12010          }
12011       }
12012       free(f1SetRspMsg->protocolIEs.list.array);
12013    }
12014 }
12015 /******************************************************************
12016  *
12017  * @brief Processes F1 Setup Response sent by CU
12018  *
12019  * @details
12020  *
12021  *    Function : procF1SetupRsp
12022  *
12023  *    Functionality: Processes F1 Setup Response sent by CU
12024  *
12025  * @params[in] F1AP_PDU_t ASN decoded F1AP message
12026  * @return ROK     - success
12027  *         RFAILED - failure
12028  *
12029  * ****************************************************************/
12030 uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg)
12031 {
12032    uint8_t ret = ROK;
12033    uint16_t idx =0;
12034    F1SetupResponse_t *f1SetRspMsg = NULLP;
12035    GNB_CU_Name_t     *cuName = NULLP;
12036    F1SetupRsp  f1SetRspDb;
12037    RRC_Version_t      *rrcVer =NULLP;
12038
12039    memset(&f1SetRspDb, 0, sizeof(F1SetupRsp));
12040
12041    DU_LOG("\nINFO   -->  F1AP : F1 Setup Response received");
12042    f1SetRspMsg = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
12043
12044    for(idx=0; idx<f1SetRspMsg->protocolIEs.list.count; idx++)
12045    {
12046       switch(f1SetRspMsg->protocolIEs.list.array[idx]->id)
12047       {
12048          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
12049             {
12050                extractCellsToBeActivated(f1SetRspMsg->protocolIEs.list.array[idx]->\
12051                      value.choice.Cells_to_be_Activated_List);
12052                break;
12053             }
12054          case ProtocolIE_ID_id_TransactionID:
12055             {
12056                f1SetRspDb.transId = f1SetRspMsg->protocolIEs.list.array[idx]->\
12057                                     value.choice.TransactionID;
12058                break;
12059             }
12060          case ProtocolIE_ID_id_gNB_CU_Name:
12061             {
12062                cuName = &f1SetRspMsg->protocolIEs.list.array[idx]->\
12063                         value.choice.GNB_CU_Name;
12064                strcpy(f1SetRspDb.cuName, (const char*)cuName->buf);
12065                break;
12066             }
12067          case ProtocolIE_ID_id_GNB_CU_RRC_Version:
12068             {
12069                rrcVer = &f1SetRspMsg->protocolIEs.list.array[idx]->value.choice.RRC_Version;
12070                strcpy(f1SetRspDb.rrcVersion.rrcVer,
12071                      (const char*)rrcVer->latest_RRC_Version.buf);
12072                break;
12073             }
12074          default:
12075             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
12076                   f1SetRspMsg->protocolIEs.list.array[idx]->id);
12077       }
12078       duProcF1SetupRsp();
12079    }
12080
12081    freeAperDecodeF1SetupRsp(f1SetRspMsg);
12082    return ret;
12083 }
12084 /*******************************************************************
12085 *
12086 * @brief free GNB DU config update ack
12087 *
12088 * @details
12089 *
12090 *    Function : freeAperDecodeGnbDuAck
12091 *
12092 *    Functionality: Processes GNB DU config update ack And
12093 *                     added free part for the memory allocated by aper_decoder
12094 *
12095 * @params[in] F1AP_PDU_t ASN decoded F1AP message
12096 * @return ROK     - success
12097 *         RFAILED - failure
12098 *
12099 * ****************************************************************/
12100
12101 void freeAperDecodeGnbDuAck(GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck)
12102 {
12103    uint8_t ieIdx = 0;
12104
12105    if(gnbDuAck->protocolIEs.list.array)
12106    {
12107       for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
12108       {
12109          if(gnbDuAck->protocolIEs.list.array[ieIdx])
12110          {
12111             free(gnbDuAck->protocolIEs.list.array[ieIdx]);
12112          }
12113       }
12114       free(gnbDuAck->protocolIEs.list.array);
12115    }
12116 }
12117
12118 /*******************************************************************
12119 *
12120 * @brief Building  result of gnb-du config update ack output
12121 *
12122 * @details
12123 *
12124 *    Function : duProcGnbDuCfgUpdAckMsg
12125 *
12126 *    Functionality:
12127 *        Building output of gnb-du config update ack
12128 *
12129 * @params[in] transId
12130 * @return void
12131 *
12132 * ****************************************************************/
12133
12134 uint8_t duProcGnbDuCfgUpdAckMsg(uint8_t transId)
12135 {
12136    uint8_t  ieIdx=0, arrIdx=0,ret=ROK;
12137    uint8_t  ueId =0 , ueIdx =0;
12138    uint16_t cellId =0, cellIdx =0, crnti=0;
12139    CmLList *f1apPduNode = NULLP;
12140    ReservedF1apPduInfo *f1apPduInfo =NULLP;
12141    F1AP_PDU_t *f1apMsgPdu = NULLP;
12142    GNBDUConfigurationUpdate_t *gnbDuConfigUpdate = NULLP;
12143    BIT_STRING_t *cellIdentity=NULLP;
12144    struct Served_Cells_To_Delete_ItemIEs *deleteItemIe=NULLP;
12145    Served_Cells_To_Delete_List_t *cellsToDelete=NULLP;
12146    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
12147
12148    DU_LOG("\nINFO   -->  DU APP: GNB-DU config update Ack received ");
12149    f1apPduNode = searchFromReservedF1apPduList(transId);
12150    f1apPduInfo = (ReservedF1apPduInfo *)f1apPduNode->node;
12151    f1apMsgPdu = (F1AP_PDU_t *)f1apPduInfo->f1apMsg;
12152
12153    if(f1apMsgPdu)
12154    {
12155       if(f1apMsgPdu->choice.initiatingMessage)
12156       {
12157          gnbDuConfigUpdate = &f1apMsgPdu->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
12158          for(ieIdx=0; ieIdx < gnbDuConfigUpdate->protocolIEs.list.count; ieIdx++)
12159          {
12160             switch(gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->id)
12161             {
12162                case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
12163                   {
12164                      cellsToDelete = &gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
12165                                      Served_Cells_To_Delete_List;
12166                      if(cellsToDelete->list.array)
12167                      {
12168                         if(cellsToDelete->list.array[arrIdx])
12169                         {
12170                            deleteItemIe = (Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx];
12171                            deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
12172                            if(deleteItem->oldNRCGI.nRCellIdentity.buf)
12173                            {
12174                               cellIdentity = &deleteItem->oldNRCGI.nRCellIdentity;
12175                               bitStringToInt(cellIdentity, &cellId);
12176                            }
12177                         }
12178                      }
12179
12180                      GET_CELL_IDX(cellId, cellIdx);
12181                      if(duCb.actvCellLst[cellIdx] != NULLP)
12182                      {
12183                         if(duCb.actvCellLst[cellIdx]->numActvUes == 0)
12184                         {
12185                            duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
12186                            ret = duSendCellDeletReq(cellId);
12187                            if(ret == RFAILED)
12188                            {
12189                               DU_LOG("ERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to send cell delete\
12190                               request for cellId[%d]", cellId);
12191                            }
12192                         }
12193                         else
12194                         {
12195                            for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
12196                            {
12197                               crnti = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].crnti;
12198                               GET_UE_IDX(crnti,ueId);
12199                               ret = BuildAndSendUeContextReleaseReq(cellId, ueId);
12200                               if(ret == RFAILED)
12201                               {
12202                                  DU_LOG("ERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to build and send UE delete\
12203                                  request for cellId[%d]", cellId);
12204                               }
12205                            }
12206                         }
12207                      }
12208                      else
12209                      {
12210                         DU_LOG("ERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): CellId [%d] not found", cellId);
12211                         ret = RFAILED;
12212                      }
12213                      break;
12214                   }
12215
12216                default:
12217                   break;
12218             }
12219          }
12220       }
12221    }
12222
12223    FreeDUConfigUpdate(f1apMsgPdu);
12224    deleteFromReservedF1apPduList(f1apPduNode);
12225    return ret;
12226 }
12227
12228 /*******************************************************************
12229 *
12230 * @brief Processes GNB DU config update ack
12231 *
12232 * @details
12233 *
12234 *    Function : procF1GNBDUCfgUpdAck
12235 *
12236 *    Functionality: added free part for the memory allocated by aper_decoder
12237 *
12238 * @params[in] F1AP_PDU_t *f1apMsg
12239 * @return void
12240 *
12241 * ****************************************************************/
12242 uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
12243 {
12244    uint8_t ieIdx=0,transId=0;
12245    GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
12246
12247    DU_LOG("\nINFO   -->  F1AP : GNB-DU config update acknowledgment");
12248    gnbDuAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
12249
12250    for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
12251    {
12252       switch(gnbDuAck->protocolIEs.list.array[ieIdx]->id)
12253       {
12254          case ProtocolIE_ID_id_TransactionID:
12255             {
12256                transId = gnbDuAck->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
12257                break;
12258             }
12259          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
12260             {
12261                break;
12262             }
12263          default :
12264             {
12265                DU_LOG("\nERROR  -->  F1AP: procF1GNBDUCfgUpdAck(): Invalid IE Received: %ld", \
12266                      gnbDuAck->protocolIEs.list.array[ieIdx]->id);
12267                break;
12268             }
12269       }
12270    }
12271
12272    duProcGnbDuCfgUpdAckMsg(transId);
12273
12274 #if 0
12275    /* presently we are not supporting F1 Reset from DU to CU , we are only
12276     * supporting F1 Reset from CU to DU */
12277
12278    if(BuildAndSendF1ResetReq() != ROK)
12279    {
12280       return RFAILED;
12281    }
12282 #endif
12283
12284    freeAperDecodeGnbDuAck(gnbDuAck);
12285    return ROK;
12286 }
12287 /******************************************************************
12288 *
12289 * @brief free DL RRC Message Transfer allocated by aper_decoder
12290 *
12291 * @details
12292 *
12293 *    Function : freeAperDecodef1DlRrcMsg
12294 *
12295 *    Functionality: free DL RRC Message Transfer allocated by aper_decoder
12296 *
12297 * @params[in] DLRRCMessageTransfer_t *f1DlRrcMsg
12298 * @return ROK     - success
12299 *         RFAILED - failure
12300 *
12301 * ****************************************************************/
12302
12303 void freeAperDecodef1DlRrcMsg(DLRRCMessageTransfer_t *f1DlRrcMsg)
12304 {
12305    uint8_t ieIdx =0;
12306    RRCContainer_t *rrcContainer = NULLP;
12307
12308    if(f1DlRrcMsg->protocolIEs.list.array)
12309    {
12310       for(ieIdx=0; ieIdx<f1DlRrcMsg->protocolIEs.list.count; ieIdx++)
12311       {
12312          if(f1DlRrcMsg->protocolIEs.list.array[ieIdx])
12313          {
12314             switch(f1DlRrcMsg->protocolIEs.list.array[ieIdx]->id)
12315             {
12316                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12317                   break;
12318                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12319                   break;
12320                case ProtocolIE_ID_id_SRBID:
12321                   break;
12322                case ProtocolIE_ID_id_RRCContainer:
12323                   {
12324                      rrcContainer =&f1DlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
12325                      free(rrcContainer->buf);
12326                   }
12327                case ProtocolIE_ID_id_ExecuteDuplication:
12328                   break;
12329                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
12330                   break;
12331                   break;
12332             }
12333             free(f1DlRrcMsg->protocolIEs.list.array[ieIdx]);
12334          }
12335       }
12336       free(f1DlRrcMsg->protocolIEs.list.array);
12337    }
12338 }
12339 /******************************************************************
12340  *
12341  * @brief Processes DL RRC Message Transfer  sent by CU
12342  *
12343  * @details
12344  *
12345  *    Function : procF1DlRrcMsgTrans
12346  *
12347  *    Functionality: Processes DL RRC Message Transfer sent by CU
12348  *
12349  * @params[in] F1AP_PDU_t ASN decoded F1AP message
12350  * @return ROK     - success
12351  *         RFAILED - failure
12352  *
12353  * ****************************************************************/
12354 uint8_t procF1DlRrcMsgTrans(F1AP_PDU_t *f1apMsg)
12355 {
12356    uint8_t  idx, ret;
12357    DLRRCMessageTransfer_t *f1DlRrcMsg = NULLP;
12358    F1DlRrcMsg dlMsg;
12359    memset(&dlMsg, 0, sizeof(F1DlRrcMsg));
12360
12361    DU_LOG("\nINFO   -->  DU_APP : DL RRC message transfer Recevied");
12362    f1DlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
12363
12364    ret = ROK;
12365
12366    for(idx=0; idx<f1DlRrcMsg->protocolIEs.list.count; idx++)
12367    {
12368       switch(f1DlRrcMsg->protocolIEs.list.array[idx]->id)
12369       {
12370          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12371             {
12372                dlMsg.gnbCuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
12373                break;
12374             }
12375          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12376             {
12377                dlMsg.gnbDuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
12378                break;
12379             }
12380          case ProtocolIE_ID_id_SRBID:
12381             {
12382                dlMsg.srbId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
12383                break;
12384             }
12385          case ProtocolIE_ID_id_ExecuteDuplication:
12386             dlMsg.execDup = true;
12387             break;
12388
12389          case ProtocolIE_ID_id_RRCContainer:
12390             {
12391                if(f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0)
12392                {
12393                   dlMsg.rrcMsgSize = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
12394                   DU_ALLOC_SHRABL_BUF(dlMsg.rrcMsgPdu, dlMsg.rrcMsgSize);
12395                   if(dlMsg.rrcMsgPdu)
12396                   {
12397                      memcpy(dlMsg.rrcMsgPdu, f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
12398                         dlMsg.rrcMsgSize);
12399                   }
12400                   else
12401                   {
12402                      DU_LOG("\nERROR  -->  DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
12403                      return RFAILED;
12404                   }
12405                }
12406                else
12407                {
12408                   DU_LOG("\nERROR  -->  DU_APP : RRC Container Size is invalid:%ld",\
12409                   f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
12410                   return RFAILED;
12411                }
12412                break;
12413             }
12414          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
12415             {
12416                dlMsg.deliveryStatRpt = true;
12417                break;
12418             }
12419          default:
12420             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
12421                   f1DlRrcMsg->protocolIEs.list.array[idx]->id);
12422       }
12423    }
12424
12425    ret = duProcDlRrcMsg(&dlMsg);
12426
12427    freeAperDecodef1DlRrcMsg(f1DlRrcMsg);
12428    return ret;
12429 }
12430 /*******************************************************************
12431  *
12432 * @brief Builds the DRB to be Setup Mod list
12433 *
12434 * @details
12435 *
12436 *    Function :
12437 *
12438 *    Functionality: Constructs the DRB to be Setup Mod list
12439 *
12440 * @params[in] DRBs_SetupMod_List_t *drbSet
12441 *
12442 * @return ROK     - success
12443 *         RFAILED - failure
12444 *
12445 * ****************************************************************/
12446
12447 uint8_t BuildDrbSetupModList(DRBs_SetupMod_List_t *drbSet , DuUeCfg *ueCfg)
12448 {
12449    uint8_t arrIdx =0;
12450    uint8_t drbCnt =0;
12451    struct DRBs_SetupMod_ItemIEs *drbItemIe;
12452
12453    drbCnt = 1;
12454    drbSet->list.count = drbCnt;
12455    drbSet->list.size = drbCnt * sizeof(DRBs_SetupMod_ItemIEs_t *);
12456    DU_ALLOC(drbSet->list.array, drbSet->list.size);
12457    if(drbSet->list.array == NULLP)
12458    {
12459       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
12460       return  RFAILED;
12461    }
12462    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
12463    {
12464       DU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
12465       if(drbSet->list.array[arrIdx] == NULLP)
12466       {
12467               DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
12468               return  RFAILED;
12469       }
12470
12471       drbItemIe = (struct DRBs_SetupMod_ItemIEs *)drbSet->list.array[arrIdx];
12472       drbItemIe->id = ProtocolIE_ID_id_DRBs_SetupMod_Item;
12473       drbItemIe->criticality = Criticality_reject;
12474       drbItemIe->value.present = DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item;
12475       drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
12476       if(fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List,\
12477       &ueCfg->upTnlInfo[arrIdx])!= ROK)
12478       {
12479          DU_LOG("\nERROR  -->  F1AP : Failed to fill DlTnl SetupList in BuildDrbToBeSetupModList");
12480          return RFAILED;
12481       }
12482
12483    }
12484
12485    return ROK;
12486 }
12487 /*******************************************************************
12488 * @brief Free the memory allocated for DRB setup List
12489 *
12490 * @details
12491 *
12492 *    Function : FreeDrbSetupModList
12493 *
12494 *    Functionality:
12495 *       Free the memory allocated for DRB setup list
12496 *
12497 * @params[in] DRBs_Setup_List_t *
12498 * @return void
12499 *
12500 * ****************************************************************/
12501 void FreeDrbSetupModList(DRBs_SetupMod_List_t *drbSetupList)
12502 {
12503    uint8_t arrIdx = 0;
12504    DRBs_SetupMod_ItemIEs_t *drbItemIe = NULLP;
12505
12506    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
12507    {
12508       drbItemIe = ((DRBs_SetupMod_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
12509       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
12510       DU_FREE(drbSetupList->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
12511    }
12512    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
12513 }
12514 /*******************************************************************
12515 * @brief Free the memory allocated for UE Context Mod Response
12516 *
12517 * @details
12518 *
12519 *    Function : FreeUeContextModResp
12520 *
12521 *    Functionality:
12522 *       Free the memory allocated for UE Context Mod Response
12523 *
12524 * @params[in] F1AP_PDU_t *f1apMsg
12525 * @return void
12526 *
12527 * ****************************************************************/
12528
12529 void FreeUeContextModResp(F1AP_PDU_t *f1apMsg)
12530 {
12531    uint8_t ieIdx;
12532    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
12533    if(f1apMsg)
12534    {
12535       if(f1apMsg->choice.successfulOutcome)
12536       {
12537          ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
12538          if(ueContextModifyRes->protocolIEs.list.array)
12539          {
12540             for(ieIdx=0 ; ieIdx<ueContextModifyRes->protocolIEs.list.count; ieIdx++)
12541             {
12542                if(ueContextModifyRes->protocolIEs.list.array[ieIdx])
12543                {
12544                   switch(ueContextModifyRes->protocolIEs.list.array[ieIdx]->id)
12545                   {
12546                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12547                         break;
12548                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12549                         break;
12550                      case ProtocolIE_ID_id_DRBs_SetupMod_List:
12551                         {
12552                             FreeDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
12553                             value.choice.DRBs_SetupMod_List));
12554                             break;
12555                         }
12556                   }
12557                   DU_FREE(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
12558                }
12559
12560             }
12561             DU_FREE(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
12562          }
12563          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12564       }
12565       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12566    }
12567 }
12568
12569 /*****************************************************************i
12570 *
12571 * @brief Creating the ue context modifcation response and sending
12572 *
12573 * @details
12574 *
12575 *    Function : BuildAndSendUeContextModRsp
12576 *
12577 *    Functionality:
12578 *         - Creating the ue context modifcation response
12579 *
12580 * @params[in] uint8_t cellId,uint8_t ueIdx
12581 * @return ROK     - success
12582 *         RFAILED - failure
12583 *
12584 * ****************************************************************/
12585 uint8_t BuildAndSendUeContextModRsp(uint8_t cellId,uint8_t ueIdx)
12586 {
12587    uint8_t   ieIdx = 0;
12588    uint8_t   cellIdx =0;
12589    uint8_t   elementCnt = 0;
12590    uint8_t   ret = RFAILED;
12591    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
12592    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
12593    F1AP_PDU_t *f1apMsg = NULLP;
12594    asn_enc_rval_t         encRetVal;
12595    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
12596    DuUeCb                   *ueCb = NULLP;
12597
12598    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification response\n");
12599
12600    while(1)
12601    {
12602       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12603       if(f1apMsg == NULLP)
12604       {
12605          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
12606          break;
12607       }
12608
12609       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
12610
12611       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12612       if(f1apMsg->choice.successfulOutcome == NULLP)
12613       {
12614          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
12615          break;
12616       }
12617       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextModification;
12618       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
12619       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_UEContextModificationResponse;
12620
12621       ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
12622
12623       elementCnt = 3;
12624       ueContextModifyRes->protocolIEs.list.count = elementCnt;
12625       ueContextModifyRes->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationResponse_t*);
12626
12627       /* Initialize the UE context modification members */
12628       DU_ALLOC(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
12629       if(ueContextModifyRes->protocolIEs.list.array == NULLP)
12630       {
12631          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
12632          break;
12633       }
12634
12635       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
12636       {
12637          DU_ALLOC(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
12638          if(ueContextModifyRes->protocolIEs.list.array[ieIdx] == NULLP)
12639          {
12640             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
12641             break;
12642          }
12643       }
12644
12645       /* Fetching Ue Cb Info*/
12646       GET_CELL_IDX(cellId, cellIdx);
12647       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
12648       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
12649       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
12650
12651       ieIdx=0;
12652       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
12653       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12654       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
12655       UEContextModificationResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
12656       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
12657
12658       ieIdx++;
12659       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
12660       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12661       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present=\
12662       UEContextModificationResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
12663       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
12664
12665       ieIdx++;
12666       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_SetupMod_List;
12667       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12668       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
12669       UEContextModificationResponseIEs__value_PR_DRBs_SetupMod_List;
12670       if(ueCb->f1UeDb)
12671       {
12672          ret = BuildDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
12673                   value.choice.DRBs_SetupMod_List) , &ueCb->f1UeDb->duUeCfg);
12674          if(ret != ROK)
12675          {
12676             DU_LOG( "\nERROR  -->  F1AP : Failed to build drb setupmod List ");
12677             break;
12678          }
12679          freeF1UeDb(ueCb->f1UeDb);
12680          ueCb->f1UeDb = NULLP;
12681       }
12682       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12683
12684       /* Encode the F1SetupRequest type as APER */
12685       memset(encBuf, 0, ENC_BUF_MAX_LEN);
12686       encBufSize = 0;
12687       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,encBuf);
12688
12689       /* Encode results */
12690       if(encRetVal.encoded == ENCODE_FAIL)
12691       {
12692          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
12693                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12694          ret = RFAILED;
12695          break;
12696       }
12697       else
12698       {
12699          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Modification Response\n");
12700          for(int i=0; i< encBufSize; i++)
12701          {
12702             printf("%x",encBuf[i]);
12703          }
12704       }
12705
12706       /* Sending  msg  */
12707       if(sendF1APMsg() != ROK)
12708       {
12709          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Res Failed");
12710          ret = RFAILED;
12711          break;
12712       }
12713       break;
12714    }
12715    FreeUeContextModResp(f1apMsg);
12716    return ret;
12717 }
12718 /*******************************************************************
12719  *
12720  * @brief Deallocating the memory allocated by the aper decoder
12721  *          for QOSInfo
12722  *
12723  * @details
12724  *
12725  *    Function : freeAperDecodeQosInfo
12726  *
12727  *    Functionality:  Deallocating the memory allocated for QOSInfo
12728  *
12729  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
12730  *
12731  * @return void
12732  *
12733  * ****************************************************************/
12734
12735 void freeAperDecodeQosInfo(QoSFlowLevelQoSParameters_t *drbQos)
12736 {
12737    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
12738    {
12739       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
12740       {
12741          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
12742          {
12743             free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
12744          }
12745          free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
12746       }
12747       free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI);
12748    }
12749 }
12750 /*******************************************************************
12751  *
12752  * @brief Deallocating the memory allocated by the aper decoder
12753  *          for UlTnlInfoforDrb
12754  *
12755  * @details
12756  *
12757  *    Function : freeAperDecodeUlTnlInfoforDrbSetupMod
12758  *
12759  *    Functionality:  Deallocating memory allocated for UlTnlInfoforDrb
12760  *
12761  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
12762  *
12763  * @return void
12764  *
12765  * ****************************************************************/
12766 void freeAperDecodeUlTnlInfoforDrbSetupMod(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
12767 {
12768    uint8_t arrIdx =0;
12769
12770    if(ulInfo->list.array)
12771    {
12772       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
12773       {
12774          if(ulInfo->list.array[arrIdx])
12775          {
12776             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
12777             {
12778                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
12779                {
12780                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
12781                   {
12782                      free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12783                            gTP_TEID.buf);
12784                   }
12785                   free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12786                         transportLayerAddress.buf);
12787                }
12788                free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel);
12789             }
12790             free(ulInfo->list.array[arrIdx]);
12791          }
12792       }
12793       free(ulInfo->list.array);
12794    }
12795 }
12796 /*******************************************************************
12797  *
12798  * @brief Deallocating the memory allocated by the aper decoder
12799  *          for DrbSetupModItem
12800  *
12801  * @details
12802  *
12803  *    Function : freeAperDecodeDrbSetupModItem
12804  *
12805  *    Functionality:  Deallocating memory allocated for DrbSetupModItem
12806  *
12807  * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
12808  *
12809  * @return void
12810  *
12811  * ****************************************************************/
12812
12813 void freeAperDecodeDrbSetupModItem(DRBs_ToBeSetupMod_Item_t *drbItem)
12814 {
12815    uint8_t arrIdx =0;
12816    SNSSAI_t *snssai =NULLP;
12817    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
12818
12819    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
12820    switch(drbItem->qoSInformation.present)
12821    {
12822       case QoSInformation_PR_NOTHING:
12823          break;
12824       case QoSInformation_PR_eUTRANQoS:
12825          {
12826             if(drbItem->qoSInformation.choice.eUTRANQoS)
12827             {
12828                free(drbItem->qoSInformation.choice.eUTRANQoS);
12829             }
12830             break;
12831          }
12832       case QoSInformation_PR_choice_extension:
12833          {
12834             if(drbItem->qoSInformation.choice.choice_extension)
12835             {
12836                freeAperDecodeQosInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.\
12837                      DRB_Information.dRB_QoS);
12838                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
12839                if(snssai->sST.buf)
12840                {
12841                   free(snssai->sST.buf);
12842                }
12843                if(snssai->sD)
12844                {
12845                   if(snssai->sD->buf)
12846                   {
12847                      free(snssai->sD->buf);
12848                   }
12849                   free(snssai->sD);
12850                }
12851
12852                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.\
12853                          DRB_Information.flows_Mapped_To_DRB_List;
12854                if(flowMap->list.array)
12855                {
12856                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
12857                   {
12858                      if(flowMap->list.array[arrIdx] )
12859                      {
12860                         freeAperDecodeQosInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
12861                         free(flowMap->list.array[arrIdx]);
12862                      }
12863                   }
12864                   free(flowMap->list.array);
12865                }
12866
12867                free(drbItem->qoSInformation.choice.choice_extension);
12868             }
12869             break;
12870          }
12871
12872    }
12873    freeAperDecodeUlTnlInfoforDrbSetupMod(&drbItem->uLUPTNLInformation_ToBeSetup_List);
12874    if(drbItem->uLConfiguration)
12875    {
12876       free(drbItem->uLConfiguration);
12877    }
12878 }
12879
12880 /*******************************************************************
12881  *
12882  * @brief Deallocating the memory allocated by the aper decoder
12883  *          for DrbToBeSetupModList
12884  *
12885  * @details
12886  *
12887  *    Function : freeAperDecodeDrbToBeSetupModList
12888  *
12889  *    Functionality:  Deallocating memory allocated for DrbToBeSetupModList
12890  *
12891  * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
12892  *
12893  * @return void
12894  *
12895  * ****************************************************************/
12896
12897 void freeAperDecodeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
12898 {
12899    uint8_t arrIdx =0;
12900    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
12901
12902    if(drbSet->list.array)
12903    {
12904       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
12905       {
12906          if(drbSet->list.array[arrIdx] != NULLP)
12907          {
12908             if(arrIdx == 0)
12909             {
12910                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
12911                freeAperDecodeDrbSetupModItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
12912             }
12913             free(drbSet->list.array[arrIdx]);
12914          }
12915       }
12916       free(drbSet->list.array);
12917    }
12918
12919 }
12920 /*******************************************************************
12921  *
12922  * @brief Deallocating the memory allocated by the aper decoder
12923  *          for UeContextModificationReqMsg
12924  *
12925  * @details
12926  *
12927  *    Function : freeAperDecodeUeContextModificationReqMsg
12928  *
12929  *    Functionality:  Deallocating memory allocated for
12930  *                  UeContextModificationReqMsg
12931  *
12932  * @params[in] UEContextModificationRequest_t *UeContextModifyReq
12933  *
12934  * @return void
12935  *
12936  * ****************************************************************/
12937 void freeAperDecodeUeContextModificationReqMsg(UEContextModificationRequest_t *UeContextModifyReq )
12938 {
12939    uint8_t arrIdx, ieId;
12940
12941    if(UeContextModifyReq->protocolIEs.list.array)
12942    {
12943       for( arrIdx = 0 ; arrIdx<UeContextModifyReq->protocolIEs.list.count ; arrIdx++)
12944       {
12945          if(UeContextModifyReq->protocolIEs.list.array[arrIdx])
12946          {
12947             ieId = UeContextModifyReq->protocolIEs.list.array[arrIdx]->id;
12948             switch(ieId)
12949             {
12950                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12951                   break;
12952                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12953                   break;
12954                case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
12955                   {
12956                      freeAperDecodeDrbToBeSetupModList(&UeContextModifyReq->protocolIEs.list.array[arrIdx]->\
12957                            value.choice.DRBs_ToBeSetupMod_List);
12958                      break;
12959                   }
12960             }
12961             free(UeContextModifyReq->protocolIEs.list.array[arrIdx]);
12962          }
12963       }
12964       free(UeContextModifyReq->protocolIEs.list.array);
12965    }
12966 }
12967 /*******************************************************************
12968  *
12969  * @brief processing the F1 UeContextModificationReq
12970  *
12971  * @details
12972  *
12973  *    Function : procF1UeContextModificationReq
12974  *
12975  *    Functionality:  processing the F1 UeContextModificationReq
12976  *
12977  * @params[in] F1AP_PDU_t *f1apMsg
12978  *
12979  * @return
12980  * ****************************************************************/
12981 uint8_t procF1UeContextModificationReq(F1AP_PDU_t *f1apMsg)
12982 {
12983    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
12984    uint8_t  ret = ROK, ieIdx = 0, cellIdx=0, ueIdx=0;
12985    DuUeCb   *duUeCb = NULLP;
12986    DRBs_ToBeSetupMod_List_t *drbSetupModCfg;
12987    DRBs_ToBeModified_List_t *drbModifiedCfg;
12988    uint32_t gnbCuUeF1apId, gnbDuUeF1apId;
12989
12990    ueContextModifyReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
12991    for(ieIdx=0; (ieIdx < ueContextModifyReq->protocolIEs.list.count && ret == ROK); ieIdx++)
12992    {
12993       switch(ueContextModifyReq->protocolIEs.list.array[ieIdx]->id)
12994       {
12995          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12996             {
12997                gnbCuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
12998                break;
12999             }
13000          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13001             {
13002                gnbDuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
13003                break;
13004             }
13005          case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
13006          case ProtocolIE_ID_id_DRBs_ToBeModified_List:
13007             {
13008                for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
13009                {
13010                   for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
13011                   {
13012                      if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
13013                            (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
13014                      {
13015
13016                         duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
13017                         if(duUeCb->f1UeDb == NULLP)
13018                         {
13019                            DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
13020                         }
13021                         if(duUeCb->f1UeDb)
13022                         {
13023                            duUeCb->f1UeDb->actionType = UE_CTXT_MOD;
13024                            if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present ==\
13025                                  UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List)
13026                            {
13027                               drbSetupModCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
13028                               choice.DRBs_ToBeSetupMod_List;
13029
13030                               if(extractDrbListToSetupMod(NULL, drbSetupModCfg, NULL, drbSetupModCfg->list.count,\
13031                               &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, NULL))
13032                               {
13033                                  DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbSetupModList");
13034                                  ret = RFAILED;
13035                               }
13036                            }
13037
13038                            if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present == \
13039                                   UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List)
13040
13041                            {
13042                               drbModifiedCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
13043                               choice.DRBs_ToBeModified_List;
13044                               if(extractDrbListToSetupMod(NULL, NULL, drbModifiedCfg, drbSetupModCfg->list.count,\
13045                                  &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, &duUeCb->rlcUeCfg))
13046                               {
13047                                  DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbModifiedList");
13048                                  ret = RFAILED;
13049                               }
13050                            }
13051                         }
13052                         break;
13053                      }
13054                   }
13055                   if(ueIdx >= duCb.actvCellLst[cellIdx]->numActvUes)
13056                   {
13057                      DU_LOG("\nERROR  -->  DU APP : wrong values of gnbCuUeF1apId and gnbDuUeF1apId ");
13058                      ret = RFAILED;
13059                   }
13060                }
13061                break;
13062             }
13063       }
13064    }
13065    if(ret != RFAILED)
13066    {
13067       ret = duProcUeContextModReq(duUeCb);
13068    }
13069    freeAperDecodeUeContextModificationReqMsg(ueContextModifyReq);
13070    return ret;
13071 }
13072 /*****************************************************************i
13073 *
13074 * @brief Free memory allocated for UE Context Release Request
13075 *
13076 * @details
13077 *
13078 *    Function : FreeUeContextReleaseReq
13079 *
13080 *    Functionality:
13081 *         - Free memory allocated for UE Context Release Request
13082 *
13083 * @params[in] F1AP_PDU_t *f1apMsg
13084 * @return void
13085 *
13086 * *************************************************************/
13087 void FreeUeContextReleaseReq(F1AP_PDU_t *f1apMsg)
13088 {
13089    uint8_t ieIdx;
13090    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
13091
13092    if(f1apMsg)
13093    {
13094       if(f1apMsg->choice.initiatingMessage)
13095       {
13096          ueReleaseReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
13097          if(ueReleaseReq->protocolIEs.list.array)
13098          {
13099             for(ieIdx=0 ; ieIdx<ueReleaseReq->protocolIEs.list.count; ieIdx++)
13100             {
13101                DU_FREE(ueReleaseReq->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseRequest_t));
13102             }
13103             DU_FREE(ueReleaseReq->protocolIEs.list.array, ueReleaseReq->protocolIEs.list.size);
13104          }
13105          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
13106       }
13107       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
13108    }
13109
13110 }
13111 /*****************************************************************i
13112 *
13113 * @brief Build and Send UE Context Release Request
13114 *
13115 * @details
13116 *
13117 *    Function : BuildAndSendUeContextReleaseReq
13118 *
13119 *    Functionality:
13120 *         - Build and Send UE Context Release Request
13121 *
13122 * @params[in]
13123 * @return ROK     - success
13124 *         RFAILED - failure
13125 *
13126 * *************************************************************/
13127 uint8_t BuildAndSendUeContextReleaseReq(uint16_t cellId, uint8_t ueIdx)
13128 {
13129    bool memAllocFail = false;
13130    uint8_t ieIdx =0;
13131    uint8_t ret = RFAILED;
13132    uint16_t cellIdx =0;
13133    uint16_t crnti = 0;
13134    uint8_t  elementCnt = 0;
13135    uint32_t  gnbCuUeF1apId =0;   /* gNB-CU UE F1AP Id */
13136    uint32_t  gnbDuUeF1apId =0;   /* gNB-DU UE F1AP Id */
13137    asn_enc_rval_t encRetVal;
13138    F1AP_PDU_t *f1apMsg = NULLP;
13139    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
13140
13141    DU_LOG("\nINFO  --> Building the UE Context Release Request");
13142    do
13143    {
13144       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
13145       if(f1apMsg == NULLP)
13146       {
13147          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for f1apMsg");
13148          break;
13149       }
13150
13151       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
13152       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
13153       if(f1apMsg->choice.initiatingMessage == NULLP)
13154       {
13155          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for\
13156          initiatingMessage");
13157          break;
13158       }
13159       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextReleaseRequest;
13160       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
13161       f1apMsg->choice.initiatingMessage->value.present = \
13162       InitiatingMessage__value_PR_UEContextReleaseRequest;
13163
13164       ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
13165
13166       elementCnt = 2;
13167
13168       ueReleaseReq->protocolIEs.list.count = elementCnt;
13169       ueReleaseReq->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseRequest_t *);
13170
13171       /* Initialize the F1Setup members */
13172       DU_ALLOC(ueReleaseReq->protocolIEs.list.array,ueReleaseReq->protocolIEs.list.size);
13173       if(ueReleaseReq->protocolIEs.list.array == NULLP)
13174       {
13175          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE array");
13176          break;
13177       }
13178       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
13179       {
13180          DU_ALLOC(ueReleaseReq->protocolIEs.list.array[ieIdx],\
13181                sizeof(UEContextReleaseRequest_t));
13182          if(ueReleaseReq->protocolIEs.list.array[ieIdx] == NULLP)
13183          {
13184             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE elements");
13185             memAllocFail = true;
13186             break;
13187          }
13188       }
13189       if(memAllocFail == true)
13190          break;
13191
13192       /* Fetching Ue Cb Info*/
13193       GET_CELL_IDX(cellId, cellIdx);
13194       if(duCb.actvCellLst[cellIdx] == NULLP)
13195       {
13196          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): CellId[%d] does not exist", cellId);
13197          break;
13198       }
13199       else
13200       {
13201          GET_CRNTI(crnti, ueIdx);
13202          if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].crnti != crnti)
13203          {
13204             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): crnti[%d] does not exist", crnti);
13205             break;
13206          }
13207          gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
13208          gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
13209       }
13210
13211       ieIdx=0;
13212       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
13213       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13214       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present = \
13215       UEContextReleaseRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
13216       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
13217
13218       ieIdx++;
13219       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
13220       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13221       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present =\
13222       UEContextReleaseRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
13223       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
13224
13225       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13226
13227       /* Encode the F1SetupRequest type as APER */
13228       memset(encBuf, 0, ENC_BUF_MAX_LEN);
13229       encBufSize = 0;
13230       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
13231       /* Encode results */
13232       if(encRetVal.encoded == ENCODE_FAIL)
13233       {
13234          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseRequest structure (at %s)\n",\
13235                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13236          break;
13237       }
13238       else
13239       {
13240          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseRequest\n");
13241          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
13242          {
13243             printf("%x",encBuf[ieIdx]);
13244          }
13245       }
13246
13247       /* Sending msg */
13248       if(sendF1APMsg() != ROK)
13249       {
13250          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Request failed");
13251          break;
13252       }
13253       ret = ROK;
13254       break;
13255    }while(true);
13256
13257    FreeUeContextReleaseReq(f1apMsg);
13258    return ret;
13259 }
13260 /*****************************************************************i
13261  *
13262  * @brief Free memory allocated for UE Context Release Complete
13263  *
13264  * @details
13265  *
13266  *    Function : FreeUeContextReleaseComplete
13267  *
13268  *    Functionality:
13269  *         - Free memory allocated for UE Context Release Complete
13270  *
13271  * @params[in] F1AP_PDU_t *f1apMsg
13272  * @return void
13273  *
13274  * *************************************************************/
13275 void FreeUeContextReleaseComplete(F1AP_PDU_t *f1apMsg)
13276 {
13277    uint8_t ieIdx;
13278    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
13279
13280    if(f1apMsg)
13281    {
13282       if(f1apMsg->choice.successfulOutcome)
13283       {
13284          ueReleaseComplete =&f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
13285          if(ueReleaseComplete->protocolIEs.list.array)
13286          {
13287             for(ieIdx=0 ; ieIdx<ueReleaseComplete->protocolIEs.list.count; ieIdx++)
13288             {
13289                DU_FREE(ueReleaseComplete->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseComplete_t));
13290             }
13291             DU_FREE(ueReleaseComplete->protocolIEs.list.array, ueReleaseComplete->protocolIEs.list.size);
13292          }
13293          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
13294       }
13295       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
13296    }
13297
13298 }
13299 /*****************************************************************i
13300  *
13301  * @brief Build and Send UE Context Release Complete
13302  *
13303  * @details
13304  *
13305  *    Function : BuildAndSendUeContextReleaseComplete
13306  *
13307  *    Functionality:
13308  *         - Build and Send UE Context Release Complete
13309  *
13310  * @params[in]  cellId,  gnbCuUeF1apId, gnbDuUeF1apId
13311  * @return ROK     - success
13312  *         RFAILED - failure
13313  *
13314  * *************************************************************/
13315 uint8_t BuildAndSendUeContextReleaseComplete(uint16_t cellId, uint32_t gnbCuUeF1apId, uint32_t gnbDuUeF1apId)
13316 {
13317    bool memAllocFail = false;
13318    uint8_t ieIdx =0, ret = RFAILED, elementCnt = 0;
13319    asn_enc_rval_t encRetVal;
13320    F1AP_PDU_t *f1apMsg = NULLP;
13321    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
13322
13323    DU_LOG("\nINFO  --> Building the UE Context Release Complete");
13324    do
13325    {
13326       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
13327       if(f1apMsg == NULLP)
13328       {
13329          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for f1apMsg");
13330          break;
13331       }
13332
13333       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
13334       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
13335       if(f1apMsg->choice.successfulOutcome == NULLP)
13336       {
13337          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for\
13338                successfulOutcome");
13339          break;
13340       }
13341       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextRelease;
13342       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
13343       f1apMsg->choice.successfulOutcome->value.present = \
13344       SuccessfulOutcome__value_PR_UEContextReleaseComplete;
13345
13346       ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
13347
13348       elementCnt = 2;
13349       ueReleaseComplete->protocolIEs.list.count = elementCnt;
13350       ueReleaseComplete->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseComplete_t *);
13351
13352       /* Initialize the UE Release Complete members */
13353       DU_ALLOC(ueReleaseComplete->protocolIEs.list.array,ueReleaseComplete->protocolIEs.list.size);
13354       if(ueReleaseComplete->protocolIEs.list.array == NULLP)
13355       {
13356          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE array");
13357          break;
13358       }
13359       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
13360       {
13361          DU_ALLOC(ueReleaseComplete->protocolIEs.list.array[ieIdx],\
13362                sizeof(UEContextReleaseComplete_t));
13363          if(ueReleaseComplete->protocolIEs.list.array[ieIdx] == NULLP)
13364          {
13365             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE\
13366             elements");
13367             memAllocFail = true;
13368             break;
13369          }
13370       }
13371       if(memAllocFail == true)
13372          break;
13373
13374
13375       ieIdx=0;
13376       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
13377       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13378       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present = \
13379       UEContextReleaseCompleteIEs__value_PR_GNB_CU_UE_F1AP_ID;
13380       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
13381
13382       ieIdx++;
13383       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
13384       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13385       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present =\
13386       UEContextReleaseCompleteIEs__value_PR_GNB_DU_UE_F1AP_ID;
13387       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
13388
13389       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13390
13391       /* Encode the F1SetupComplete type as APER */
13392       memset(encBuf, 0, ENC_BUF_MAX_LEN);
13393       encBufSize = 0;
13394       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
13395       /* Encode results */
13396       if(encRetVal.encoded == ENCODE_FAIL)
13397       {
13398          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseComplete structure (at %s)\n",\
13399                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13400          break;
13401       }
13402       else
13403       {
13404          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseComplete\n");
13405          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
13406          {
13407             printf("%x",encBuf[ieIdx]);
13408          }
13409       }
13410
13411       /* Sending msg */
13412       if(sendF1APMsg() != ROK)
13413       {
13414          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Complete failed");
13415          break;
13416       }
13417       ret = ROK;
13418       break;
13419    }while(true);
13420
13421    if(ret == ROK)
13422    {
13423       duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
13424       ret = duSendCellDeletReq(cellId);
13425       if(ret != ROK)
13426       {
13427          DU_LOG("\nERROR  -->  F1AP: BuildAndSendUeContextReleaseComplete(): Failed to process cell\
13428                Delete req for CellId");
13429       }
13430    }
13431    FreeUeContextReleaseComplete(f1apMsg);
13432    return ret;
13433
13434 }
13435
13436 /*******************************************************************
13437 *
13438 * @brief added free part for the memory allocated by aper_decoder
13439 *
13440 * @details
13441 *
13442 *    Function : freeAperDecodeUeContextReleaseCommand
13443 *
13444 *    Functionality: added free part for the memory allocated by aper_decoder
13445 *
13446 * @params[in] F1AP_PDU_t *f1apMsg
13447 * @return void
13448 *
13449 * ****************************************************************/
13450 void freeAperDecodeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
13451 {
13452    uint8_t ieIdx=0;
13453    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
13454
13455    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
13456
13457    if(ueContextReleaseCommand->protocolIEs.list.array)
13458    {
13459       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
13460       {
13461          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
13462          {
13463             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
13464             {
13465                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13466                   break;
13467                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13468                   break;
13469                case ProtocolIE_ID_id_Cause:
13470                   break;
13471                case ProtocolIE_ID_id_RRCContainer:
13472                {
13473                   if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
13474                   {
13475                      free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
13476                   }
13477                   break;
13478                }
13479                default :
13480                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
13481                        ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
13482                   break;
13483             }
13484          }
13485          free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]);
13486       }
13487       free(ueContextReleaseCommand->protocolIEs.list.array);
13488    }
13489 }
13490 /*******************************************************************
13491 *
13492 * @brief processing of UE Context Release Command
13493 *
13494 * @details
13495 *
13496 *    Function : procF1UeContextReleaseCommand
13497 *
13498 *    Functionality: processing of UE Context Release Command
13499 *
13500 * @params[in] F1AP_PDU_t *f1apMsg
13501 * @return void
13502 *
13503 * ****************************************************************/
13504 uint8_t procF1UeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
13505 {
13506    uint8_t  ieIdx=0, ret=ROK, ueIdx=0;
13507    uint16_t cellIdx =0;
13508    bool ueIdxFound;
13509    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0;
13510    DuUeCb   *duUeCb = NULLP;
13511    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
13512
13513    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
13514
13515    if(ueContextReleaseCommand->protocolIEs.list.array)
13516    {
13517       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
13518       {
13519          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
13520          {
13521             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
13522             {
13523                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13524                   {
13525                      gnbCuUeF1apId= ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13526                                     value.choice.GNB_CU_UE_F1AP_ID;
13527                      break;
13528                   }
13529
13530                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13531                   {
13532                      gnbDuUeF1apId = ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13533                                      value.choice.GNB_DU_UE_F1AP_ID;
13534                      break;
13535                   }
13536
13537                case ProtocolIE_ID_id_Cause:
13538                   {
13539                      break;
13540                   }
13541
13542                case ProtocolIE_ID_id_RRCContainer:
13543                   {
13544                      for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
13545                      {
13546                         for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
13547                         {
13548                            if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
13549                                  (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
13550                            {
13551                               duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
13552                               DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
13553                               if(duUeCb->f1UeDb)
13554                               {
13555                                  memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
13556                                  duUeCb->f1UeDb->actionType = UE_CTXT_RELEASE;
13557                                  duUeCb->f1UeDb->cellIdx = cellIdx;
13558                                  /* Filling Dl RRC Msg Info */
13559                                  DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
13560                                  if(!duUeCb->f1UeDb->dlRrcMsg)
13561                                  {
13562                                     DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
13563                                     Memory allocation failed ");
13564                                     ret = RFAILED;
13565                                  }
13566                                  else
13567                                  {
13568                                     duUeCb->f1UeDb->dlRrcMsgPres = true;
13569                                     memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
13570                                     ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
13571                                           &ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13572                                           value.choice.RRCContainer);
13573                                  }
13574
13575                               }
13576                               else
13577                               {
13578                                  DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
13579                                  Memory allocation failed ");
13580                                  ret = RFAILED;
13581
13582                               }
13583
13584                               ueIdxFound = true;
13585                               break;
13586                            }
13587                         }
13588                         if(ueIdxFound == true)
13589                         {
13590                            break;
13591                         }
13592                      }
13593                      if(!ueIdxFound)
13594                      {
13595                         DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
13596                         ret = RFAILED;
13597                      }
13598
13599
13600                      break;
13601                   }
13602                default :
13603                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
13604                         ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
13605                   break;
13606             }
13607          }
13608       }
13609    }
13610    if(ret != RFAILED)
13611    {
13612       duProcUeContextReleaseCommand(duUeCb);
13613    }
13614    freeAperDecodeUeContextReleaseCommand(f1apMsg);
13615    return ret;
13616 }
13617 /**************************************************************
13618  *
13619  * @brief Handles received F1AP message and sends back response
13620  *
13621  * @details
13622  *
13623  *    Function : F1APMsgHdlr
13624  *
13625  *    Functionality:
13626  *         - Decodes received F1AP control message
13627  *         - Prepares response message, encodes and sends to SCTP
13628  *
13629  * @params[in]
13630  * @return ROK     - success
13631  *         RFAILED - failure
13632  *
13633  * ****************************************************************/
13634 void F1APMsgHdlr(Buffer *mBuf)
13635 {
13636    int i =0;
13637    char *recvBuf =NULLP;
13638    MsgLen copyCnt =0;
13639    MsgLen recvBufLen =0;
13640    F1AP_PDU_t *f1apMsg =NULLP;
13641    asn_dec_rval_t rval; /* Decoder return value */
13642    F1AP_PDU_t f1apasnmsg ;
13643    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
13644    ODU_PRINT_MSG(mBuf, 0,0);
13645
13646    /* Copy mBuf into char array to decode it */
13647    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
13648    DU_ALLOC(recvBuf, (Size)recvBufLen);
13649
13650    if(recvBuf == NULLP)
13651    {
13652       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
13653       return;
13654    }
13655    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
13656    {
13657       DU_LOG("\nERROR   -->  F1AP : Failed while copying %d", copyCnt);
13658       return;
13659    }
13660
13661    printf("\nDEBUG   -->  F1AP : Received flat buffer to be decoded : ");
13662    for(i=0; i< recvBufLen; i++)
13663    {
13664       printf("%x",recvBuf[i]);
13665    }
13666
13667    /* Decoding flat buffer into F1AP messsage */
13668    f1apMsg = &f1apasnmsg;
13669    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
13670
13671    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
13672    DU_FREE(recvBuf, (Size)recvBufLen);
13673
13674    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
13675    {
13676       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
13677       return;
13678    }
13679    printf("\n");
13680    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13681
13682    switch(f1apMsg->present)
13683    {
13684       case F1AP_PDU_PR_successfulOutcome:
13685          {
13686             switch(f1apMsg->choice.successfulOutcome->value.present)
13687             {
13688                case SuccessfulOutcome__value_PR_ResetAcknowledge:
13689                   {
13690                      DU_LOG("\nINFO   -->  F1AP : F1ResetAcknowledge is received successfully ");
13691                      break;
13692                   }
13693                case SuccessfulOutcome__value_PR_F1SetupResponse:
13694                   {
13695 #ifndef ODU_TEST_STUB
13696                      procF1SetupRsp(f1apMsg);
13697 #endif
13698                      break;
13699                   }
13700
13701                case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
13702                   {
13703                      procF1GNBDUCfgUpdAck(f1apMsg);
13704                      break;
13705                   }
13706
13707                default:
13708                   {
13709                      DU_LOG("\nERROR  -->  F1AP : Invalid type of SuccessfulOutcome__value_PR_ResetAcknowledge [%d]",\
13710                            f1apMsg->choice.successfulOutcome->value.present);
13711                      return;
13712                   }
13713             }/* End of switch(successfulOutcome) */
13714             free(f1apMsg->choice.successfulOutcome);
13715             break;
13716          }
13717       case F1AP_PDU_PR_initiatingMessage:
13718          {
13719             switch(f1apMsg->choice.initiatingMessage->value.present)
13720             {
13721                case InitiatingMessage__value_PR_Reset:
13722                   {
13723                      procF1ResetReq(f1apMsg);
13724                      break;
13725                   }
13726                case InitiatingMessage__value_PR_DLRRCMessageTransfer:
13727                   {
13728                      procF1DlRrcMsgTrans(f1apMsg);
13729                      break;
13730                   }
13731                case InitiatingMessage__value_PR_UEContextSetupRequest:
13732                   {
13733                      procF1UeContextSetupReq(f1apMsg);
13734                      break;
13735                   }
13736                case InitiatingMessage__value_PR_UEContextModificationRequest:
13737                   {
13738                      procF1UeContextModificationReq(f1apMsg);
13739                      break;
13740                   }
13741                case InitiatingMessage__value_PR_UEContextReleaseCommand:
13742                   {
13743                       procF1UeContextReleaseCommand(f1apMsg);
13744                       break;
13745                   }
13746                default:
13747                   {
13748                      DU_LOG("\nERROR  -->  F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
13749                            f1apMsg->choice.initiatingMessage->value.present);
13750                      return;
13751                   }
13752             }/* End of switch(initiatingMessage) */
13753             free(f1apMsg->choice.initiatingMessage);
13754             break;
13755          }
13756
13757       default:
13758          {
13759             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
13760             return;
13761          }
13762          free(f1apMsg);
13763
13764    }/* End of switch(f1apMsg->present) */
13765
13766 } /* End of F1APMsgHdlr */
13767
13768 /**********************************************************************
13769   End of file
13770  **********************************************************************/