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 = NUM_OF_SUPPORTED_SLICE;
 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, sizeof(SliceSupportItem_t*));
1486                         }
1487                         DU_FREE(servedPlmnItem->iE_Extensions->list.array[0],\
1488                         sizeof(ServedPLMNs_ItemExtIEs_t));
1489                      }
1490                      DU_FREE(servedPlmnItem->iE_Extensions->list.array,\
1491                      extensionCnt*sizeof(ServedPLMNs_ItemExtIEs_t*));
1492                   }
1493                   DU_FREE(servedPlmnItem->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P3_t));
1494                }
1495                DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx],\
1496                sizeof(ServedPLMNs_Item_t));
1497             }
1498             DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array,\
1499             sizeof(ServedPLMNs_Item_t *));
1500          }
1501
1502          if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD != NULLP)
1503          {
1504             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
1505                   freqBandListNr.list.array != NULLP)
1506             {
1507                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
1508                uL_NRFreqInfo.freqBandListNr.list.array[0],sizeof(FreqBandNrItem_t));
1509                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
1510                uL_NRFreqInfo.freqBandListNr.list.array,sizeof(FreqBandNrItem_t*));
1511             }
1512
1513             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1514                   freqBandListNr.list.array)
1515             {
1516                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1517                      freqBandListNr.list.array[0],sizeof(FreqBandNrItem_t));
1518                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1519                      freqBandListNr.list.array,sizeof(FreqBandNrItem_t *));
1520             }
1521             DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD, sizeof(FDD_Info_t));
1522          }
1523
1524          DU_FREE(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1525                srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1526
1527          if(srvCellItem->gNB_DU_System_Information != NULLP)
1528          {
1529             if(srvCellItem->gNB_DU_System_Information->mIB_message.buf != NULLP)
1530             {
1531                DU_FREE(srvCellItem->gNB_DU_System_Information->mIB_message.buf,\
1532                      srvCellItem->gNB_DU_System_Information->mIB_message.size);
1533             }
1534
1535             if(srvCellItem->gNB_DU_System_Information->sIB1_message.buf != NULLP)
1536             {
1537                DU_FREE(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,\
1538                      srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1539             }
1540
1541             DU_FREE(srvCellItem->gNB_DU_System_Information, sizeof(GNB_DU_System_Information_t));
1542          }
1543
1544          DU_FREE(duServedCell->list.array[0], sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1545       }
1546       DU_FREE(duServedCell->list.array, plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t*));
1547    }
1548 }
1549
1550 /*******************************************************************
1551  *
1552  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1553  *
1554  * @details
1555  *
1556  *    Function :  FreeF1SetupReq
1557  *
1558  *    Functionality:  deallocating the memory of function BuildAndSendF1SetupReq
1559  *
1560  * @params[in] F1AP_PDU_t *f1apMsg
1561  *
1562  * @return void
1563  *
1564  * ****************************************************************/
1565 void FreeF1SetupReq(F1AP_PDU_t *f1apMsg)
1566 {
1567    uint8_t ieIdx, ieIdx2;
1568    F1SetupRequest_t *f1SetupReq=NULLP;
1569
1570    if(f1apMsg != NULLP)
1571    {
1572       if(f1apMsg->choice.initiatingMessage != NULLP)
1573       {
1574          f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1575          if(f1SetupReq->protocolIEs.list.array != NULLP)
1576          {
1577             for(ieIdx = 0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
1578             {
1579                if(f1SetupReq->protocolIEs.list.array[ieIdx] != NULLP)
1580                {
1581                   switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
1582                   {
1583                      case ProtocolIE_ID_id_TransactionID:
1584                         break;
1585                      case ProtocolIE_ID_id_gNB_DU_ID:
1586                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1587                               f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1588                         break;
1589                      case ProtocolIE_ID_id_gNB_DU_Name:
1590                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,\
1591                               strlen((char *)duCfgParam.duName));
1592                         break;
1593                      case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
1594                         FreeServedCellList(&f1SetupReq->protocolIEs.list.\
1595                               array[ieIdx]->value.choice.GNB_DU_Served_Cells_List);
1596                         break;
1597                      case ProtocolIE_ID_id_GNB_DU_RRC_Version:
1598                         FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version);
1599                         break;
1600                      default:
1601                         DU_LOG("\nERROR  -->  Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id);
1602                         break;
1603                   }
1604                }
1605             }
1606             for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++)
1607             {
1608                DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx2],sizeof(F1SetupRequestIEs_t));
1609             }
1610             DU_FREE(f1SetupReq->protocolIEs.list.array,\
1611                   f1SetupReq->protocolIEs.list.size);
1612          }
1613          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1614       }
1615       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1616    }
1617 }
1618 /*******************************************************************
1619  *
1620  * @brief Builds and Send the F1SetupRequest
1621  *
1622  * @details
1623  *
1624  *    Function : BuildAndSendF1SetupReq
1625  *
1626  * Functionality:Fills the F1SetupRequest
1627  *
1628  * @return ROK     - success
1629  *         RFAILED - failure
1630  *
1631  ******************************************************************/
1632 uint8_t BuildAndSendF1SetupReq()
1633 {
1634    uint8_t   ret, ieIdx, elementCnt;
1635    F1AP_PDU_t                 *f1apMsg = NULLP;
1636    F1SetupRequest_t           *f1SetupReq=NULLP;
1637    GNB_DU_Served_Cells_List_t *duServedCell=NULLP;
1638    RRC_Version_t              *rrcVer=NULLP;
1639    asn_enc_rval_t             encRetVal;        /* Encoder return value */
1640    ret= RFAILED;
1641
1642    DU_LOG("\nINFO   -->  F1AP : Building F1 Setup Request\n");
1643    do
1644    {
1645       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1646       if(f1apMsg == NULLP)
1647       {
1648          break;
1649       }
1650       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1651       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1652       if(f1apMsg->choice.initiatingMessage == NULLP)
1653       {
1654          break;
1655       }
1656       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_F1Setup;
1657       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
1658       f1apMsg->choice.initiatingMessage->value.present = \
1659                                                          InitiatingMessage__value_PR_F1SetupRequest;
1660
1661       f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1662
1663       elementCnt = (duCfgParam.duName != NULL) ? 5 : 4;
1664
1665       f1SetupReq->protocolIEs.list.count = elementCnt;
1666       f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t );
1667
1668       /* Initialize the F1Setup members */
1669       DU_ALLOC(f1SetupReq->protocolIEs.list.array,f1SetupReq->protocolIEs.list.size);
1670       if(f1SetupReq->protocolIEs.list.array == NULLP)
1671       {
1672          break;
1673       }
1674       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
1675       {
1676          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx],\
1677                sizeof(F1SetupRequestIEs_t));
1678          if(f1SetupReq->protocolIEs.list.array[ieIdx] == NULLP)
1679          {
1680             break;
1681          }
1682       }
1683
1684       ieIdx = 0;
1685       /*TransactionID*/
1686       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransactionID;
1687       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1688       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present =\
1689                                                                F1SetupRequestIEs__value_PR_TransactionID;
1690       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = \
1691                                                                              TRANS_ID;
1692
1693       /*DU ID*/
1694       ieIdx++;
1695       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
1696       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1697       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1698                                                                 F1SetupRequestIEs__value_PR_GNB_DU_ID;
1699       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size =\
1700                                                                              sizeof(uint8_t);
1701
1702       DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1703             f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1704       if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == \
1705             NULLP)
1706       {
1707          break;
1708       }
1709
1710       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] =\
1711          duCfgParam.duId;
1712
1713       /*DU Name*/
1714       if(duCfgParam.duName != NULL)
1715       {
1716          ieIdx++;
1717          f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_Name;
1718          f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
1719          f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = F1SetupRequestIEs__value_PR_GNB_DU_Name;
1720          f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.size =\
1721             strlen((char *)duCfgParam.duName);
1722          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.\
1723                GNB_DU_Name.buf, strlen((char *)duCfgParam.duName));
1724          if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.\
1725                buf == NULLP)
1726          {
1727             break;
1728          }
1729          strcpy((char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.\
1730                choice.GNB_DU_Name.buf,
1731                (char*)&duCfgParam.duName);
1732
1733       }
1734
1735       /*Served Cell list */
1736       ieIdx++;
1737       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1738                                                      ProtocolIE_ID_id_gNB_DU_Served_Cells_List;
1739       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1740       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1741                                                                 F1SetupRequestIEs__value_PR_GNB_DU_Served_Cells_List;
1742       duServedCell = &f1SetupReq->protocolIEs.list.\
1743                      array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
1744       if(BuildServedCellList(duServedCell))
1745       {
1746          break;
1747       }
1748       /*RRC Version*/
1749       ieIdx++;
1750       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1751                                                      ProtocolIE_ID_id_GNB_DU_RRC_Version ;
1752       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1753       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1754                                                                 F1SetupRequestIEs__value_PR_RRC_Version;
1755       rrcVer = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
1756       if(BuildRrcVer(rrcVer))
1757       {
1758          break;
1759       }
1760       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1761
1762       /* Encode the F1SetupRequest type as APER */
1763       memset(encBuf, 0, ENC_BUF_MAX_LEN);
1764       encBufSize = 0;
1765       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1766             encBuf);
1767
1768       /* Encode results */
1769       if(encRetVal.encoded == ENCODE_FAIL)
1770       {
1771          DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupRequest structure (at %s)\n",\
1772                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1773          break;
1774       }
1775       else
1776       {
1777          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1SetupRequest\n");
1778          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
1779          {
1780             printf("%x",encBuf[ieIdx]);
1781          }
1782       }
1783
1784       /* Sending msg */
1785       if(sendF1APMsg() != ROK)
1786       {
1787          DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup request failed");
1788          break;
1789       }
1790
1791       ret=ROK;
1792       break;
1793    }while(true);
1794
1795    FreeF1SetupReq(f1apMsg);
1796
1797    return ret;
1798 }/* End of BuildAndSendF1SetupReq */
1799
1800 /*******************************************************************
1801  *
1802  * @brief Deallocating memory allocated for Served_Cells_To_Modify_Item_t
1803  *
1804  * @details
1805  *
1806  *    Function : freeCellsToModifyItem
1807  *
1808  *    Functionality: Deallocating memory of variables allocated in
1809  *                    BuildAndSendDUConfigUpdate function
1810  *
1811  * @params[in]  Served_Cells_To_Modify_Item_t *modifyItem
1812  *
1813  * @return ROK     - void
1814  *
1815  * ****************************************************************/
1816
1817 void freeCellsToModifyItem(Served_Cells_To_Modify_Item_t *modifyItem)
1818 {
1819    uint8_t arrIdx=0, servedPlmnIdx=0, sliceLstIdx=0;
1820    ServedPLMNs_Item_t *servedPlmnItem = NULLP;
1821    SliceSupportItem_t *sliceSupportItem = NULLP;
1822
1823    DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf, modifyItem->oldNRCGI.pLMN_Identity.size);
1824    DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf, modifyItem->oldNRCGI.nRCellIdentity.size);
1825
1826    DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1827            modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
1828    DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1829          modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
1830
1831    if(modifyItem->served_Cell_Information.servedPLMNs.list.array != NULLP)
1832    {
1833       if(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx] != NULLP)
1834       {
1835          servedPlmnItem = modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx];
1836
1837          DU_FREE(servedPlmnItem->pLMN_Identity.buf,servedPlmnItem->pLMN_Identity.size);
1838
1839          if(servedPlmnItem->iE_Extensions != NULLP)
1840          {
1841             if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1842             {
1843                if(servedPlmnItem->iE_Extensions->list.array[arrIdx] != NULLP)
1844                {
1845                   if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1846                         list.array != NULLP)
1847                   {
1848                      for(sliceLstIdx =0; sliceLstIdx<servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
1849                            extensionValue.choice.SliceSupportList.list.count; sliceLstIdx++)
1850                      {
1851                         if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1852                               list.array[sliceLstIdx] != NULLP)
1853                         {
1854
1855                            sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1856                                               SliceSupportList.list.array[sliceLstIdx];
1857
1858                            DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sliceSupportItem->sNSSAI.sST.size);
1859                            if(sliceSupportItem->sNSSAI.sD != NULLP)
1860                            {
1861                               DU_FREE(sliceSupportItem->sNSSAI.sD->buf, sliceSupportItem->sNSSAI.sD->size);
1862                               DU_FREE(sliceSupportItem->sNSSAI.sD,sizeof(OCTET_STRING_t));
1863                            }
1864                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1865                                  SliceSupportList.list.array[sliceLstIdx], sizeof(SliceSupportItem_t));
1866                         }
1867                      }
1868                      DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.\
1869                            choice.SliceSupportList.list.array,\
1870                            servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
1871                            extensionValue.choice.SliceSupportList.list.size);
1872                   }
1873                }
1874                for(servedPlmnIdx=0; servedPlmnIdx< servedPlmnItem->iE_Extensions->list.count ; servedPlmnIdx++)
1875                {
1876                   DU_FREE(servedPlmnItem->iE_Extensions->list.array[servedPlmnIdx], sizeof(ServedPLMNs_ItemExtIEs_t ));
1877                }
1878                DU_FREE(servedPlmnItem->iE_Extensions->list.array, servedPlmnItem->iE_Extensions->list.size);
1879             }
1880             DU_FREE(servedPlmnItem->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1881          }
1882       }
1883       for(servedPlmnIdx=0; servedPlmnIdx<modifyItem->served_Cell_Information.servedPLMNs.list.count; servedPlmnIdx++)
1884       {
1885          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[servedPlmnIdx], sizeof(ServedPLMNs_Item_t));
1886       }
1887       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1888          modifyItem->served_Cell_Information.servedPLMNs.list.size);
1889    }
1890
1891    if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD != NULLP)
1892    {
1893       if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1894       {
1895          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
1896                array[arrIdx], sizeof(FreqBandNrItem_t));
1897          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array, \
1898                modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1899       }
1900
1901       if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1902       {
1903          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.\
1904              array[arrIdx], sizeof(FreqBandNrItem_t));
1905          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,\
1906                modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1907       }
1908       DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD,sizeof(FDD_Info_t));
1909    }
1910
1911    DU_FREE(modifyItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1912       modifyItem->served_Cell_Information.measurementTimingConfiguration.size);
1913 }
1914
1915 /*******************************************************************
1916  *
1917  * @brief Deallocating memory of BuildAndSendDUConfigUpdate
1918  *
1919  * @details
1920  *
1921  *    Function : FreeDUConfigUpdate
1922  *
1923  *    Functionality: Deallocating memory of variables allocated in
1924  *                    BuildAndSendDUConfigUpdate function
1925  *
1926  * @params[in]  F1AP_PDU_t *f1apDuCfg
1927  *
1928  * @return ROK     - void
1929  *
1930  * ****************************************************************/
1931 void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg)
1932 {
1933    uint8_t  ieIdx=0, cellModifyIdx=0, cellDeleteIdx=0;
1934    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
1935    Served_Cells_To_Modify_List_t  *cellsToModify=NULLP;
1936    Served_Cells_To_Delete_List_t  *cellsToDelete=NULLP;
1937    Served_Cells_To_Delete_Item_t  *deleteItem = NULLP;
1938    Served_Cells_To_Delete_ItemIEs_t *deleteItemIe = NULLP;
1939
1940    if(f1apDuCfg != NULLP)
1941    {
1942       if(f1apDuCfg->choice.initiatingMessage != NULLP)
1943       {
1944          duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->\
1945                        value.choice.GNBDUConfigurationUpdate;
1946          if(duCfgUpdate->protocolIEs.list.array != NULLP)
1947          {
1948             for(ieIdx=0; ieIdx<duCfgUpdate->protocolIEs.list.count; ieIdx++)
1949             {
1950                if(duCfgUpdate->protocolIEs.list.array[ieIdx] != NULLP)
1951                {
1952                   switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
1953                   {
1954                      case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
1955                         {
1956                            cellsToModify = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1957                                            value.choice.Served_Cells_To_Modify_List;
1958                            if(cellsToModify->list.array != NULLP)
1959                            {
1960                               for(cellModifyIdx=0; cellModifyIdx<cellsToModify->list.count ;cellModifyIdx++)
1961                               {
1962                                  if(cellsToModify->list.array[cellModifyIdx] != NULLP)
1963                                  {
1964                                     freeCellsToModifyItem(&cellsToModify->list.array[cellModifyIdx]->value.choice.\
1965                                           Served_Cells_To_Modify_Item);
1966                                     DU_FREE(cellsToModify->list.array[cellModifyIdx],\
1967                                           sizeof(Served_Cells_To_Modify_ItemIEs_t));
1968                                  }
1969                               }
1970                               DU_FREE(cellsToModify->list.array,cellsToModify->list.size);
1971                            }
1972                            break;
1973                         }
1974                      case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
1975                         {
1976                            cellsToDelete = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1977                                            value.choice.Served_Cells_To_Delete_List;
1978                            if(cellsToDelete->list.array != NULLP)
1979                            {
1980                               for(cellDeleteIdx=0; cellDeleteIdx<cellsToDelete->list.count ;cellDeleteIdx++)
1981                               {
1982                                  if(cellsToDelete->list.array[cellDeleteIdx] != NULLP)
1983                                  {
1984                                     deleteItemIe = ((Served_Cells_To_Delete_ItemIEs_t*)\
1985                                           cellsToDelete->list.array[cellDeleteIdx]);
1986                                     deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
1987                                     DU_FREE(deleteItem->oldNRCGI.pLMN_Identity.buf,\
1988                                           deleteItem->oldNRCGI.pLMN_Identity.size);
1989                                     DU_FREE(deleteItem->oldNRCGI.nRCellIdentity.buf,\
1990                                           deleteItem->oldNRCGI.nRCellIdentity.size);
1991                                     DU_FREE(cellsToDelete->list.array[cellDeleteIdx],\
1992                                           sizeof(Served_Cells_To_Delete_ItemIEs_t));
1993                                  }
1994                               }
1995                               DU_FREE(cellsToDelete->list.array,cellsToDelete->list.size);
1996                            }
1997
1998                            break;
1999                         }
2000                      case ProtocolIE_ID_id_gNB_DU_ID:
2001                         {
2002                            DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2003                                  duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2004                            break;
2005                         }
2006                   }
2007                   DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx],\
2008                         sizeof(GNBDUConfigurationUpdateIEs_t));
2009                }
2010             }
2011             DU_FREE(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2012          }
2013          DU_FREE(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2014       }
2015       DU_FREE(f1apDuCfg, (Size)sizeof(F1AP_PDU_t));
2016    }
2017 }
2018
2019 /*******************************************************************
2020  *
2021  * @brief Fills Served Plmns required in ServCellInfo IE
2022  *
2023  * @details
2024  *
2025  *    Function : fillServedPlmns
2026  *
2027  *    Functionality: Fills Served Plmns required in ServCellInfo IE
2028  *
2029  * @params[in] Pointer to ServedPLMNs_List_t *
2030  *
2031  * @return ROK     - success
2032  *         RFAILED - failure
2033  *
2034  *****************************************************************/
2035
2036 uint8_t fillServedPlmns(ServedPLMNs_List_t *servedPlmn)
2037 {
2038    uint8_t ieIdx=0, arrayIdx=0, ieListCnt=0, elementCnt=0, sliceLstIdx=0;
2039
2040    servedPlmn->list.array[arrayIdx]->pLMN_Identity.size = 3*sizeof(uint8_t);
2041    DU_ALLOC(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf, servedPlmn->list.\
2042          array[arrayIdx]->pLMN_Identity.size);
2043    if(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf == NULLP)
2044    {
2045       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2046       return RFAILED;
2047    }
2048    buildPlmnId(duCfgParam.srvdCellLst[arrayIdx].duCellInfo.cellInfo.srvdPlmn[arrayIdx].plmn,\
2049          servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf);
2050    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
2051    if(servedPlmn->list.array[arrayIdx]->iE_Extensions == NULLP)
2052    {
2053       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2054       return RFAILED;
2055    }
2056
2057    ieListCnt=1;
2058    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.count = ieListCnt;
2059    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.size = ieListCnt *sizeof(ServedPLMNs_ItemExtIEs_t *);
2060    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array,servedPlmn->list.array[arrayIdx]->\
2061          iE_Extensions->list.size);
2062    if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array == NULLP)
2063    {
2064       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2065       return RFAILED;
2066    }
2067    for(ieIdx=arrayIdx;ieIdx<ieListCnt;ieIdx++)
2068    {
2069       DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx],\
2070             sizeof(ServedPLMNs_ItemExtIEs_t));
2071       if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx] == NULLP)
2072       {
2073          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2074          return RFAILED;
2075       }
2076    }
2077
2078    ieIdx = 0;
2079    elementCnt = NUM_OF_SUPPORTED_SLICE;
2080    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->id =ProtocolIE_ID_id_TAISliceSupportList;
2081    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->criticality = Criticality_ignore;
2082    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.present = \
2083    ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
2084    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2085       list.count = elementCnt;
2086    servedPlmn->list.array[arrayIdx]->\
2087       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2088       list.size = elementCnt * sizeof(SliceSupportItem_t *);
2089    DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2090          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2091          list.array,servedPlmn->list.array[arrayIdx]->\
2092          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.size);
2093    if(servedPlmn->list.array[arrayIdx]->\
2094          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2095          list.array == NULLP)
2096    {
2097       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2098       return RFAILED;
2099    }
2100
2101    for(sliceLstIdx =0; sliceLstIdx< elementCnt; sliceLstIdx++)
2102    {
2103       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2104       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2105       list.array[sliceLstIdx],sizeof( SliceSupportItem_t));
2106       if(servedPlmn->list.array[arrayIdx]->\
2107       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2108       list.array[sliceLstIdx] == NULLP)
2109       {
2110          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2111          return RFAILED;
2112       }
2113
2114       servedPlmn->list.array[arrayIdx]->\
2115       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2116       list.array[sliceLstIdx]->sNSSAI.sST.size = sizeof(uint8_t);
2117       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2118       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2119       list.array[sliceLstIdx]->sNSSAI.sST.buf,servedPlmn->list.array[arrayIdx]->\
2120       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->\
2121       sNSSAI.sST.size);
2122
2123       if(servedPlmn->list.array[arrayIdx]->\
2124       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2125       list.array[sliceLstIdx]->sNSSAI.sST.buf == NULLP)
2126       {
2127          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2128          return RFAILED;
2129       }
2130       servedPlmn->list.array[arrayIdx]->\
2131       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2132       list.array[sliceLstIdx]->sNSSAI.sST.buf[arrayIdx] =  duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
2133       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
2134
2135       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2136       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2137       list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
2138       if(servedPlmn->list.array[arrayIdx]->\
2139       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2140       list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
2141       {
2142          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2143          return RFAILED;
2144       }
2145       servedPlmn->list.array[arrayIdx]->\
2146       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2147       list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
2148       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2149       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2150       list.array[sliceLstIdx]->sNSSAI.sD->buf,servedPlmn->list.array[arrayIdx]->\
2151       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2152       list.array[sliceLstIdx]->sNSSAI.sD->size);
2153       if(servedPlmn->list.array[arrayIdx]->\
2154       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2155       list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
2156       {
2157          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2158          return RFAILED;
2159       }
2160       memcpy(servedPlmn->list.array[arrayIdx]->\
2161       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2162       list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
2163       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sd,\
2164       servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2165       list.array[sliceLstIdx]->sNSSAI.sD->size);
2166    }
2167    return ROK;
2168 }
2169
2170 /*******************************************************************
2171  *
2172  * @brief Fills Nr Fdd Info required in ServCellInfo IE
2173  *
2174  * @details
2175  *
2176  *    Function : fillNrFddInfo
2177  *
2178  *    Functionality: Fills Nr Fdd Info required in ServCellInfo IE
2179  *
2180  * @params[in] Pointer to NR_Mode_Info_t *
2181  *
2182  * @return ROK     - success
2183  *         RFAILED - failure
2184  *
2185  *****************************************************************/
2186
2187 uint8_t fillNrFddInfo(NR_Mode_Info_t *nrFdd)
2188 {
2189    nrFdd->choice.fDD->uL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.\
2190       f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn;
2191    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.count = 1;
2192    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t*);
2193    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
2194          array, nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size);
2195    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2196    {
2197       return RFAILED;
2198    }
2199    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0], \
2200       sizeof(FreqBandNrItem_t));
2201    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2202    {
2203       return RFAILED;
2204    }
2205    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2206       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
2207       freqBand[0].nrFreqBand;
2208    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2209    nrFdd->choice.fDD->dL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.\
2210       dlNrFreqInfo.nrArfcn;
2211    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.count = 1;
2212    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
2213    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,nrFdd->\
2214          choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
2215    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2216    {
2217       return RFAILED;
2218    }
2219    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0],\
2220          sizeof(FreqBandNrItem_t));
2221    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2222    {
2223       return RFAILED;
2224    }
2225    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2226       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
2227       freqBand[0].nrFreqBand;
2228    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2229
2230    /*Transmission Bandwidth*/
2231    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2232       f1Mode.mode.fdd.ulTxBw.nrScs;
2233    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2234       f1Mode.mode.fdd.ulTxBw.nrb;
2235    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2236       f1Mode.mode.fdd.dlTxBw.nrScs;
2237    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2238       f1Mode.mode.fdd.dlTxBw.nrb;
2239
2240    return ROK;
2241 }
2242
2243 /*******************************************************************
2244  *
2245  * @brief Fills ServCellInfo IE
2246  *
2247  * @details
2248  *
2249  *    Function : fillServedCellInfo
2250  *
2251  *    Functionality: Fills ServCellInfo
2252  *
2253  * @params[in] Pointer to Served_Cell_Information_t *
2254  *
2255  * @return ROK     - success
2256  *         RFAILED - failure
2257  *
2258  *****************************************************************/
2259
2260 uint8_t fillServedCellInfo(Served_Cell_Information_t *srvCellInfo)
2261 {
2262    uint8_t tmp, ieIdx, ieListCnt;
2263
2264    /*nRCGI*/
2265    srvCellInfo->nRCGI.pLMN_Identity.size =3*sizeof(uint8_t);
2266    DU_ALLOC(srvCellInfo->nRCGI.pLMN_Identity.buf,\
2267          srvCellInfo->nRCGI.pLMN_Identity.size);
2268    if(srvCellInfo->nRCGI.pLMN_Identity.buf == NULLP)
2269    {
2270       return RFAILED;
2271    }
2272    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2273          srvCellInfo->nRCGI.pLMN_Identity.buf);
2274    srvCellInfo->nRCGI.nRCellIdentity.size =5*sizeof(uint8_t);
2275    DU_ALLOC(srvCellInfo->nRCGI.nRCellIdentity.buf,\
2276          srvCellInfo->nRCGI.nRCellIdentity.size);
2277    if(srvCellInfo->nRCGI.nRCellIdentity.buf == NULLP)
2278    {
2279       return RFAILED;
2280    }
2281    for (tmp = 0 ; tmp < srvCellInfo->\
2282          nRCGI.nRCellIdentity.size-1 ; tmp++)
2283    {
2284       srvCellInfo->nRCGI.nRCellIdentity.buf[tmp] = 0;
2285    }
2286    srvCellInfo->nRCGI.nRCellIdentity.buf[4] = 16;
2287    srvCellInfo->nRCGI.nRCellIdentity.bits_unused =4;
2288
2289    /*nRPCI*/
2290    srvCellInfo->nRPCI = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
2291
2292    /*servedPLMNs*/
2293    ieListCnt = 1;
2294    srvCellInfo->servedPLMNs.list.count = ieListCnt;
2295    srvCellInfo->servedPLMNs.list.size = ieListCnt*sizeof(ServedPLMNs_Item_t *);
2296    DU_ALLOC(srvCellInfo->servedPLMNs.list.array,\
2297          srvCellInfo->servedPLMNs.list.size);
2298    if(srvCellInfo->servedPLMNs.list.array == NULLP)
2299    {
2300       return RFAILED;
2301    }
2302    for(ieIdx=0; ieIdx < ieListCnt; ieIdx++)
2303    {
2304       DU_ALLOC(srvCellInfo->servedPLMNs.list.array[ieIdx],\
2305             sizeof(ServedPLMNs_Item_t));
2306       if(srvCellInfo->servedPLMNs.list.array[ieIdx]== NULLP)
2307       {
2308          return RFAILED;
2309       }
2310    }
2311    if(fillServedPlmns(&srvCellInfo->servedPLMNs))
2312    {
2313       return RFAILED;
2314    }
2315
2316    /*nR Mode Info with FDD*/
2317    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_fDD;
2318    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.fDD,\
2319          sizeof(FDD_Info_t));
2320    if(srvCellInfo->nR_Mode_Info.choice.fDD == NULLP)
2321    {
2322       return RFAILED;
2323    }
2324    if(fillNrFddInfo(&srvCellInfo->nR_Mode_Info))
2325       return RFAILED;
2326
2327    /*Measurement timing Config*/
2328    srvCellInfo->measurementTimingConfiguration.size = sizeof(uint8_t);
2329    DU_ALLOC(srvCellInfo->measurementTimingConfiguration.\
2330          buf,srvCellInfo->measurementTimingConfiguration.size);
2331    if(srvCellInfo->measurementTimingConfiguration.buf == NULLP)
2332    {
2333       return RFAILED;
2334    }
2335    srvCellInfo->measurementTimingConfiguration.\
2336          buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
2337
2338    return ROK;
2339 }
2340
2341 /*******************************************************************
2342  *
2343  * @brief Fills ServCellToModItem IE
2344  *
2345  * @details
2346  *
2347  *    Function : fillServCellToModItem
2348  *
2349  *    Functionality: Fills ServCellToModItem IE
2350  *
2351  * @params[in] Pointer to Served_Cells_To_Modify_Item_t *
2352  *
2353  * @return ROK     - success
2354  *         RFAILED - failure
2355  *
2356  *****************************************************************/
2357
2358 uint8_t fillServCellToModItem(Served_Cells_To_Modify_Item_t *modifyItem)
2359 {
2360    uint8_t ieIdx;
2361
2362    /*pLMN_Identity*/
2363    modifyItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2364    DU_ALLOC(modifyItem->oldNRCGI.pLMN_Identity.buf,modifyItem->oldNRCGI.pLMN_Identity.size);
2365    if(modifyItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2366    {
2367       return RFAILED;
2368    }
2369    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2370          modifyItem->oldNRCGI.pLMN_Identity.buf);
2371
2372    /*nRCellIdentity*/
2373    modifyItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2374    DU_ALLOC(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2375          modifyItem->oldNRCGI.nRCellIdentity.size);
2376    if(modifyItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2377    {
2378       return RFAILED;
2379    }
2380    for(ieIdx = 0; ieIdx < modifyItem->oldNRCGI.nRCellIdentity.size-1; ieIdx++)
2381    {
2382       modifyItem->oldNRCGI.nRCellIdentity.buf[ieIdx] = 0;
2383    }
2384    modifyItem->oldNRCGI.nRCellIdentity.buf[4] = 16;
2385    modifyItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
2386
2387    if(fillServedCellInfo(&modifyItem->served_Cell_Information))
2388       return RFAILED;
2389    else
2390       return ROK;
2391 }
2392
2393 /*******************************************************************
2394  *
2395  * @brief Builds ServCellToModList
2396  *
2397  * @details
2398  *
2399  *    Function : buildServCellToModList
2400  *
2401  *    Functionality: Builds the serv cell to Mod List
2402  *
2403  * @params[in] Pointer to Served_Cells_To_Modify_List_t *
2404  *
2405  * @return ROK     - success
2406  *         RFAILED - failure
2407  *
2408  *****************************************************************/
2409
2410 uint8_t buildServCellToModList(Served_Cells_To_Modify_List_t *cellsToModify)
2411 {
2412    uint8_t ieListCnt, ieIdx;
2413    Served_Cells_To_Modify_Item_t *modifyItem = NULLP;
2414
2415    ieListCnt = 1;
2416    cellsToModify->list.count = ieListCnt;
2417    cellsToModify->list.size = ieListCnt*sizeof(Served_Cells_To_Modify_ItemIEs_t *);
2418    DU_ALLOC(cellsToModify->list.array,cellsToModify->list.size);
2419    if(cellsToModify->list.array == NULLP)
2420    {
2421       return RFAILED;
2422    }
2423    for(ieIdx=0; ieIdx< ieListCnt; ieIdx++)
2424    {
2425       DU_ALLOC(cellsToModify->list.array[ieIdx],sizeof(Served_Cells_To_Modify_ItemIEs_t));
2426       if(cellsToModify->list.array[ieIdx] == NULLP)
2427       {
2428          return RFAILED;
2429       }
2430    }
2431    cellsToModify->list.array[0]->id = ProtocolIE_ID_id_Served_Cells_To_Modify_Item;
2432    cellsToModify->list.array[0]->criticality = Criticality_reject;
2433    cellsToModify->list.array[0]->value.present =\
2434       Served_Cells_To_Modify_ItemIEs__value_PR_Served_Cells_To_Modify_Item;
2435    modifyItem=&cellsToModify->list.array[0]->value.choice.Served_Cells_To_Modify_Item;
2436
2437    if(fillServCellToModItem(modifyItem))
2438       return RFAILED;
2439    else
2440       return ROK;
2441 }
2442 /*******************************************************************
2443  *
2444  * @brief filling the DeleteItemList
2445  *
2446  * @details
2447  *
2448  *    Function : fillCellToDeleteItem
2449  *
2450  *    Functionality: Filling the DeleteItemIe
2451  *
2452  * @params[in] Pointer to Served_Cells_To_Delete_ItemIEs_t
2453  *
2454  * @return ROK     - success
2455  *         RFAILED - failure
2456  *
2457  *****************************************************************/
2458 uint8_t fillCellToDeleteItem(struct Served_Cells_To_Delete_ItemIEs *deleteItemIe)
2459 {
2460    uint8_t arrIdx;
2461    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
2462
2463    deleteItemIe->id = ProtocolIE_ID_id_Served_Cells_To_Delete_Item;
2464    deleteItemIe->criticality = Criticality_reject;
2465    deleteItemIe->value.present =\
2466    Served_Cells_To_Delete_ItemIEs__value_PR_Served_Cells_To_Delete_Item;
2467    deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
2468
2469    /*pLMN_Identity*/
2470    deleteItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2471    DU_ALLOC(deleteItem->oldNRCGI.pLMN_Identity.buf,deleteItem->oldNRCGI.pLMN_Identity.size);
2472    if(deleteItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2473    {
2474       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2475       return RFAILED;
2476    }
2477    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2478          deleteItem->oldNRCGI.pLMN_Identity.buf);
2479
2480    /*nRCellIdentity*/
2481    deleteItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2482    DU_ALLOC(deleteItem->oldNRCGI.nRCellIdentity.buf,\
2483          deleteItem->oldNRCGI.nRCellIdentity.size);
2484    if(deleteItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2485    {
2486       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2487       return RFAILED;
2488    }
2489    for(arrIdx = 0; arrIdx < deleteItem->oldNRCGI.nRCellIdentity.size-1; arrIdx++)
2490    {
2491       deleteItem->oldNRCGI.nRCellIdentity.buf[arrIdx] = 0;
2492    }
2493    deleteItem->oldNRCGI.nRCellIdentity.buf[4] = 16;
2494    deleteItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
2495    return ROK;
2496 }
2497 /*******************************************************************
2498  *
2499  * @brief Builds ServCellToDeleteList
2500  *
2501  * @details
2502  *
2503  *    Function : buildServCellToDeleteList
2504  *
2505  *    Functionality: Builds the serv cell to delete List
2506  *
2507  * @params[in] Pointer to Served_Cells_To_Delete_List_t *
2508  *
2509  * @return ROK     - success
2510  *         RFAILED - failure
2511  *
2512  *****************************************************************/
2513
2514 uint8_t buildServCellToDeleteList(Served_Cells_To_Delete_List_t *cellsToDelete)
2515 {
2516    uint8_t ieListCnt, arrIdx;
2517
2518    ieListCnt = 1;
2519    cellsToDelete->list.count = ieListCnt;
2520    cellsToDelete->list.size = ieListCnt*sizeof(Served_Cells_To_Delete_ItemIEs_t *);
2521
2522    DU_ALLOC(cellsToDelete->list.array,cellsToDelete->list.size);
2523    if(cellsToDelete->list.array == NULLP)
2524    {
2525       DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2526       return RFAILED;
2527    }
2528
2529    for(arrIdx=0; arrIdx< ieListCnt; arrIdx++)
2530    {
2531       DU_ALLOC(cellsToDelete->list.array[arrIdx],sizeof(Served_Cells_To_Delete_ItemIEs_t));
2532       if(cellsToDelete->list.array[arrIdx] == NULLP)
2533       {
2534          DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2535          return RFAILED;
2536       }
2537    }
2538
2539    arrIdx=0;
2540    if(fillCellToDeleteItem((Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx]) !=ROK)
2541    {
2542       DU_LOG("\nERROR  -->  F1AP: buildServCellToDeleteList(): failed to fill Served_Cells_To_Delete_ItemIEs");
2543       return RFAILED;
2544    }
2545    return ROK;
2546 }
2547
2548 /*******************************************************************
2549  *
2550  * @brief Builds and sends the DUConfigUpdate
2551  *
2552  * @details
2553  *
2554  *    Function : BuildAndSendDUConfigUpdate
2555  *
2556  *    Functionality: Constructs the DU Update message and sends
2557  *                   it to the CU through SCTP.
2558  *
2559  * @params[in] void **buf,Buffer to which encoded pattern is written into
2560  * @params[in] int *size,size of buffer
2561  *
2562  * @return ROK     - success
2563  *         RFAILED - failure
2564  *
2565  * ****************************************************************/
2566 uint8_t BuildAndSendDUConfigUpdate(ServCellAction servCellAction)
2567 {
2568    uint8_t ret =0, ieIdx=0, elementCnt=0;
2569    bool memAlloctionFailure = false;
2570    F1AP_PDU_t                 *f1apDuCfg = NULLP;
2571    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
2572    asn_enc_rval_t encRetVal;     /* Encoder return value */
2573
2574    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2575    ret= RFAILED;
2576
2577    while(true)
2578    {
2579       DU_LOG("\nINFO   -->  F1AP : Building DU config update\n");
2580       /* Allocate the memory for F1DuCfg */
2581       DU_ALLOC(f1apDuCfg, sizeof(F1AP_PDU_t));
2582       if(f1apDuCfg == NULLP)
2583       {
2584          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2585          break;
2586       }
2587
2588       f1apDuCfg->present = F1AP_PDU_PR_initiatingMessage;
2589       DU_ALLOC(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2590       if(f1apDuCfg->choice.initiatingMessage == NULLP)
2591       {
2592          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2593          break;
2594       }
2595
2596       f1apDuCfg->choice.initiatingMessage->procedureCode = \
2597                                                            ProcedureCode_id_gNBDUConfigurationUpdate;
2598       f1apDuCfg->choice.initiatingMessage->criticality = Criticality_reject;
2599       f1apDuCfg->choice.initiatingMessage->value.present = \
2600                                                            InitiatingMessage__value_PR_GNBDUConfigurationUpdate;
2601       duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\
2602                     choice.GNBDUConfigurationUpdate;
2603       elementCnt = 3;
2604       duCfgUpdate->protocolIEs.list.count = elementCnt;
2605       duCfgUpdate->protocolIEs.list.size = \
2606                                            elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t*);
2607
2608       /* Initialize the F1Setup members */
2609       DU_ALLOC(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2610       if(duCfgUpdate->protocolIEs.list.array == NULLP)
2611       {
2612          DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2613          break;
2614       }
2615       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
2616       {
2617          DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx],sizeof(GNBDUConfigurationUpdateIEs_t));
2618          if(duCfgUpdate->protocolIEs.list.array[ieIdx] == NULLP)
2619          {
2620             DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2621             memAlloctionFailure = true;
2622             break;
2623          }
2624       }
2625
2626       if(memAlloctionFailure == true)
2627       {
2628          break;
2629       }
2630       /*TransactionID*/
2631       ieIdx = 0;
2632       duCfgUpdate->protocolIEs.list.array[ieIdx]->id=ProtocolIE_ID_id_TransactionID;
2633       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
2634       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2635       GNBDUConfigurationUpdateIEs__value_PR_TransactionID;
2636       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = TRANS_ID;
2637
2638       ieIdx++;
2639       if(servCellAction == SERV_CELL_TO_MODIFY)
2640       {
2641          /*Served Cell to Modify */
2642          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2643          ProtocolIE_ID_id_Served_Cells_To_Modify_List;
2644          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2645          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2646          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Modify_List;
2647          if(buildServCellToModList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2648                   Served_Cells_To_Modify_List))
2649          {
2650             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToModList");
2651             break;
2652          }
2653       }
2654       else
2655       {
2656          /*Served Cell to Delete */
2657          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2658          ProtocolIE_ID_id_Served_Cells_To_Delete_List;
2659          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2660          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2661          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Delete_List;
2662          if(buildServCellToDeleteList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2663          Served_Cells_To_Delete_List)!=ROK)
2664          {
2665             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToDeleteList");
2666             break;
2667          }
2668
2669       }
2670       // NOTE :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
2671       /*GNB DU ID */
2672       ieIdx++;
2673       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
2674       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
2675       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2676       GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID;
2677       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size = sizeof(uint8_t);
2678       DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2679             duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2680       if(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == NULLP)
2681       {
2682          DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): Memory allocation failed for GNB_DU_ID");
2683          break;
2684       }
2685       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] = duCfgParam.duId;
2686
2687       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
2688
2689       /* Encode the DU Config Update type as APER */
2690       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
2691       encBufSize = 0;
2692       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
2693
2694       /* Checking encode results */
2695       if(encRetVal.encoded == ENCODE_FAIL)
2696       {
2697          DU_LOG("ERROR  -->  F1AP : Could not encode DUConfigUpdate structure (at %s)\n",\
2698                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2699          break;
2700       }
2701       else
2702       {
2703          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DUConfigUpdate\n");
2704          for(ieIdx =0; ieIdx < encBufSize; ieIdx++)
2705          {
2706             printf("%x",encBuf[ieIdx]);
2707          }
2708       }
2709       /* Sending msg */
2710       if(sendF1APMsg() != ROK)
2711       {
2712          DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update failed");
2713          break;
2714       }
2715
2716       ret = ROK;
2717       break;
2718    }
2719
2720    addToReservedF1apPduList(TRANS_ID,f1apDuCfg);
2721    return ret;
2722 }
2723
2724
2725 /*******************************************************************
2726  *
2727  * @brief free the ULRRCMessageTransfer
2728  *
2729  * @details
2730  *
2731  *    Function : FreeULRRCMessageTransfer
2732  *
2733  *    Functionality: Deallocating the memory of variable allocated in
2734  *                      FreeULRRCMessageTransfer
2735  *
2736  * @params[in]
2737  *
2738  * @return ROK     - void
2739  *
2740  ******************************************************************/
2741 void FreeULRRCMessageTransfer( F1AP_PDU_t *f1apMsg)
2742 {
2743    uint8_t idx1;
2744    ULRRCMessageTransfer_t  *ulRRCMsg;
2745
2746    if(f1apMsg != NULLP)
2747    {
2748       if(f1apMsg->choice.initiatingMessage != NULLP)
2749       {
2750          ulRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2751          if(ulRRCMsg->protocolIEs.list.array != NULLP)
2752          {
2753             for(idx1=0;idx1<ulRRCMsg->protocolIEs.list.count;idx1++)
2754             {
2755                if(ulRRCMsg->protocolIEs.list.array[idx1] != NULLP)
2756                {
2757                   if(ulRRCMsg->protocolIEs.list.array[idx1]->value.present ==
2758                         ULRRCMessageTransferIEs__value_PR_RRCContainer)
2759                   {
2760                      DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2761                            ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2762                   }
2763                   DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1],sizeof(ULRRCMessageTransferIEs_t));
2764                }
2765             }
2766             DU_FREE(ulRRCMsg->protocolIEs.list.array,ulRRCMsg->protocolIEs.list.size );
2767          }
2768          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2769       }
2770       DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
2771    }
2772 }
2773 /*******************************************************************
2774  *
2775  * @brief Builds and sends the ULRRCMessageTransfer
2776  *
2777  * @details
2778  *
2779  *    Function : BuildAndSendULRRCMessageTransfer
2780  *
2781  *    Functionality: Constructs the UL RRC Message Transfer and sends
2782  *                   it to the CU through SCTP.
2783  *
2784  * @params[in]
2785  *
2786  * @return ROK     - success
2787  *         RFAILED - failure
2788  *
2789  * ****************************************************************/
2790 uint8_t BuildAndSendULRRCMessageTransfer(DuUeCb  ueCb, uint8_t lcId, \
2791       uint16_t msgLen, uint8_t *rrcMsg)
2792 {
2793    uint8_t   elementCnt =0;
2794    uint8_t   idx1 =0;
2795    uint8_t   idx =0;
2796    F1AP_PDU_t                   *f1apMsg = NULLP;
2797    ULRRCMessageTransfer_t       *ulRRCMsg = NULLP;
2798    asn_enc_rval_t               encRetVal;        /* Encoder return value */
2799    uint8_t ret =RFAILED;
2800
2801    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2802
2803    while(true)
2804    {
2805       DU_LOG("\n INFO   -->  F1AP : Building UL RRC Message Transfer Message\n");
2806
2807       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
2808       if(f1apMsg == NULLP)
2809       {
2810          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2811          break;
2812       }
2813       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
2814       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2815       if(f1apMsg->choice.initiatingMessage == NULLP)
2816       {
2817          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
2818          break;
2819       }
2820       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_ULRRCMessageTransfer;
2821       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
2822       f1apMsg->choice.initiatingMessage->value.present = \
2823                                                          InitiatingMessage__value_PR_ULRRCMessageTransfer;
2824       ulRRCMsg =
2825          &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2826       elementCnt = 4;
2827       ulRRCMsg->protocolIEs.list.count = elementCnt;
2828       ulRRCMsg->protocolIEs.list.size = \
2829                                         elementCnt * sizeof(ULRRCMessageTransferIEs_t *);
2830
2831       /* Initialize the F1Setup members */
2832       DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size);
2833       if(ulRRCMsg->protocolIEs.list.array == NULLP)
2834       {
2835          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
2836          break;
2837       }
2838       for(idx=0; idx<elementCnt; idx++)
2839       {
2840          DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t));
2841          if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP)
2842          {
2843             break;
2844          }
2845       }
2846
2847       idx1 = 0;
2848
2849       /*GNB CU UE F1AP ID*/
2850       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
2851       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2852       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2853                                                               ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
2854       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = ueCb.gnbCuUeF1apId;
2855
2856       /*GNB DU UE F1AP ID*/
2857       idx1++;
2858       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
2859       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2860       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2861                                                               ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
2862       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = ueCb.gnbDuUeF1apId;
2863
2864       /*SRBID*/
2865       idx1++;
2866       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
2867       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2868       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2869                                                               ULRRCMessageTransferIEs__value_PR_SRBID;
2870       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = lcId;
2871
2872       /*RRCContainer*/
2873       idx1++;
2874       ulRRCMsg->protocolIEs.list.array[idx1]->id  = ProtocolIE_ID_id_RRCContainer;
2875       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2876       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2877                                                               ULRRCMessageTransferIEs__value_PR_RRCContainer;
2878       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size = msgLen;
2879       DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2880             ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
2881       if(!ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
2882       {
2883          DU_LOG(" ERROR  -->  F1AP : Memory allocation for BuildAndSendULRRCMessageTransfer failed");
2884          break;
2885       }
2886       memset(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, 0, msgLen);
2887       memcpy(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, \
2888             rrcMsg, ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2889
2890       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2891
2892       /* Encode the F1SetupRequest type as APER */
2893       memset(encBuf, 0, ENC_BUF_MAX_LEN);
2894       encBufSize = 0;
2895       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
2896             encBuf);
2897       /* Encode results */
2898       if(encRetVal.encoded == ENCODE_FAIL)
2899       {
2900          DU_LOG( "\nERROR  -->  F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
2901                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2902          break;
2903       }
2904       else
2905       {
2906          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
2907          for(int i=0; i< encBufSize; i++)
2908          {
2909             printf("%x",encBuf[i]);
2910          }
2911       }
2912
2913       /* Sending  msg  */
2914       if(sendF1APMsg()  !=      ROK)
2915       {
2916          DU_LOG("\nERROR  -->   F1AP : Sending  UL RRC Message Transfer Failed");
2917          break;
2918       }
2919       ret = ROK;
2920       break;
2921    }
2922    FreeULRRCMessageTransfer(f1apMsg);
2923
2924    return ret;
2925 }/* End of BuildAndSendULRRCMessageTransfer*/
2926
2927 /*******************************************************************
2928  *
2929  * @brief Builds tag config
2930  *
2931  * @details
2932  *
2933  *    Function : BuildTagConfig
2934  *
2935  *    Functionality: Builds tag config in MacCellGroupConfig
2936  *
2937  * @params[in] TAG_Config *tag_Config
2938  *
2939  * @return ROK     - success
2940  *         RFAILED - failure
2941  *
2942  * ****************************************************************/
2943 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
2944 {
2945    struct TAG_Config__tag_ToAddModList *tagList;
2946    uint8_t                     idx, elementCnt;
2947
2948    tagConfig->tag_ToReleaseList = NULLP;
2949    tagConfig->tag_ToAddModList = NULLP;
2950    DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
2951    if(!tagConfig->tag_ToAddModList)
2952    {
2953       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2954       return RFAILED;
2955    }
2956
2957    elementCnt = 1; //ODU_VALUE_ONE;
2958    tagList = tagConfig->tag_ToAddModList;
2959    tagList->list.count = elementCnt;
2960    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
2961
2962    tagList->list.array = NULLP;
2963    DU_ALLOC(tagList->list.array, tagList->list.size);
2964    if(!tagList->list.array)
2965    {
2966       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2967       return RFAILED;
2968    }
2969
2970    for(idx=0; idx<tagList->list.count; idx++)
2971    {
2972       tagList->list.array[idx] = NULLP;
2973       DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
2974       if(!tagList->list.array[idx])
2975       {
2976          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2977          return RFAILED;
2978       }
2979    }
2980
2981    idx = 0;
2982    tagList->list.array[idx]->tag_Id = TAG_ID;
2983    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
2984
2985    return ROK;
2986 }
2987
2988 /*******************************************************************
2989  *
2990  * @brief Builds PHR Config
2991  *
2992  * @details
2993  *
2994  *    Function : BuildPhrConfig
2995  *
2996  *    Functionality: Builds phrConfig in MacCellGroupConfig
2997  *
2998  * @params[in] PHR Config *
2999  *
3000  * @return ROK     - success
3001  *         RFAILED - failure
3002  *
3003  * ****************************************************************/
3004 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
3005 {
3006
3007    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
3008    phrConfig->choice.setup = NULLP;
3009    DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
3010    if(!phrConfig->choice.setup)
3011    {
3012       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
3013       return RFAILED;
3014    }
3015
3016    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
3017    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
3018    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
3019    phrConfig->choice.setup->multiplePHR              = false;
3020    phrConfig->choice.setup->dummy                    = false;
3021    phrConfig->choice.setup->phr_Type2OtherCell       = false;
3022    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
3023
3024    return ROK;
3025 }
3026
3027 /*******************************************************************
3028  *
3029  * @brief Builds BSR Config
3030  *
3031  * @details
3032  *
3033  *    Function : BuildBsrConfig
3034  *
3035  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
3036  *
3037  * @params[in] BSR_Config *bsrConfig
3038  *
3039  * @return ROK     - success
3040  *         RFAILED - failure
3041  *
3042  * ****************************************************************/
3043 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
3044 {
3045    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
3046    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
3047    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
3048
3049    return ROK;
3050 }
3051
3052 /*******************************************************************
3053  *
3054  * @brief Builds scheduling request config
3055  *
3056  * @details
3057  *
3058  *    Function : BuildSchedulingReqConfig
3059  *
3060  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
3061  *
3062  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
3063  *
3064  * @return ROK     - success
3065  *         RFAILED - failure
3066  *
3067  * ****************************************************************/
3068 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
3069 {
3070    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
3071    uint8_t                     idx, elementCnt;
3072
3073    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
3074    DU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
3075          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
3076    if(!schedulingRequestConfig->schedulingRequestToAddModList)
3077    {
3078       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3079       return RFAILED;
3080    }
3081
3082    elementCnt = 1; //ODU_VALUE_ONE;
3083    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
3084    schReqList->list.count = elementCnt;
3085    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
3086
3087    schReqList->list.array = NULLP;
3088    DU_ALLOC(schReqList->list.array, schReqList->list.size);
3089    if(!schReqList->list.array)
3090    {
3091       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3092       return RFAILED;
3093    }
3094
3095    for(idx=0;idx<schReqList->list.count; idx++)
3096    {
3097       schReqList->list.array[idx] = NULLP;
3098       DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
3099       if(!schReqList->list.array[idx])
3100       {
3101          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3102          return RFAILED;
3103       }
3104    }
3105
3106    idx = 0;
3107    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
3108
3109    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
3110    DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
3111    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
3112    {
3113       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3114       return RFAILED;
3115    }
3116    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
3117    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
3118    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
3119
3120    return ROK;
3121 }
3122
3123 /*******************************************************************
3124  *
3125  * @brief Builds RLC Config
3126  *
3127  * @details
3128  *
3129  *    Function : BuildRlcConfig
3130  *
3131  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
3132  *
3133  * @params[in] RLC_Config *rlcConfig
3134  *
3135  * @return ROK     - success
3136  *         RFAILED - failure
3137  *
3138  * ****************************************************************/
3139 uint8_t BuildRlcConfig(struct RLC_Config *rlcConfig)
3140 {
3141
3142    rlcConfig->present = RLC_Config_PR_am;
3143
3144    rlcConfig->choice.am = NULLP;
3145    DU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
3146    if(!rlcConfig->choice.am)
3147    {
3148       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3149       return RFAILED;
3150    }
3151
3152    /* UL */
3153    rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
3154    DU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3155    if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
3156    {
3157       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3158       return RFAILED;
3159    }
3160    *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3161    rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
3162    rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
3163    rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
3164    rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
3165
3166    /* DL */
3167    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
3168    DU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3169    if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
3170    {
3171       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3172       return RFAILED;
3173    }
3174    *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3175    rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
3176    rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
3177
3178    return ROK;
3179 }
3180
3181 /*******************************************************************
3182  *
3183  * @brief Builds MAC LC Config
3184  *
3185  * @details
3186  *
3187  *    Function : BuildMacLCConfig
3188  *
3189  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
3190  *
3191  * @params[in] struct LogicalChannelConfig macLcConfig
3192  *
3193  * @return ROK     - success
3194  *         RFAILED - failure
3195  *
3196  * ****************************************************************/
3197 uint8_t BuildMacLCConfig(struct LogicalChannelConfig *macLcConfig)
3198 {
3199
3200    macLcConfig->ul_SpecificParameters = NULLP;
3201    DU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
3202    if(!macLcConfig->ul_SpecificParameters)
3203    {
3204       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3205       return RFAILED;
3206    }
3207
3208    macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
3209    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     PRIORTISIED_BIT_RATE;
3210    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     BUCKET_SIZE_DURATION;
3211    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
3212    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
3213    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
3214    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
3215
3216    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
3217    DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
3218    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
3219    {
3220       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3221       return RFAILED;
3222    }
3223    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
3224
3225    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
3226    DU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
3227    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
3228    {
3229       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3230       return RFAILED;
3231    }
3232    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
3233
3234    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
3235    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
3236    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
3237
3238    return ROK;
3239 }
3240
3241 /*******************************************************************
3242  *
3243  * @brief Builds RLC Bearer to Add/Mod list
3244  *
3245  * @details
3246  *
3247  *    Function :BuildRlcBearerToAddModList
3248  *
3249  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
3250  *
3251  * @params[in] rlc_BearerToAddModList
3252  *
3253  * @return ROK     - success
3254  *         RFAILED - failure
3255  *
3256  * ****************************************************************/
3257 uint8_t BuildRlcBearerToAddModList(struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
3258 {
3259    uint8_t                     idx, elementCnt;
3260
3261    elementCnt = 1;
3262    rlcBearerList->list.count = elementCnt;
3263    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
3264
3265    rlcBearerList->list.array = NULLP;
3266    DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
3267    if(!rlcBearerList->list.array)
3268    {
3269       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3270       return RFAILED;
3271    }
3272
3273    for(idx=0; idx<rlcBearerList->list.count; idx++)
3274    {
3275       rlcBearerList->list.array[idx] = NULLP;
3276       DU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
3277       if(!rlcBearerList->list.array[idx])
3278       {
3279          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3280          return RFAILED;
3281       }
3282    }
3283
3284    idx = 0;
3285    rlcBearerList->list.array[idx]->logicalChannelIdentity = SRB1_LCID;
3286
3287    DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, \
3288       sizeof(struct RLC_BearerConfig__servedRadioBearer));
3289    if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3290    {
3291       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3292       return RFAILED;
3293    }
3294
3295    rlcBearerList->list.array[idx]->servedRadioBearer->present = \
3296       RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
3297    rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = \
3298       SRB1_LCID;
3299
3300    rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3301    rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3302    DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3303    if(!rlcBearerList->list.array[idx]->rlc_Config)
3304    {
3305       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3306       return RFAILED;
3307    }
3308
3309    if(BuildRlcConfig(rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3310    {
3311       DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3312       return RFAILED;
3313    }
3314
3315    rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3316    DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, \
3317       sizeof(struct LogicalChannelConfig));
3318    if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3319    {
3320       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3321       return RFAILED;
3322    }
3323
3324    if(BuildMacLCConfig(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3325    {
3326       DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3327       return RFAILED;
3328    }
3329
3330    return ROK;
3331 }
3332
3333 /*******************************************************************
3334  *
3335  * @brief Build Control resource set to add/modify list
3336  *
3337  * @details
3338  *
3339  *    Function : BuildControlRSetToAddModList
3340  *
3341  *    Functionality: Build Control resource set to add/modify list
3342  *
3343  * @params[in]
3344  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3345  *
3346  * @return ROK     - success
3347  *         RFAILED - failure
3348  *
3349  * ****************************************************************/
3350    uint8_t BuildControlRSetToAddModList
3351 (
3352  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3353  )
3354 {
3355    uint8_t idx;
3356    uint8_t elementCnt;
3357    uint8_t numBytes, bitsUnused;
3358    struct ControlResourceSet *controlRSet;
3359    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3360    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3361
3362
3363    elementCnt = 1;
3364    controlRSetList->list.count = elementCnt;
3365    controlRSetList->list.size = \
3366                                 elementCnt * sizeof(struct ControlResourceSet *);
3367
3368    controlRSetList->list.array = NULLP;
3369    DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3370    if(!controlRSetList->list.array)
3371    {
3372       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3373       return RFAILED;
3374    }
3375
3376    for(idx = 0; idx < elementCnt; idx++)
3377    {
3378       controlRSetList->list.array[idx] = NULLP;
3379       DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3380       if(!controlRSetList->list.array[idx])
3381       {
3382          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3383          return RFAILED;
3384       }
3385    }
3386
3387    idx=0;
3388    controlRSet = controlRSetList->list.array[idx];
3389
3390    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3391
3392    /* size 6 bytes
3393     * 3 LSBs unsued
3394     * Bit string stored ff0000000000
3395     */
3396    numBytes = 6;
3397    bitsUnused = 3;
3398    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3399
3400    controlRSet->frequencyDomainResources.buf = NULLP;
3401    DU_ALLOC(controlRSet->frequencyDomainResources.buf, \
3402          controlRSet->frequencyDomainResources.size);
3403    if(!controlRSet->frequencyDomainResources.buf)
3404    {
3405       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3406       return RFAILED;
3407    }
3408
3409    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3410    coreset0EndPrb = CORESET0_END_PRB;
3411    coreset1StartPrb = coreset0EndPrb + 6;
3412    coreset1NumPrb = CORESET1_NUM_PRB;
3413    /* calculate the PRBs */
3414    freqDomRscAllocType0(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3415    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3416    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3417
3418    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3419    controlRSet->cce_REG_MappingType.present = \
3420                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3421
3422    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3423    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3424    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3425    controlRSet->tci_PresentInDCI = NULLP;
3426 #if 0
3427    uint8_t tciStateIdx;
3428
3429    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3430          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3431    if(!controlRset->tci_StatesPDCCH_ToAddList)
3432    {
3433       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3434       return RFAILED;
3435    }
3436
3437    elementCnt = 1;
3438    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3439    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3440    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3441          controlRset->tci_StatesPDCCH_ToAddList->list.size)
3442       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3443       {
3444          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3445          return RFAILED;
3446       }
3447
3448    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3449    {
3450       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3451       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3452       {
3453          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3454          return RFAILED;
3455       }
3456    }
3457
3458    tciStateIdx = 0;
3459    /* TODO */
3460    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3461
3462    DU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3463    if(!controlRset->tci_PresentInDCI)
3464    {
3465       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3466       return RFAILED;
3467    }
3468    /* TODO */
3469    *(controlRset->tci_PresentInDCI);
3470 #endif
3471
3472    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3473    DU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3474    if(!controlRSet->pdcch_DMRS_ScramblingID)
3475    {
3476       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3477       return RFAILED;
3478    }
3479    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3480
3481    return ROK;
3482 } /* End BuildControlRSetToAddModList */
3483
3484 /*******************************************************************
3485  *
3486  * @brief Build search space to add/modify list
3487  *
3488  * @details
3489  *
3490  *    Function : BuildSearchSpcToAddModList
3491  *
3492  *    Functionality: Build search space to add/modify list
3493  *
3494  * @params[in]
3495  * @return ROK     - success
3496  *         RFAILED - failure
3497  *
3498  * ****************************************************************/
3499    uint8_t BuildSearchSpcToAddModList
3500 (
3501  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
3502  )
3503 {
3504    uint8_t idx;
3505    uint8_t numBytes;
3506    uint8_t byteIdx;
3507    uint8_t bitsUnused;
3508    uint8_t elementCnt;
3509    struct SearchSpace *searchSpc;
3510
3511    elementCnt = 1;
3512    searchSpcList->list.count = elementCnt;
3513    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3514
3515    searchSpcList->list.array = NULLP;
3516    DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3517    if(!searchSpcList->list.array)
3518    {
3519       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3520       return RFAILED;
3521    }
3522
3523    for(idx = 0; idx < elementCnt; idx++)
3524    {
3525       searchSpcList->list.array[idx] = NULLP;
3526       DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3527       if(!searchSpcList->list.array[idx])
3528       {
3529          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3530          return RFAILED;
3531       }
3532    }
3533
3534    idx = 0;
3535    searchSpc = searchSpcList->list.array[idx];
3536
3537    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3538
3539    searchSpc->controlResourceSetId = NULLP;
3540    DU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3541    if(!searchSpc->controlResourceSetId)
3542    {
3543       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3544       return RFAILED;
3545    }
3546    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3547
3548    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3549    DU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
3550          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3551    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3552    {
3553       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3554       return RFAILED;
3555    }
3556    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
3557                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3558
3559    searchSpc->duration = NULLP;
3560    searchSpc->monitoringSymbolsWithinSlot = NULLP;
3561    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3562    if(!searchSpc->monitoringSymbolsWithinSlot)
3563    {
3564       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3565       return RFAILED;
3566    }
3567
3568    /* Values taken from reference logs :
3569     * size 2 bytes
3570     * 2 LSBs unsued
3571     * Bit string stores 8000
3572     */
3573    numBytes = 2;
3574    bitsUnused = 2;
3575
3576    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3577    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3578    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
3579          searchSpc->monitoringSymbolsWithinSlot->size);
3580    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3581    {
3582       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3583       return RFAILED;
3584    }
3585
3586    byteIdx = 0;
3587    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
3588                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3589    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3590    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3591
3592    searchSpc->nrofCandidates = NULLP;
3593    DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3594    if(!searchSpc->nrofCandidates)
3595    {
3596       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3597       return RFAILED;
3598    }
3599
3600    searchSpc->nrofCandidates->aggregationLevel1 = \
3601                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3602    searchSpc->nrofCandidates->aggregationLevel2 = \
3603                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3604    searchSpc->nrofCandidates->aggregationLevel4 = \
3605                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3606    searchSpc->nrofCandidates->aggregationLevel8 = \
3607                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3608    searchSpc->nrofCandidates->aggregationLevel16 = \
3609                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3610
3611    searchSpc->searchSpaceType = NULLP;
3612    DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3613    if(!searchSpc->searchSpaceType)
3614    {
3615       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3616       return RFAILED;
3617    }
3618
3619    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3620
3621    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3622    DU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
3623          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3624    if(!searchSpc->searchSpaceType->choice.ue_Specific)
3625    {
3626       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3627       return RFAILED;
3628    }
3629    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
3630                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3631
3632    return ROK;
3633 }/* End BuildSearchSpcToAddModList */
3634
3635 /*******************************************************************
3636  *
3637  * @brief Builds BWP DL dedicated PDCCH config
3638  *
3639  * @details
3640  *
3641  *    Function : BuildBWPDlDedPdcchCfg
3642  *
3643  *    Functionality: Builds BWP DL dedicated PDCCH config
3644  *
3645  * @params[in] struct PDCCH_Config *pdcchCfg
3646  *
3647  * @return ROK     - success
3648  *         RFAILED - failure
3649  *
3650  * ****************************************************************/
3651 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
3652 {
3653    pdcchCfg->controlResourceSetToAddModList = NULLP;
3654    DU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
3655          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3656    if(!pdcchCfg->controlResourceSetToAddModList)
3657    {
3658       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3659       return RFAILED;
3660    }
3661
3662    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
3663    {
3664       return RFAILED;
3665    }
3666
3667    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3668
3669    pdcchCfg->searchSpacesToAddModList = NULLP;
3670    DU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3671          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3672    if(!pdcchCfg->searchSpacesToAddModList)
3673    {
3674       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3675       return RFAILED;
3676    }
3677
3678    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3679    {
3680       return RFAILED;
3681    }
3682
3683    pdcchCfg->searchSpacesToReleaseList = NULLP;
3684    pdcchCfg->downlinkPreemption = NULLP;
3685    pdcchCfg->tpc_PUSCH = NULLP;
3686    pdcchCfg->tpc_PUCCH = NULLP;
3687    pdcchCfg->tpc_SRS = NULLP;
3688
3689    return ROK;
3690 }
3691
3692 /*******************************************************************
3693  *
3694  * @brief Builds DMRS DL PDSCH Mapping type A
3695  *
3696  * @details
3697  *
3698  *    Function : BuildDMRSDLPdschMapTypeA
3699  *
3700  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3701  *
3702  * @params[in]
3703  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3704  * @return ROK     - success
3705  *         RFAILED - failure
3706  *
3707  * ****************************************************************/
3708    uint8_t BuildDMRSDLPdschMapTypeA
3709 (
3710  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3711  )
3712 {
3713    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3714    dmrsDlCfg->choice.setup = NULLP;
3715    DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3716    if(!dmrsDlCfg->choice.setup)
3717    {
3718       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3719       return RFAILED;
3720    }
3721
3722    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3723    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3724    DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3725    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3726    {
3727       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3728       return RFAILED;
3729    }
3730    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3731
3732    dmrsDlCfg->choice.setup->maxLength = NULLP;
3733    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3734    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3735    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3736
3737    return ROK;
3738 }
3739
3740 /*******************************************************************
3741  *
3742  * @brief Builds TCI states to add/modify list
3743  *
3744  * @details
3745  *
3746  *    Function : BuildTCIStatesToAddModList
3747  *
3748  *    Functionality:Builds TCI states to add/modify list
3749  *
3750  * @params[in]
3751  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3752  *
3753  * @return ROK     - success
3754  *         RFAILED - failure
3755  *
3756  * ****************************************************************/
3757 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3758 {
3759    return ROK;
3760 }
3761
3762 /*******************************************************************
3763  *
3764  * @brief Builds PDSCH time domain allocation list
3765  *
3766  * @details
3767  *
3768  *    Function : BuildPdschTimeDomAllocList
3769  *
3770  *    Functionality: Builds PDSCH time domain allocation list
3771  *
3772  * @params[in]
3773  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3774  *
3775  * @return ROK     - success
3776  *         RFAILED - failure
3777  *
3778  * ****************************************************************/
3779    uint8_t BuildPdschTimeDomAllocList
3780 (
3781  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3782  )
3783 {
3784    uint8_t idx;
3785    uint8_t elementCnt;
3786    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3787
3788    timeDomAllocList->present = \
3789                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3790
3791    timeDomAllocList->choice.setup = NULLP;
3792    DU_ALLOC(timeDomAllocList->choice.setup, \
3793          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3794    if(!timeDomAllocList->choice.setup)
3795    {
3796       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3797       return RFAILED;
3798    }
3799
3800    elementCnt = 2;
3801    timeDomAllocList->choice.setup->list.count = elementCnt;
3802    timeDomAllocList->choice.setup->list.size = \
3803                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3804
3805    timeDomAllocList->choice.setup->list.array = NULLP;
3806    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3807          timeDomAllocList->choice.setup->list.size);
3808    if(!timeDomAllocList->choice.setup->list.array)
3809    {
3810       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3811       return RFAILED;
3812    }
3813
3814    for(idx = 0; idx < elementCnt; idx++)
3815    {
3816       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3817       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3818             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3819       if(!timeDomAllocList->choice.setup->list.array[idx])
3820       {
3821          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3822          return RFAILED;
3823       }
3824    }
3825
3826    idx = 0;
3827    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3828    DU_ALLOC(timeDomAlloc->k0, sizeof(long));
3829    if(!timeDomAlloc->k0)
3830    {
3831       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3832       return RFAILED;
3833    }
3834    *(timeDomAlloc->k0) = 0;
3835    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3836    timeDomAlloc->startSymbolAndLength = \
3837                                         calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
3838
3839    idx++;
3840    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3841    DU_ALLOC(timeDomAlloc->k0, sizeof(long));
3842    if(!timeDomAlloc->k0)
3843    {
3844       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3845       return RFAILED;
3846    }
3847    *(timeDomAlloc->k0) = 1;
3848    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3849    timeDomAlloc->startSymbolAndLength = calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
3850
3851    return ROK;
3852 }
3853
3854 /*******************************************************************
3855  *
3856  * @brief Builds PDSCH PRB Bundling type
3857  *
3858  * @details
3859  *
3860  *    Function : BuildPdschPrbBundlingType
3861  *
3862  *    Functionality: Builds PDSCH PRB Bundling type
3863  *
3864  * @params[in]
3865  * struct PDSCH_Config__prb_BundlingType *prbBndlType
3866  *
3867  * @return ROK     - success
3868  *         RFAILED - failure
3869  *
3870  * ****************************************************************/
3871    uint8_t BuildPdschPrbBundlingType
3872 (
3873  struct PDSCH_Config__prb_BundlingType *prbBndlType
3874  )
3875 {
3876    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
3877
3878    prbBndlType->choice.staticBundling = NULLP;
3879    DU_ALLOC(prbBndlType->choice.staticBundling, \
3880          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
3881    if(!prbBndlType->choice.staticBundling)
3882    {
3883       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
3884       return RFAILED;
3885    }
3886    prbBndlType->choice.staticBundling->bundleSize = NULLP;
3887
3888    return ROK;
3889 }
3890
3891 /*******************************************************************
3892  *
3893  * @brief Builds BWP DL dedicated PDSCH config
3894  *
3895  * @details
3896  *
3897  *    Function : BuildBWPDlDedPdschCfg
3898  *
3899  *    Functionality: Builds BWP DL dedicated PDSCH config
3900  *
3901  * @params[in] struct PDSCH_Config *pdschCfg
3902  *
3903  * @return ROK     - success
3904  *         RFAILED - failure
3905  *
3906  * ****************************************************************/
3907 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
3908 {
3909    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
3910
3911    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
3912    DU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
3913          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
3914    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
3915    {
3916       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3917       return RFAILED;
3918    }
3919
3920    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
3921    {
3922       return RFAILED;
3923    }
3924
3925    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
3926    pdschCfg->tci_StatesToAddModList = NULLP;
3927    pdschCfg->tci_StatesToReleaseList = NULLP;
3928    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
3929 #if 0
3930    DU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
3931    if(!pdschCfg->tci_StatesToAddModList)
3932    {
3933       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3934       return RFAILED;
3935    }
3936    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
3937    {
3938       return RFAILED;
3939    }
3940 #endif
3941
3942    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
3943
3944    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
3945    DU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
3946          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
3947    if(!pdschCfg->pdsch_TimeDomainAllocationList)
3948    {
3949       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3950       return RFAILED;
3951    }
3952
3953    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
3954    {
3955       return RFAILED;
3956    }
3957
3958    pdschCfg->pdsch_AggregationFactor = NULLP;
3959    pdschCfg->rateMatchPatternToAddModList = NULLP;
3960    pdschCfg->rateMatchPatternToReleaseList = NULLP;
3961    pdschCfg->rateMatchPatternGroup1 = NULLP;
3962    pdschCfg->rateMatchPatternGroup2 = NULLP;
3963    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
3964    pdschCfg->mcs_Table = NULLP;
3965
3966    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
3967    DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
3968    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
3969    {
3970       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3971       return RFAILED;
3972    }
3973    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
3974
3975    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
3976    {
3977       return RFAILED;
3978    }
3979
3980    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
3981    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
3982    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3983    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3984    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3985    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3986    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
3987
3988    return ROK;
3989 }
3990
3991 /*******************************************************************
3992  *
3993  * @brief Builds intitial DL BWP
3994  * @details
3995  *
3996  *    Function : BuildInitialDlBWP
3997  *
3998  *    Functionality: Builds intitial DL BWP in spCellCfgDed
3999  *
4000  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4001  *
4002  * @return ROK     - success
4003  *         RFAILED - failure
4004  *
4005  * ****************************************************************/
4006 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
4007 {
4008    dlBwp->pdcch_Config = NULLP;
4009    DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
4010    if(!dlBwp->pdcch_Config)
4011    {
4012       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4013       return RFAILED;
4014    }
4015    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
4016
4017    dlBwp->pdcch_Config->choice.setup = NULLP;
4018    DU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
4019    if(!dlBwp->pdcch_Config->choice.setup)
4020    {
4021       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4022       return RFAILED;
4023    }
4024    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
4025    {
4026       return RFAILED;
4027    }
4028
4029    dlBwp->pdsch_Config = NULLP;
4030    DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
4031    if(!dlBwp->pdsch_Config)
4032    {
4033       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4034       return RFAILED;
4035    }
4036    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
4037
4038    dlBwp->pdsch_Config->choice.setup = NULLP;
4039    DU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
4040    if(!dlBwp->pdsch_Config->choice.setup)
4041    {
4042       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4043       return RFAILED;
4044    }
4045
4046    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
4047    {
4048       return RFAILED;
4049    }
4050
4051    dlBwp->sps_Config = NULLP;
4052    dlBwp->radioLinkMonitoringConfig = NULLP;
4053    return ROK;
4054 }
4055
4056 /*******************************************************************
4057  *
4058  * @brief Builds DMRS UL Pusch Mapping type A
4059  *
4060  * @details
4061  *
4062  *    Function : BuildDMRSULPuschMapTypeA
4063  *
4064  *    Functionality: Builds DMRS UL Pusch Mapping type A
4065  *
4066  * @params[in]
4067  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4068  * @return ROK     - success
4069  *         RFAILED - failure
4070  *
4071  * ****************************************************************/
4072    uint8_t BuildDMRSULPuschMapTypeA
4073 (
4074  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4075  )
4076 {
4077    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
4078    dmrsUlCfg->choice.setup= NULLP;
4079    DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
4080    if(!dmrsUlCfg->choice.setup)
4081    {
4082       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4083       return RFAILED;
4084    }
4085
4086    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
4087    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
4088    DU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
4089    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4090    {
4091       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4092       return RFAILED;
4093    }
4094    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
4095
4096    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
4097    dmrsUlCfg->choice.setup->maxLength = NULLP;
4098    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
4099    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
4100          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4101    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4102    {
4103       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4104       return RFAILED;
4105    }
4106
4107    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
4108    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4109          sizeof(long));
4110    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
4111    {
4112       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4113       return RFAILED;
4114    }
4115    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
4116
4117    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
4118    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
4119    return ROK;
4120 }
4121
4122 /*******************************************************************
4123  *
4124  * @brief Build PUSCH time domain allocation list
4125  *
4126  * @details
4127  *
4128  *    Function : BuildPuschTimeDomAllocList
4129  *
4130  *    Functionality: Build PUSCH time domain allocation list
4131  *
4132  * @params[in]
4133  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4134  *
4135  * @return ROK     - success
4136  *         RFAILED - failure
4137  *
4138  * ****************************************************************/
4139    uint8_t BuildPuschTimeDomAllocList
4140 (
4141  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4142  )
4143 {
4144    uint8_t idx;
4145    uint8_t elementCnt;
4146    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
4147
4148    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
4149    timeDomAllocList->choice.setup = NULLP;
4150    DU_ALLOC(timeDomAllocList->choice.setup, \
4151          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4152    if(!timeDomAllocList->choice.setup)
4153    {
4154       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4155       return RFAILED;
4156    }
4157
4158    elementCnt = 2;
4159    timeDomAllocList->choice.setup->list.count = elementCnt;
4160    timeDomAllocList->choice.setup->list.size = \
4161                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
4162    timeDomAllocList->choice.setup->list.array = NULLP;
4163    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
4164          timeDomAllocList->choice.setup->list.size);
4165    if(!timeDomAllocList->choice.setup->list.array)
4166    {
4167       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4168       return RFAILED;
4169    }
4170
4171    for(idx = 0; idx < elementCnt; idx++)
4172    {
4173       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4174       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
4175             sizeof(PUSCH_TimeDomainResourceAllocation_t));
4176       if(!timeDomAllocList->choice.setup->list.array[idx])
4177       {
4178          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4179          return RFAILED;
4180       }
4181    }
4182
4183    idx = 0;
4184    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4185    DU_ALLOC(timeDomAlloc->k2, sizeof(long));
4186    if(!timeDomAlloc->k2)
4187    {
4188       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4189       return RFAILED;
4190    }
4191    *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
4192    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4193    timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
4194
4195    idx++;
4196    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4197    DU_ALLOC(timeDomAlloc->k2, sizeof(long));
4198    if(!timeDomAlloc->k2)
4199    {
4200       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4201       return RFAILED;
4202    }
4203    *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
4204    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4205    timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
4206
4207    return ROK;
4208 }
4209
4210 /*******************************************************************
4211  *
4212  * @brief Builds BWP UL dedicated PUSCH Config
4213  *
4214  * @details
4215  *
4216  *    Function : BuildBWPUlDedPuschCfg
4217  *
4218  *    Functionality:
4219  *      Builds BWP UL dedicated PUSCH Config
4220  *
4221  * @params[in] : PUSCH_Config_t *puschCfg
4222  *
4223  * @return ROK     - success
4224  *         RFAILED - failure
4225  *
4226  * ****************************************************************/
4227 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
4228 {
4229    puschCfg->dataScramblingIdentityPUSCH = NULLP;
4230    DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4231    if(!puschCfg->dataScramblingIdentityPUSCH)
4232    {
4233       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4234       return RFAILED;
4235    }
4236    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
4237
4238    puschCfg->txConfig = NULLP;
4239    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4240    DU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4241          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4242    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4243    {
4244       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4245       return RFAILED;
4246    }
4247
4248    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4249    {
4250       return RFAILED;
4251    }
4252
4253    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4254    puschCfg->pusch_PowerControl = NULLP;
4255    puschCfg->frequencyHopping = NULLP;
4256    puschCfg->frequencyHoppingOffsetLists = NULLP;
4257    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4258
4259    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4260    DU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
4261          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4262    if(!puschCfg->pusch_TimeDomainAllocationList)
4263    {
4264       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4265       return RFAILED;
4266    }
4267
4268    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
4269    {
4270       return RFAILED;
4271    }
4272
4273    puschCfg->pusch_AggregationFactor = NULLP;
4274    puschCfg->mcs_Table = NULLP;
4275    puschCfg->mcs_TableTransformPrecoder = NULLP;
4276    puschCfg->transformPrecoder = NULLP;
4277    DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4278    if(!puschCfg->transformPrecoder)
4279    {
4280       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4281       return RFAILED;
4282    }
4283    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4284
4285    puschCfg->codebookSubset = NULLP;
4286    puschCfg->maxRank = NULLP;
4287    puschCfg->rbg_Size = NULLP;
4288    puschCfg->uci_OnPUSCH = NULLP;
4289    puschCfg->tp_pi2BPSK = NULLP;
4290
4291    return ROK;
4292 }
4293
4294 /*******************************************************************
4295  *
4296  * @brief Builds BWP UL dedicated PUCCH Config
4297  *
4298  * @details
4299  *
4300  *    Function : BuildBWPUlDedPucchCfg
4301  *
4302  *    Functionality:
4303  *      Builds BWP UL dedicated PUCCH Config
4304  *
4305  * @params[in] : PUCCH_Config_t *pucchCfg
4306  *
4307  * @return ROK     - success
4308  *         RFAILED - failure
4309  *
4310  * ****************************************************************/
4311 uint8_t BuildBWPUlDedPucchCfg(PUCCH_Config_t *pucchCfg)
4312 {
4313    uint8_t arrIdx, elementCnt;
4314
4315    DU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
4316    if(pucchCfg->dl_DataToUL_ACK == NULLP)
4317    {
4318       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4319       return RFAILED;
4320    }
4321
4322    elementCnt = 2;
4323    pucchCfg->dl_DataToUL_ACK->list.count = elementCnt;
4324    pucchCfg->dl_DataToUL_ACK->list.size = elementCnt * sizeof(long *);
4325    DU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
4326    if(pucchCfg->dl_DataToUL_ACK->list.array == NULLP)
4327    {
4328       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4329       return RFAILED;
4330    }
4331
4332    for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
4333    {
4334       DU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
4335       if(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx] == NULLP)
4336       {
4337           DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4338           return RFAILED;
4339       }
4340    }
4341
4342    arrIdx = 0;
4343    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx++]) = 1;
4344    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx]) = 2;
4345    return ROK;
4346 }
4347
4348 /*******************************************************************
4349  *
4350  * @brief Fills SRS resource to add/modify list
4351  *
4352  * @details
4353  *
4354  *    Function : BuildSrsRsrcAddModList
4355  *
4356  *    Functionality: Fills SRS resource to add/modify list
4357  *
4358  * @params[in]
4359  * @return ROK     - success
4360  *         RFAILED - failure
4361  *
4362  * ****************************************************************/
4363 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
4364 {
4365    uint8_t   elementCnt;
4366    uint8_t   rsrcIdx;
4367
4368    elementCnt = 1;
4369    resourceList->list.count = elementCnt;
4370    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
4371    resourceList->list.array = NULLP;
4372    DU_ALLOC(resourceList->list.array, resourceList->list.size);
4373    if(!resourceList->list.array)
4374    {
4375       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4376       return RFAILED;
4377    }
4378
4379    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4380    {
4381       DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4382       if(!resourceList->list.array[rsrcIdx])
4383       {
4384          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4385          return RFAILED;
4386       }
4387    }
4388
4389    rsrcIdx = 0;
4390    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
4391    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
4392    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
4393
4394    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
4395    DU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
4396          sizeof(struct SRS_Resource__transmissionComb__n2));
4397    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
4398    {
4399       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4400       return RFAILED;
4401    }
4402    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
4403       = SRS_COMB_OFFSET_N2;
4404    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
4405       = SRS_CYCLIC_SHIFT_N2;
4406
4407    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
4408                                                                       PUSCH_START_SYMBOL;
4409    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
4410                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
4411    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
4412                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
4413
4414    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
4415    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
4416    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
4417    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
4418    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
4419    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
4420                                                                SRS_Resource__groupOrSequenceHopping_neither;
4421
4422    /* Setting resource type to aperiodic for intergration purposes */
4423    resourceList->list.array[rsrcIdx]->resourceType.present = \
4424                                                              SRS_Resource__resourceType_PR_aperiodic;
4425    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
4426    DU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
4427          sizeof(struct SRS_Resource__resourceType__aperiodic));
4428    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
4429    {
4430       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4431       return RFAILED;
4432    }
4433    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
4434
4435    return ROK;
4436 }
4437
4438 /*******************************************************************
4439  *
4440  * @brief Build SRS resource set Add/mod list
4441  *
4442  * @details
4443  *
4444  *    Function : BuildSrsRsrcSetAddModList
4445  *
4446  *    Functionality: Build SRS resource set Add/mod list
4447  *
4448  * @params[in]
4449  * @return ROK     - success
4450  *         RFAILED - failure
4451  *
4452  * ****************************************************************/
4453    uint8_t BuildSrsRsrcSetAddModList
4454 (
4455  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
4456  )
4457 {
4458    uint8_t  elementCnt;
4459    uint8_t  rSetIdx;
4460    uint8_t  rsrcIdx;
4461    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
4462
4463    elementCnt = 1;
4464    rsrcSetList->list.count = elementCnt;
4465    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
4466    rsrcSetList->list.array = NULLP;
4467    DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
4468    if(!rsrcSetList->list.array)
4469    {
4470       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4471       return RFAILED;
4472    }
4473
4474    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4475    {
4476       DU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4477       if(!rsrcSetList->list.array[rSetIdx])
4478       {
4479          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4480          return RFAILED;
4481       }
4482    }
4483
4484    rSetIdx = 0;
4485    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
4486
4487    /* Fill Resource Id list in resource set */
4488    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
4489    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4490          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4491    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4492    {
4493       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4494       return RFAILED;
4495    }
4496
4497    elementCnt = 1;
4498    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4499    rsrcIdList->list.count = elementCnt;
4500    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
4501    rsrcIdList->list.array = NULLP;
4502    DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
4503    if(!rsrcIdList->list.array)
4504    {
4505       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4506       return RFAILED;
4507    }
4508
4509    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4510    {
4511       DU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4512       if(!rsrcIdList->list.array[rsrcIdx])
4513       {
4514          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4515          return RFAILED;
4516       }
4517    }
4518
4519    rsrcIdx = 0;
4520    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
4521
4522    /* Fill resource type */
4523    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
4524                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
4525
4526    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
4527    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4528          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4529    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
4530    {
4531       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4532       return RFAILED;
4533    }
4534    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
4535       = APERIODIC_SRS_RESRC_TRIGGER;
4536
4537    /* TODO : Fill values for below IEs as expected by Viavi */
4538    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
4539    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
4540
4541
4542    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
4543    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
4544    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
4545    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
4546    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
4547
4548    return ROK;
4549 }
4550
4551 /*******************************************************************
4552  *
4553  * @brief Builds BWP UL dedicated SRS Config
4554  *
4555  * @details
4556  *
4557  *    Function : BuildBWPUlDedSrsCfg
4558  *
4559  *    Functionality: Builds BWP UL dedicated SRS Config
4560  *
4561  * @params[in] SRS Config
4562  * @return ROK     - success
4563  *         RFAILED - failure
4564  *
4565  * ****************************************************************/
4566 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
4567 {
4568    srsCfg->srs_ResourceSetToReleaseList = NULLP;
4569    srsCfg->srs_ResourceSetToAddModList = NULLP;
4570    DU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
4571          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4572    if(!srsCfg->srs_ResourceSetToAddModList)
4573    {
4574       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4575       return RFAILED;
4576    }
4577    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
4578    {
4579       return RFAILED;
4580    }
4581
4582    srsCfg->srs_ResourceToReleaseList = NULLP;
4583
4584    /* Resource to Add/Modify list */
4585    srsCfg->srs_ResourceToAddModList = NULLP;
4586    DU_ALLOC(srsCfg->srs_ResourceToAddModList, \
4587          sizeof(struct SRS_Config__srs_ResourceToAddModList));
4588    if(!srsCfg->srs_ResourceToAddModList)
4589    {
4590       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4591       return RFAILED;
4592    }
4593
4594    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
4595    {
4596       return RFAILED;
4597    }
4598
4599    srsCfg->tpc_Accumulation = NULLP;
4600
4601    return ROK;
4602 }
4603
4604
4605
4606 /*******************************************************************
4607  *
4608  * @brief Builds Pusch Serving cell Config
4609  *
4610  * @details
4611  *
4612  *    Function : BuildPuschSrvCellCfg
4613  *
4614  *    Functionality: Builds Pusch Serving cell Config
4615  *
4616  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
4617  *
4618  * @return ROK     - success
4619  *         RFAILED - failure
4620  *
4621  * ****************************************************************/
4622 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
4623 {
4624    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
4625    puschCfg->choice.setup = NULLP;
4626    DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4627    if(!puschCfg->choice.setup)
4628    {
4629       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4630       return RFAILED;
4631    }
4632
4633    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4634    puschCfg->choice.setup->rateMatching = NULLP;
4635    puschCfg->choice.setup->xOverhead = NULLP;
4636    puschCfg->choice.setup->ext1 = NULLP;
4637    DU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
4638    if(!puschCfg->choice.setup->ext1)
4639    {
4640       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4641       return RFAILED;
4642    }
4643
4644    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
4645    DU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
4646    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
4647    {
4648       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4649       return RFAILED;
4650    }
4651    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
4652
4653    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
4654    DU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
4655    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
4656    {
4657       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4658       return RFAILED;
4659    }
4660    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
4661    return ROK;
4662 }
4663
4664 /*******************************************************************
4665  *
4666  * @brief Builds inital UL BWP
4667  *
4668  * @details
4669  *
4670  *    Function : BuildInitialUlBWP
4671  *
4672  *    Functionality: Builds initial UL BWP
4673  *
4674  * @params[in] BWP_UplinkDedicated_t *ulBwp
4675  * @return ROK     - success
4676  *         RFAILED - failure
4677  *
4678  * ****************************************************************/
4679 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4680 {
4681    ulBwp->pucch_Config = NULLP;
4682    DU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
4683    if(!ulBwp->pucch_Config)
4684    {
4685       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4686       return RFAILED;
4687    }
4688
4689    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
4690    ulBwp->pucch_Config->choice.setup = NULLP;
4691    DU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
4692    if(!ulBwp->pucch_Config->choice.setup)
4693    {
4694       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4695       return RFAILED;
4696    }
4697
4698    if(BuildBWPUlDedPucchCfg(ulBwp->pucch_Config->choice.setup) != ROK)
4699    {
4700       return RFAILED;
4701    }
4702
4703    /* Fill BWP UL dedicated PUSCH config */
4704    ulBwp->pusch_Config = NULLP;
4705    DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4706    if(!ulBwp->pusch_Config)
4707    {
4708       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4709       return RFAILED;
4710    }
4711
4712    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
4713    ulBwp->pusch_Config->choice.setup = NULLP;
4714    DU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4715    if(!ulBwp->pusch_Config->choice.setup)
4716    {
4717       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4718       return RFAILED;
4719    }
4720
4721    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
4722    {
4723       return RFAILED;
4724    }
4725
4726    ulBwp->configuredGrantConfig = NULLP;
4727
4728    /* Fill BPW UL dedicated SRS config */
4729    ulBwp->srs_Config = NULLP;
4730    DU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4731    if(!ulBwp->srs_Config)
4732    {
4733       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4734       return RFAILED;
4735    }
4736
4737    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
4738    ulBwp->srs_Config->choice.setup = NULLP;
4739    DU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4740    if(!ulBwp->srs_Config->choice.setup)
4741    {
4742       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4743       return RFAILED;
4744    }
4745
4746    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
4747    {
4748       return RFAILED;
4749    }
4750
4751    ulBwp->beamFailureRecoveryConfig = NULLP;
4752
4753    return ROK;
4754 }
4755
4756 /*******************************************************************
4757  *
4758  * @brief Builds UL config
4759  * @details
4760  *
4761  *    Function : BuildUlCfg
4762  *
4763  *    Functionality: Builds UL config in spCellCfgDed
4764  *
4765  * @params[in] UplinkConfig_t *ulCfg
4766  *
4767  * @return ROK     - success
4768  *         RFAILED - failure
4769  *
4770  * ****************************************************************/
4771 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
4772 {
4773    ulCfg->initialUplinkBWP = NULLP;
4774    DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4775    if(!ulCfg->initialUplinkBWP)
4776    {
4777       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4778       return RFAILED;
4779    }
4780
4781    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
4782    {
4783       return RFAILED;
4784    }
4785
4786    ulCfg->uplinkBWP_ToReleaseList = NULLP;
4787    ulCfg->uplinkBWP_ToAddModList = NULLP;
4788    ulCfg->firstActiveUplinkBWP_Id = NULLP;
4789    DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4790    if(!ulCfg->firstActiveUplinkBWP_Id)
4791    {
4792       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4793       return RFAILED;
4794    }
4795    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
4796
4797    ulCfg->pusch_ServingCellConfig = NULLP;
4798    DU_ALLOC(ulCfg->pusch_ServingCellConfig, \
4799          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4800    if(!ulCfg->pusch_ServingCellConfig)
4801    {
4802       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4803       return RFAILED;
4804    }
4805
4806    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
4807    {
4808       return RFAILED;
4809    }
4810
4811    ulCfg->carrierSwitching = NULLP;
4812    ulCfg->ext1 = NULLP;
4813    return ROK;
4814 }
4815
4816 /*******************************************************************
4817  *
4818  * @brief Builds PDSCH serving cell config
4819  * @details
4820  *
4821  *    Function : BuildPdschSrvCellCfg
4822  *
4823  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
4824  *
4825  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
4826  *
4827  * @return ROK     - success
4828  *         RFAILED - failure
4829  *
4830  * ****************************************************************/
4831 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
4832 {
4833    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
4834    pdschCfg->choice.setup = NULLP;
4835    DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
4836    if(!pdschCfg->choice.setup)
4837    {
4838       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4839       return RFAILED;
4840    }
4841
4842    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4843    pdschCfg->choice.setup->xOverhead = NULLP;
4844    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
4845    DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
4846    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
4847    {
4848       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4849       return RFAILED;
4850    }
4851    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
4852    pdschCfg->choice.setup->pucch_Cell = NULLP;
4853    pdschCfg->choice.setup->ext1 = NULLP;
4854
4855    return ROK;
4856 }
4857
4858 /*******************************************************************
4859  *
4860  * @brief Builds CSI Meas config
4861  * @details
4862  *
4863  *    Function : BuildCsiMeasCfg
4864  *
4865  *    Functionality: Builds CSI Meas config in spCellCfgDed
4866  *
4867  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
4868  *
4869  * @return ROK     - success
4870  *         RFAILED - failure
4871  *
4872  * ****************************************************************/
4873 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
4874 {
4875
4876    return ROK;
4877 }
4878
4879 /*******************************************************************
4880  *
4881  * @brief Builds Spcell config dedicated
4882  * @details
4883  *
4884  *    Function : BuildSpCellCfgDed
4885  *
4886  *    Functionality: Builds sp cell config dedicated in spCellCfg
4887  *
4888  * @params[in] ServingCellConfig_t srvCellCfg
4889  *
4890  * @return ROK     - success
4891  *         RFAILED - failure
4892  *
4893  * ****************************************************************/
4894 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
4895 {
4896    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
4897    DU_ALLOC(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
4898    if(!srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
4899    {
4900       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4901       return RFAILED;
4902    }
4903
4904    srvCellCfg->initialDownlinkBWP = NULLP;
4905    DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
4906    if(!srvCellCfg->initialDownlinkBWP)
4907    {
4908       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4909       return RFAILED;
4910    }
4911
4912    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
4913    {
4914       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
4915       return RFAILED;
4916    }
4917    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
4918    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
4919
4920    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
4921    DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
4922    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
4923    {
4924       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4925       return RFAILED;
4926    }
4927    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4928
4929    srvCellCfg->bwp_InactivityTimer = NULLP;
4930
4931    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
4932    DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
4933    if(!srvCellCfg->defaultDownlinkBWP_Id)
4934    {
4935       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4936       return RFAILED;
4937    }
4938    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4939
4940    srvCellCfg->uplinkConfig = NULLP;
4941    DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
4942    if(!srvCellCfg->uplinkConfig)
4943    {
4944       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4945       return RFAILED;
4946    }
4947
4948    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
4949    {
4950       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
4951       return RFAILED;
4952    }
4953    srvCellCfg->supplementaryUplink = NULLP;
4954    srvCellCfg->pdcch_ServingCellConfig = NULLP;
4955
4956    srvCellCfg->pdsch_ServingCellConfig = NULLP;
4957    DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
4958    if(!srvCellCfg->pdsch_ServingCellConfig)
4959    {
4960       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4961       return RFAILED;
4962    }
4963
4964    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
4965    {
4966       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
4967       return RFAILED;
4968    }
4969
4970    srvCellCfg->csi_MeasConfig = NULLP;
4971 #if 0
4972    DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
4973       if(!srvCellCfg->csi_MeasConfig)
4974       {
4975          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4976          return RFAILED;
4977       }
4978
4979    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
4980    {
4981       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
4982       return RFAILED;
4983    }
4984 #endif
4985    srvCellCfg->sCellDeactivationTimer = NULLP;
4986    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
4987    srvCellCfg->tag_Id = TAG_ID;
4988    srvCellCfg->dummy = NULLP;
4989    srvCellCfg->pathlossReferenceLinking = NULLP;
4990    srvCellCfg->servingCellMO = NULLP;
4991    srvCellCfg->ext1 = NULLP;
4992
4993    return ROK;
4994 }
4995 /*******************************************************************
4996  *
4997  * @brief Builds Spcell config
4998  *
4999  * @details
5000  *
5001  *    Function : BuildSpCellCfg
5002  *
5003  *    Functionality: Builds sp cell config in DuToCuRrcContainer
5004  *
5005  * @params[in] SpCellConfig_t spCellCfg
5006  *
5007  * @return ROK     - success
5008  *         RFAILED - failure
5009  *
5010  * ****************************************************************/
5011 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
5012 {
5013
5014    spCellCfg->servCellIndex = NULLP;
5015    DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
5016    if(!spCellCfg->servCellIndex)
5017    {
5018       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5019       return RFAILED;
5020    }
5021    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
5022
5023    spCellCfg->reconfigurationWithSync = NULLP;
5024    spCellCfg->rlf_TimersAndConstants = NULLP;
5025    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
5026    DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5027    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
5028    {
5029       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5030       return RFAILED;
5031    }
5032    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
5033
5034    spCellCfg->spCellConfigDedicated = NULLP;
5035    DU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5036    if(!spCellCfg->spCellConfigDedicated)
5037    {
5038       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5039       return RFAILED;
5040    }
5041    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
5042    {
5043       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
5044       return RFAILED;
5045    }
5046    return ROK;
5047 }
5048 /*******************************************************************
5049  *
5050  * @brief Builds Phy cell group config
5051  *
5052  * @details
5053  *
5054  *    Function : BuildPhyCellGrpCfg
5055  *
5056  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
5057  *
5058  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
5059  *
5060  * @return ROK     - success
5061  *         RFAILED - failure
5062  *
5063  * ****************************************************************/
5064 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
5065 {
5066    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
5067    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
5068
5069    phyCellGrpCfg->p_NR_FR1 = NULLP;
5070    DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5071    if(!phyCellGrpCfg->p_NR_FR1)
5072    {
5073       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
5074       return RFAILED;
5075    }
5076    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
5077    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
5078    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
5079    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
5080    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
5081    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
5082    phyCellGrpCfg->cs_RNTI = NULLP;
5083    phyCellGrpCfg->ext1 = NULLP;
5084    phyCellGrpCfg->ext2 = NULLP;
5085
5086    return ROK;
5087 }
5088 /*******************************************************************
5089  *
5090  * @brief Builds Mac cell group config
5091  *
5092  * @details
5093  *
5094  *    Function : BuildMacCellGrpCfg
5095  *
5096  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
5097  *
5098  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
5099  *
5100  * @return ROK     - success
5101  *         RFAILED - failure
5102  *
5103  * ****************************************************************/
5104 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
5105 {
5106    macCellGrpCfg->drx_Config = NULLP;
5107    macCellGrpCfg->schedulingRequestConfig = NULLP;
5108    DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5109    if(!macCellGrpCfg->schedulingRequestConfig)
5110    {
5111       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5112       return RFAILED;
5113    }
5114
5115    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
5116    {
5117       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
5118       return RFAILED;
5119    }
5120
5121    macCellGrpCfg->bsr_Config = NULLP;
5122    DU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5123    if(!macCellGrpCfg->bsr_Config)
5124    {
5125       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5126       return RFAILED;
5127    }
5128
5129    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
5130    {
5131       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
5132       return RFAILED;
5133    }
5134
5135    macCellGrpCfg->tag_Config = NULLP;
5136    DU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
5137    if(!macCellGrpCfg->tag_Config)
5138    {
5139       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5140       return RFAILED;
5141    }
5142
5143    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
5144    {
5145       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
5146       return RFAILED;
5147    }
5148
5149    macCellGrpCfg->phr_Config = NULLP;
5150    DU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
5151    if(!macCellGrpCfg->phr_Config)
5152    {
5153       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5154       return RFAILED;
5155    }
5156
5157    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
5158    {
5159       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
5160       return RFAILED;
5161    }
5162
5163    macCellGrpCfg->skipUplinkTxDynamic = false;
5164    macCellGrpCfg->ext1 = NULLP;
5165
5166    return ROK;
5167 }
5168 /*******************************************************************
5169  *
5170  * @brief Frees memeory allocated for SearchSpcToAddModList
5171  *
5172  * @details
5173  *
5174  *    Function : FreeSearchSpcToAddModList
5175  *
5176  *    Functionality: Deallocating memory of SearchSpcToAddModList
5177  *
5178  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
5179  *
5180  * @return void
5181  *
5182  4221 * ****************************************************************/
5183 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
5184 {
5185    uint8_t idx1=0;
5186    uint8_t idx2=0;
5187    struct  SearchSpace *searchSpc=NULLP;
5188
5189    if(searchSpcList->list.array)
5190    {
5191       if(searchSpcList->list.array[idx2])
5192       {
5193          searchSpc = searchSpcList->list.array[idx2];
5194          if(searchSpc->controlResourceSetId)
5195          {
5196             if(searchSpc->monitoringSlotPeriodicityAndOffset)
5197             {
5198                if(searchSpc->monitoringSymbolsWithinSlot)
5199                {
5200                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
5201                   {
5202                      if(searchSpc->nrofCandidates)
5203                      {
5204                         if(searchSpc->searchSpaceType)
5205                         {
5206                            DU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
5207                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
5208                            DU_FREE(searchSpc->searchSpaceType, sizeof(struct
5209                                     SearchSpace__searchSpaceType));
5210                         }
5211                         DU_FREE(searchSpc->nrofCandidates,
5212                               sizeof(struct SearchSpace__nrofCandidates));
5213                      }
5214                      DU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
5215                            searchSpc->monitoringSymbolsWithinSlot->size);
5216                   }
5217                   DU_FREE(searchSpc->monitoringSymbolsWithinSlot,
5218                         sizeof(BIT_STRING_t));
5219                }
5220                DU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
5221                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
5222             }
5223             DU_FREE(searchSpc->controlResourceSetId,
5224                   sizeof(ControlResourceSetId_t));
5225          }
5226       }
5227       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
5228       {
5229          DU_FREE(searchSpcList->list.array[idx1],
5230                sizeof(struct SearchSpace));
5231       }
5232       DU_FREE(searchSpcList->list.array,searchSpcList->list.size);
5233    }
5234 }
5235 /*******************************************************************
5236  *
5237  * @brief Frees memory allocated for PdschTimeDomAllocList
5238  *
5239  * @details
5240  *
5241  *    Function : FreePdschTimeDomAllocList
5242  *
5243  *    Functionality: Deallocating memory of PdschTimeDomAllocList
5244  *
5245  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
5246  *
5247  * @return void
5248  *
5249  * ****************************************************************/
5250 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
5251 {
5252    uint8_t idx1=0;
5253
5254    if(timeDomAllocList->choice.setup)
5255    {
5256       if(timeDomAllocList->choice.setup->list.array)
5257       {
5258          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
5259          {
5260             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1]->k0, sizeof(long));
5261             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
5262                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
5263          }
5264          DU_FREE(timeDomAllocList->choice.setup->list.array, \
5265                timeDomAllocList->choice.setup->list.size);
5266       }
5267       DU_FREE(timeDomAllocList->choice.setup,\
5268             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
5269    }
5270 }
5271 /*******************************************************************
5272  *
5273  * @brief Frees memory allocated for PuschTimeDomAllocList
5274  *
5275  *@details
5276  *
5277  *    Function : FreePuschTimeDomAllocList
5278  *
5279  *    Functionality: Deallocating memory of PuschTimeDomAllocList
5280  *
5281  * @params[in] PUSCH_Config_t *puschCfg
5282  *
5283  * @return void
5284  *
5285  * ****************************************************************/
5286 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
5287 {
5288    uint8_t rsrcListIdx=0;
5289    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
5290
5291    if(puschCfg->pusch_TimeDomainAllocationList)
5292    {
5293       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
5294       if(timeDomAllocList_t->choice.setup)
5295       {
5296          if(timeDomAllocList_t->choice.setup->list.array)
5297          {
5298             for(rsrcListIdx = 0; rsrcListIdx<timeDomAllocList_t->choice.setup->list.count; rsrcListIdx++)
5299             {
5300                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx]->k2, sizeof(long));
5301                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx],\
5302                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
5303             }
5304             DU_FREE(timeDomAllocList_t->choice.setup->list.array, \
5305                   timeDomAllocList_t->choice.setup->list.size);
5306          }
5307          DU_FREE(timeDomAllocList_t->choice.setup, \
5308                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
5309       }
5310       DU_FREE(puschCfg->transformPrecoder, sizeof(long));
5311       DU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
5312             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
5313    }
5314
5315 }
5316 /*******************************************************************
5317  *
5318  * @brief Frees memory allocated for InitialUlBWP
5319  *
5320  * @details
5321  *
5322  *    Function : FreeInitialUlBWP
5323  *
5324  *    Functionality: Deallocating memory of InitialUlBWP
5325  *
5326  * @params[in] BWP_UplinkDedicated_t *ulBwp
5327  *
5328  * @return void
5329  *
5330  * ****************************************************************/
5331 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5332 {
5333    uint8_t  rSetIdx, rsrcIdx, k1Idx;
5334    SRS_Config_t   *srsCfg = NULLP;
5335    PUSCH_Config_t *puschCfg = NULLP;
5336    PUCCH_Config_t *pucchCfg = NULLP;
5337    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
5338    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
5339    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
5340    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
5341
5342    if(ulBwp->pucch_Config)
5343    {
5344       if(ulBwp->pucch_Config->choice.setup)
5345       {
5346           pucchCfg = ulBwp->pucch_Config->choice.setup;
5347           if(pucchCfg->dl_DataToUL_ACK)
5348           {
5349              if(pucchCfg->dl_DataToUL_ACK->list.array)
5350              {
5351                 for(k1Idx = 0; k1Idx < pucchCfg->dl_DataToUL_ACK->list.count; k1Idx++)
5352                 {
5353                    DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[k1Idx], sizeof(long));
5354                 }
5355                 DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
5356              }
5357              DU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
5358           }
5359           DU_FREE(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
5360       }
5361       DU_FREE(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
5362    }
5363
5364    if(ulBwp->pusch_Config)
5365    {
5366       if(ulBwp->pusch_Config->choice.setup)
5367       {
5368          puschCfg=ulBwp->pusch_Config->choice.setup;
5369          if(puschCfg->dataScramblingIdentityPUSCH)
5370          {
5371             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
5372             {
5373                FreePuschTimeDomAllocList(puschCfg);
5374                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
5375                if(dmrsUlCfg->choice.setup)
5376                {
5377                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
5378                   {
5379                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
5380                      {
5381                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
5382                               sizeof(long));
5383                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
5384                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
5385                      }
5386                      DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
5387                            sizeof(long));
5388                   }
5389                   DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
5390                }
5391                DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
5392                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
5393             }
5394             DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
5395          }
5396          DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5397       }
5398       DU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5399
5400       /* Free SRS-Config */
5401       if(ulBwp->srs_Config)
5402       {
5403          if(ulBwp->srs_Config->choice.setup)
5404          {
5405             srsCfg = ulBwp->srs_Config->choice.setup;
5406
5407             /* Free Resource Set to add/mod list */
5408             if(srsCfg->srs_ResourceSetToAddModList)
5409             {
5410                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
5411                if(rsrcSetList->list.array)
5412                {
5413                   rSetIdx = 0;
5414
5415                   /* Free SRS resource Id list in this SRS resource set */
5416                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5417                   {
5418                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5419
5420                      if(rsrcIdList->list.array)
5421                      {
5422                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5423                         {
5424                            DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5425                         }
5426                         DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
5427                      }
5428                      DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5429                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5430                   }
5431
5432                   /* Free resource type info for this SRS resource set */
5433                   DU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5434                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5435
5436                   /* Free memory for each resource set */
5437                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5438                   {
5439                      DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5440                   }
5441                   DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
5442                }
5443                DU_FREE(srsCfg->srs_ResourceSetToAddModList, \
5444                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5445             }
5446
5447             /* Free resource to add/modd list */
5448             if(srsCfg->srs_ResourceToAddModList)
5449             {
5450                resourceList = srsCfg->srs_ResourceToAddModList;
5451                if(resourceList->list.array)
5452                {
5453                   rsrcIdx = 0;
5454                   DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
5455                         sizeof(struct SRS_Resource__transmissionComb__n2));
5456                   DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
5457                         sizeof(struct SRS_Resource__resourceType__aperiodic));
5458
5459                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5460                   {
5461                      DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5462                   }
5463                   DU_FREE(resourceList->list.array, resourceList->list.size);
5464                }
5465                DU_FREE(srsCfg->srs_ResourceToAddModList, \
5466                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
5467             }
5468
5469             DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5470          }
5471          DU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5472       }
5473    }
5474 }
5475 /*******************************************************************
5476  *
5477  * @brief Frees memory allocated for initialUplinkBWP
5478  *
5479  * @details
5480  *
5481  *    Function : FreeinitialUplinkBWP
5482  *
5483  *    Functionality: Deallocating memory of initialUplinkBWP
5484  *
5485  * @params[in] UplinkConfig_t *ulCfg
5486  *
5487  * @return void
5488  *
5489  *
5490  * ****************************************************************/
5491 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
5492 {
5493    BWP_UplinkDedicated_t *ulBwp=NULLP;
5494    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
5495
5496    if(ulCfg->initialUplinkBWP)
5497    {
5498       ulBwp=ulCfg->initialUplinkBWP;
5499       if(ulCfg->firstActiveUplinkBWP_Id)
5500       {
5501          if(ulCfg->pusch_ServingCellConfig)
5502          {
5503             puschCfg=ulCfg->pusch_ServingCellConfig;
5504             if(puschCfg->choice.setup)
5505             {
5506                if(puschCfg->choice.setup->ext1)
5507                {
5508                   DU_FREE(puschCfg->choice.setup->ext1->\
5509                         processingType2Enabled,sizeof(BOOLEAN_t));
5510                   DU_FREE(puschCfg->choice.setup->ext1->\
5511                         maxMIMO_Layers,sizeof(long));
5512                   DU_FREE(puschCfg->choice.setup->ext1, \
5513                         sizeof(struct PUSCH_ServingCellConfig__ext1));
5514                }
5515                DU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5516             }
5517             DU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5518          }
5519          DU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5520       }
5521       FreeInitialUlBWP(ulBwp);
5522       DU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5523    }
5524 }
5525 /*******************************************************************
5526  *
5527  * @brief Frees emmory allocated for BWPDlDedPdschCfg
5528  *
5529  * @details
5530  *
5531  *    Function : FreeBWPDlDedPdschCfg
5532  *
5533  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
5534  *
5535  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5536  *
5537  * @return void
5538  *
5539  *
5540  * ****************************************************************/
5541 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
5542 {
5543    struct PDSCH_Config *pdschCfg=NULLP;
5544    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
5545    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
5546    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
5547
5548    if(dlBwp->pdsch_Config->choice.setup)
5549    {
5550       pdschCfg=dlBwp->pdsch_Config->choice.setup;
5551       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
5552       {
5553          if(pdschCfg->pdsch_TimeDomainAllocationList)
5554          {
5555             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
5556             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
5557             {
5558                prbBndlType=&pdschCfg->prb_BundlingType;
5559                DU_FREE(prbBndlType->choice.staticBundling,\
5560                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
5561                DU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
5562             }
5563             FreePdschTimeDomAllocList(timeDomAllocList);
5564             DU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
5565                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
5566          }
5567          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
5568          if(dmrsDlCfg->choice.setup)
5569          {
5570             DU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
5571                   sizeof(long));
5572             DU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
5573          }
5574          DU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
5575                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
5576       }
5577       DU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
5578    }
5579 }
5580 /*******************************************************************
5581  *
5582  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
5583  *
5584  * @details
5585  *
5586  *    Function : FreeBWPDlDedPdcchCfg
5587  *
5588  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
5589  *
5590  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5591  *
5592  * @return void
5593  *
5594  *
5595  * ****************************************************************/
5596 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
5597 {
5598    uint8_t idx1=0;
5599    uint8_t idx2=0;
5600    struct PDCCH_Config *pdcchCfg=NULLP;
5601    struct ControlResourceSet *controlRSet=NULLP;
5602    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
5603
5604    if(dlBwp->pdcch_Config->choice.setup)
5605    {
5606       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
5607       if(pdcchCfg->controlResourceSetToAddModList)
5608       {
5609          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
5610          if(controlRSetList->list.array)
5611          {
5612             controlRSet = controlRSetList->list.array[idx2];
5613             if(controlRSet)
5614             {
5615                if(controlRSet->frequencyDomainResources.buf)
5616                {
5617                   if(controlRSet->pdcch_DMRS_ScramblingID)
5618                   {
5619                      if(pdcchCfg->searchSpacesToAddModList)
5620                      {
5621                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
5622                         DU_FREE(pdcchCfg->searchSpacesToAddModList, \
5623                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
5624                      }
5625                      DU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
5626                   }
5627                   DU_FREE(controlRSet->frequencyDomainResources.buf, \
5628                         controlRSet->frequencyDomainResources.size);
5629                }
5630             }
5631             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
5632             {
5633                DU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
5634             }
5635             DU_FREE(controlRSetList->list.array, controlRSetList->list.size);
5636          }
5637          DU_FREE(pdcchCfg->controlResourceSetToAddModList, \
5638                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
5639       }
5640       DU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
5641    }
5642 }
5643
5644 /*******************************************************************
5645  *
5646  * @brief Frees emmory allocated for DUToCURRCContainer
5647  *
5648  * @details
5649  *
5650  *    Function : FreeMemDuToCuRrcCont
5651  *
5652  *    Functionality: Deallocating memory of DuToCuRrcContainer
5653  *
5654  * @params[in] DuToCuRRCContainer, DuToCuRRCContainer
5655  *
5656  * @return ROK     - success
5657  *         RFAILED - failure
5658  *
5659  * ****************************************************************/
5660 uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg)
5661 {
5662    uint8_t idx=0;
5663    SpCellConfig_t *spCellCfg=NULLP;
5664    ServingCellConfig_t *srvCellCfg=NULLP;
5665    BWP_DownlinkDedicated_t *dlBwp=NULLP;
5666    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
5667    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
5668    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
5669    struct RLC_Config *rlcConfig=NULLP;
5670    struct LogicalChannelConfig *macLcConfig=NULLP;
5671    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
5672    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
5673    struct TAG_Config *tagConfig=NULLP;
5674    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
5675    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
5676    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
5677
5678    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
5679    if(rlcBearerList)
5680    {
5681       if(rlcBearerList->list.array)
5682       {
5683          for(idx=0; idx<rlcBearerList->list.count; idx++)
5684          {
5685             if(rlcBearerList->list.array[idx])
5686             {
5687                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
5688                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
5689                if(rlcConfig)
5690                {
5691                   if(rlcConfig->choice.am)
5692                   {
5693                      DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5694                      DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5695                      DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
5696                   }
5697                   DU_FREE(rlcConfig, sizeof(struct RLC_Config));
5698                }
5699                DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
5700                if(macLcConfig)
5701                {
5702                   if(macLcConfig->ul_SpecificParameters)
5703                   {
5704                      DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
5705                      DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
5706                      DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
5707                   }
5708                   DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
5709                }
5710                DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
5711             }
5712          }
5713          DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
5714       }
5715       DU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5716    }
5717
5718    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
5719    if(macCellGrpCfg)
5720    {
5721       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
5722       if(schedulingRequestConfig)
5723       {
5724          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
5725          if(schReqList)
5726          {
5727             if(schReqList->list.array)
5728             {
5729                for(idx=0;idx<schReqList->list.count; idx++)
5730                {
5731                   if(schReqList->list.array[idx])
5732                   {
5733                      DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
5734                      DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
5735                   }
5736                }
5737                DU_FREE(schReqList->list.array, schReqList->list.size);
5738             }
5739             DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
5740                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
5741             DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5742       }
5743       if(macCellGrpCfg->bsr_Config)
5744       {
5745          DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5746       }
5747       tagConfig = macCellGrpCfg->tag_Config;
5748       if(tagConfig)
5749       {
5750          tagList = tagConfig->tag_ToAddModList;
5751          if(tagList)
5752          {
5753             if(tagList->list.array)
5754             {
5755                for(idx=0; idx<tagList->list.count; idx++)
5756                {
5757                   DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
5758                }
5759                DU_FREE(tagList->list.array, tagList->list.size);
5760             }
5761             DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
5762          }
5763          DU_FREE(tagConfig, sizeof(struct TAG_Config));
5764       }
5765
5766       phrConfig = macCellGrpCfg->phr_Config;
5767       if(phrConfig)
5768       {
5769          DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
5770          DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
5771       }
5772
5773       DU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
5774    }
5775
5776    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
5777    if(phyCellGrpCfg)
5778    {
5779       DU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5780       DU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
5781    }
5782
5783    spCellCfg = cellGrpCfg->spCellConfig;
5784    if(spCellCfg)
5785    {
5786       if(spCellCfg->servCellIndex)
5787       {
5788          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
5789          {
5790             if(spCellCfg->spCellConfigDedicated)
5791             {
5792                srvCellCfg = spCellCfg->spCellConfigDedicated;
5793                if(srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
5794                {
5795                   if(srvCellCfg->initialDownlinkBWP)
5796                   {
5797                      dlBwp = srvCellCfg->initialDownlinkBWP;
5798                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
5799                      {
5800                         if(srvCellCfg->defaultDownlinkBWP_Id)
5801                         {
5802                            if(srvCellCfg->uplinkConfig)
5803                            {
5804                               if(srvCellCfg->pdsch_ServingCellConfig)
5805                               {
5806                                  pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
5807                                  if(pdschCfg->choice.setup)
5808                                  {
5809                                     DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
5810                                     DU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5811                                  }
5812                                  DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
5813                                           ServingCellConfig__pdsch_ServingCellConfig));
5814                               }
5815                               FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
5816                               DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
5817                            }
5818                            DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
5819                         }
5820                         DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
5821                      }
5822                      if(dlBwp->pdcch_Config)
5823                      {
5824                         if(dlBwp->pdsch_Config)
5825                         {
5826                            FreeBWPDlDedPdschCfg(dlBwp);
5827                            DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
5828                         }
5829                         FreeBWPDlDedPdcchCfg(dlBwp);
5830                         DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
5831                      }
5832                      DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
5833                   }
5834                   DU_FREE(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
5835                }
5836                DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5837             }
5838             DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5839          }
5840          DU_FREE(spCellCfg->servCellIndex, sizeof(long));
5841       }
5842       DU_FREE(spCellCfg,sizeof(SpCellConfig_t));
5843    }
5844    return ROK;
5845 }
5846 /*******************************************************************
5847  *
5848  * @brief Builds DU To CU RRC Container
5849  *
5850  * @details
5851  *
5852  *    Function : BuildDuToCuRrcContainer
5853  *
5854  *    Functionality: Builds DuToCuRrcContainer
5855  *
5856  * @params[in] idx, index in F1AP msg
5857  *             DuToCuRRCContainer, DuToCuRRCContainer
5858  *
5859  * @return ROK     - success
5860  *         RFAILED - failure
5861  *
5862  * ****************************************************************/
5863 uint8_t BuildDuToCuRrcContainer(DUtoCURRCContainer_t *duToCuRrcContainer)
5864 {
5865    uint8_t  ret = ROK;
5866    CellGroupConfigRrc_t  cellGrpCfg;
5867    asn_enc_rval_t        encRetVal;
5868    memset(&cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
5869    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
5870
5871    while(true)
5872    {
5873       cellGrpCfg.cellGroupId = CELL_GRP_ID;
5874
5875       cellGrpCfg.rlc_BearerToAddModList = NULLP;
5876       DU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5877       if(!cellGrpCfg.rlc_BearerToAddModList)
5878       {
5879          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5880          ret = RFAILED;
5881          break;
5882       }
5883       if(BuildRlcBearerToAddModList(cellGrpCfg.rlc_BearerToAddModList) != ROK)
5884       {
5885          DU_LOG("\nERROR  -->  F1AP : BuildRlcBearerToAddModList failed");
5886          ret = RFAILED;
5887          break;
5888       }
5889
5890       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
5891       cellGrpCfg.mac_CellGroupConfig = NULLP;
5892       DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
5893       if(!cellGrpCfg.mac_CellGroupConfig)
5894       {
5895          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5896          ret = RFAILED;
5897          break;
5898       }
5899       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
5900       {
5901          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
5902          ret = RFAILED;
5903          break;
5904       }
5905
5906       cellGrpCfg.physicalCellGroupConfig = NULLP;
5907       DU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
5908       if(!cellGrpCfg.physicalCellGroupConfig)
5909       {
5910          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5911          ret = RFAILED;
5912          break;
5913       }
5914       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
5915       {
5916          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
5917          ret = RFAILED;
5918          break;
5919       }
5920
5921       cellGrpCfg.spCellConfig = NULLP;
5922       DU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
5923       if(!cellGrpCfg.spCellConfig)
5924       {
5925          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5926          ret = RFAILED;
5927          break;
5928       }
5929       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
5930       {
5931          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
5932          ret = RFAILED;
5933          break;
5934       }
5935
5936       cellGrpCfg.sCellToAddModList = NULLP;
5937       cellGrpCfg.sCellToReleaseList = NULLP;
5938       cellGrpCfg.ext1 = NULLP;
5939
5940       /* encode cellGrpCfg into duToCuRrcContainer */
5941       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
5942       memset(encBuf, 0, ENC_BUF_MAX_LEN);
5943       encBufSize = 0;
5944       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
5945       /* Encode results */
5946       if(encRetVal.encoded == ENCODE_FAIL)
5947       {
5948          DU_LOG( "\nERROR  --> F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
5949                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5950          ret = RFAILED;
5951          break;
5952       }
5953       else
5954       {
5955          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
5956          for(int i=0; i< encBufSize; i++)
5957          {
5958             printf("%x",encBuf[i]);
5959          }
5960       }
5961
5962       duToCuRrcContainer->size = encBufSize;
5963       DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
5964       if(!duToCuRrcContainer->buf)
5965       {
5966          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
5967          ret = RFAILED;
5968          break;
5969       }
5970       if(ret == ROK)
5971       {
5972          memcpy(duToCuRrcContainer->buf, encBuf, duToCuRrcContainer->size);
5973       }
5974       break;
5975    }
5976    FreeMemDuToCuRrcCont(&cellGrpCfg);
5977    return ret;
5978 }
5979
5980 /*******************************************************************
5981  *
5982  * @brief Free memory allocated in InitialULRRCMessage
5983  *
5984  * @details
5985  *
5986  *    Function : freeInitUlRrcMsgTransfer
5987  *
5988  *    Functionality: Free memory allocated in InitialULRRCMessage
5989  *
5990  * @params[in]F1AP_PDU_t  *f1apMsg)
5991  *
5992  * @return ROK     - success
5993  *         RFAILED - failure
5994  *
5995  * ****************************************************************/
5996
5997 uint8_t freeInitUlRrcMsgTransfer(F1AP_PDU_t  *f1apMsg)
5998 {
5999    uint8_t ieIdx, arrIdx;
6000    InitialULRRCMessageTransfer_t *initULRRCMsg=NULLP;
6001
6002    if(f1apMsg)
6003    {
6004       if(f1apMsg->choice.initiatingMessage)
6005       {
6006          initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.\
6007             choice.InitialULRRCMessageTransfer;
6008          if(initULRRCMsg->protocolIEs.list.array)
6009          {
6010             for(ieIdx = 0; ieIdx < initULRRCMsg->protocolIEs.list.count; ieIdx++)
6011             {
6012                switch(initULRRCMsg->protocolIEs.list.array[ieIdx]->id)
6013                {
6014                   case ProtocolIE_ID_id_NRCGI:
6015                   {
6016                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf)
6017                      {
6018                         if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf)
6019                         {
6020                            DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf,\
6021                            initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.size);
6022                         }
6023                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf,\
6024                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.size);
6025                      }
6026                      break;
6027                   }
6028                   case ProtocolIE_ID_id_RRCContainer:
6029                   {
6030                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
6031                      {
6032                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,\
6033                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
6034                      }
6035                      break;
6036                   }
6037                   case ProtocolIE_ID_id_DUtoCURRCContainer:
6038                   {
6039                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf)
6040                      {
6041                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf,
6042                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.size);
6043                      }
6044                      break;
6045                   }
6046                   default:
6047                      break;
6048                }
6049              }
6050              for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
6051              {
6052                 if(initULRRCMsg->protocolIEs.list.array[arrIdx])
6053                 {
6054                    DU_FREE(initULRRCMsg->protocolIEs.list.array[arrIdx],\
6055                       sizeof(InitialULRRCMessageTransferIEs_t));
6056                 }
6057              }
6058              DU_FREE(initULRRCMsg->protocolIEs.list.array, initULRRCMsg->protocolIEs.list.size);
6059           }
6060          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
6061       }
6062       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
6063    }
6064    else
6065    {
6066       DU_LOG("\nERROR  -->  DU_APP : Recevied F1ap Pdu is null at freeInitUlRrcMsgTransfer()");
6067       return RFAILED;
6068    }
6069    return ROK;
6070 }
6071
6072 /*******************************************************************
6073  *
6074  * @brief Builds and sends the InitialULRRCMessage
6075  *
6076  * @details
6077  *
6078  *    Function : BuildAndSendInitialRrcMsgTransfer
6079  *
6080  *    Functionality: Constructs the Initial UL RRC Message Transfer and sends
6081  *                   it to the CU through SCTP.
6082  *
6083  * @params[in]
6084  *
6085  * @return ROK     - success
6086  *         RFAILED - failure
6087  *
6088  * ****************************************************************/
6089 uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti,
6090       uint16_t rrcContSize, uint8_t *rrcContainer)
6091 {
6092    uint8_t   ret;
6093    uint8_t   elementCnt;
6094    uint8_t   ieIdx;
6095    asn_enc_rval_t  encRetVal;
6096    F1AP_PDU_t  *f1apMsg = NULLP;
6097    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
6098    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
6099
6100    while(true)
6101    {
6102       DU_LOG("\n INFO   -->  F1AP : Building RRC Setup Request\n");
6103       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
6104       if(f1apMsg == NULLP)
6105       {
6106          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
6107          break;
6108       }
6109       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
6110       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
6111       if(f1apMsg->choice.initiatingMessage == NULLP)
6112       {
6113          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
6114          break;
6115       }
6116       f1apMsg->choice.initiatingMessage->procedureCode =\
6117                                                         ProcedureCode_id_InitialULRRCMessageTransfer;
6118       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
6119       f1apMsg->choice.initiatingMessage->value.present = \
6120                                                          InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
6121       initULRRCMsg =\
6122                     &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
6123       elementCnt = 5;
6124       initULRRCMsg->protocolIEs.list.count = elementCnt;
6125       initULRRCMsg->protocolIEs.list.size = \
6126                                             elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *);
6127       /* Initialize the F1Setup members */
6128       DU_ALLOC(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
6129       if(initULRRCMsg->protocolIEs.list.array == NULLP)
6130       {
6131          DU_LOG(" ERROR  -->  F1AP : Memory allocation for\
6132                RRCSetupRequestMessageTransferIEs failed");
6133          break;
6134       }
6135       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
6136       {
6137          DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx],\
6138                sizeof(InitialULRRCMessageTransferIEs_t));
6139          if(initULRRCMsg->protocolIEs.list.array[ieIdx] == NULLP)
6140          {
6141             break;
6142          }
6143       }
6144       ieIdx = 0;
6145       /*GNB DU UE F1AP ID*/
6146       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6147                                                         ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
6148       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  = Criticality_reject;
6149       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
6150                                                                   InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
6151       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
6152
6153
6154       /*NRCGI*/
6155       ieIdx++;
6156       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6157                                                         ProtocolIE_ID_id_NRCGI;
6158       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  =Criticality_reject;
6159       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
6160                                                                   InitialULRRCMessageTransferIEs__value_PR_NRCGI;
6161
6162       ret =\
6163            BuildNrcgi(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
6164       if(ret!=ROK)
6165       {
6166          break;
6167       }
6168
6169       /*CRNTI*/
6170       ieIdx++;
6171       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6172                                                         ProtocolIE_ID_id_C_RNTI;
6173       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6174       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6175                                                                  InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
6176       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.C_RNTI = crnti;
6177
6178       /*RRCContainer*/
6179       ieIdx++;
6180       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6181                                                         ProtocolIE_ID_id_RRCContainer;
6182       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6183       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6184                                                                  InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
6185
6186       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = rrcContSize;
6187       DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
6188             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size)
6189       if(!initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
6190       {
6191          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
6192          break;
6193
6194       }
6195       memcpy(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, rrcContainer,
6196             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
6197
6198
6199       /*DUtoCURRCContainer*/
6200       ieIdx++;
6201       initULRRCMsg->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCContainer;
6202       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6203       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6204                                                                  InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
6205
6206       ret = BuildDuToCuRrcContainer(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer);
6207       if(ret != ROK)
6208       {
6209          break;
6210       }
6211
6212       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
6213
6214       /* Encode the F1SetupRequest type as APER */
6215       memset(encBuf, 0, ENC_BUF_MAX_LEN);
6216       encBufSize = 0;
6217       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
6218       /* Encode results */
6219       if(encRetVal.encoded == ENCODE_FAIL)
6220       {
6221          DU_LOG( "\nERROR  --> F1AP : Could not encode Initial UL RRC Message Transfer\
6222                structure (at %s)\n",encRetVal.failed_type ? \
6223                encRetVal.failed_type->name : "unknown");
6224          ret = RFAILED;
6225          break;
6226       }
6227       else
6228       {
6229
6230          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for Initial UL RRC\
6231                Message transfer\n");
6232          for(int i=0; i< encBufSize; i++)
6233          {
6234             printf("%x",encBuf[i]);
6235          }
6236       }
6237       /* Sending  msg  */
6238       if(sendF1APMsg() != ROK)
6239       {
6240          DU_LOG("\nERROR  -->  F1AP : Sending Initial UL RRC Message Transfer Failed");
6241          ret = RFAILED;
6242          break;
6243       }
6244       break;
6245    }
6246    freeInitUlRrcMsgTransfer(f1apMsg);
6247    return ret;
6248 }/* End of BuildAndSendInitialRrcMsgTransfer*/
6249
6250 /*****  UE SETUP REQUEST *****/
6251
6252 /*******************************************************************
6253  *
6254  * @brief Free Qos And Snssai Drb Info
6255  *
6256  * @details
6257  *
6258  *    Function : freeDrbQosAndSnssaiInfo
6259  *
6260  *    Functionality: Free Qos And Snssai Drb Info
6261  *
6262  * @params[in] LcCfg *lcCfg,
6263  * @return void
6264  *
6265  * ****************************************************************/
6266 void freeDrbQosAndSnssaiInfo(LcCfg *lcCfg)
6267 {
6268    if(lcCfg->snssai)
6269    {
6270       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6271    }
6272    if(lcCfg->drbQos)
6273    {
6274       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
6275    }
6276 }
6277
6278 /******************************************************************
6279 *
6280 * @brief Function to delete the RLC Lc cfg from UE APP DB
6281 *
6282 * @details
6283 *
6284 *  Function : freeRlcLcCfg
6285 *
6286 *  Functionality: Function to delete the RLC Lc cfg from UE APP DB
6287 *
6288 *
6289  *****************************************************************/
6290
6291 void freeRlcLcCfg(RlcBearerCfg *lcCfg)
6292 {
6293    switch(lcCfg->rlcMode)
6294    {
6295       case RLC_AM :
6296          {
6297             if(lcCfg->u.amCfg)
6298             {
6299                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.amCfg, sizeof(AmBearerCfg));
6300             }
6301             break;
6302          }
6303       case RLC_UM_BI_DIRECTIONAL :
6304          {
6305             if(lcCfg->u.umBiDirCfg)
6306             {
6307                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
6308             }
6309             break;
6310          }
6311       case RLC_UM_UNI_DIRECTIONAL_UL :
6312          {
6313             if(lcCfg->u.umUniDirUlCfg)
6314             {
6315                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
6316             }
6317             break;
6318
6319          }
6320       case RLC_UM_UNI_DIRECTIONAL_DL :
6321          {
6322             if(lcCfg->u.umUniDirDlCfg)
6323             {
6324                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
6325             }
6326             break;
6327          }
6328       default:
6329          DU_LOG("\nERROR  -->  DU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
6330          break;
6331    }
6332 }
6333
6334 /*******************************************************************
6335  *
6336  * @brief Function to free MacLcCfg
6337  *
6338  * @details
6339  *
6340  *    Function : freeMacLcCfg
6341  *
6342  *    Functionality: Function to free MacLcCfg
6343  *
6344  * @params[in] LcCfg *lcCfg,
6345  * @return void
6346  *
6347  * ****************************************************************/
6348
6349 void  freeMacLcCfg(LcCfg *lcCfg)
6350 {
6351     /* Deleting DRBQOS */
6352    if(lcCfg->drbQos)
6353    {
6354       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
6355    }
6356    /* Deleting SNSSAI */
6357    if(lcCfg->snssai)
6358    {
6359       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6360    }
6361 }
6362 /*******************************************************************
6363  *
6364  * @brief Free UE NR Capability received in UE Context setup request
6365  *
6366  * @details
6367  *
6368  *    Function : freeAperDecodeUeNrCapability
6369  *
6370  *    Functionality:
6371  *       Free UE NR Capability received in UE Context setup request
6372  *
6373  * @params[in]
6374  * @return ROK     - success
6375  *         RFAILED - failure
6376  *
6377  * ****************************************************************/
6378 void freeAperDecodeUeNrCapability(void *ueNrCapability)
6379 {
6380    uint8_t arrIdx =0;
6381    FeatureSets_t *featureSets =NULLP;
6382    UE_NR_Capability_t *ueNrCap = (UE_NR_Capability_t *)ueNrCapability;
6383
6384    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
6385    {
6386       for(arrIdx = 0; arrIdx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; arrIdx++)
6387       {
6388          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx])
6389             free(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx]);
6390       }
6391       free(ueNrCap->rf_Parameters.supportedBandListNR.list.array);
6392    }
6393
6394    if(ueNrCap->featureSets)
6395    {
6396       featureSets = ueNrCap->featureSets;
6397       if(featureSets->featureSetsDownlinkPerCC)
6398       {
6399          if(featureSets->featureSetsDownlinkPerCC->list.array)
6400          {
6401             for(arrIdx = 0; arrIdx < featureSets->featureSetsDownlinkPerCC->list.count; arrIdx++)
6402             {
6403                if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx])
6404                {
6405                   if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL)
6406                      free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL);
6407                   free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]);
6408                }
6409             }
6410             free(featureSets->featureSetsDownlinkPerCC->list.array);
6411          }
6412          free(featureSets->featureSetsDownlinkPerCC);
6413       }
6414       if(featureSets->featureSetsUplinkPerCC)
6415       {
6416          if(featureSets->featureSetsUplinkPerCC->list.array)
6417          {
6418             for(arrIdx = 0; arrIdx < featureSets->featureSetsUplinkPerCC->list.count; arrIdx++)
6419             {
6420                if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx])
6421                {
6422                   if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL)
6423                      free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL);
6424                   free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]);
6425                }
6426             }
6427             free(featureSets->featureSetsUplinkPerCC->list.array);
6428          }
6429          free(featureSets->featureSetsUplinkPerCC);
6430       }
6431       free(ueNrCap->featureSets);
6432    }
6433 }
6434
6435 /*******************************************************************
6436 *
6437 * @brief Function to free PdcchSearchSpcToAddModList
6438          where memory allocated by aper_decoder
6439 *
6440 * @details
6441 *
6442 *    Function : freeAperDecodePdcchSearchSpcToAddModList
6443 *
6444 *    Functionality: Function to free PdcchSearchSpcToAddModList
6445 *
6446 * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
6447 * @return void
6448 *
6449 * ****************************************************************/
6450
6451 void freeAperDecodePdcchSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
6452 {
6453    uint8_t searchSpcArrIdx=0;
6454    uint8_t searchSpcArrIdx1=0;
6455    struct  SearchSpace *searchSpc=NULLP;
6456
6457
6458    if(searchSpcList->list.array)
6459    {
6460       if(searchSpcList->list.array[searchSpcArrIdx1])
6461       {
6462          searchSpc = searchSpcList->list.array[searchSpcArrIdx1];
6463          if(searchSpc->controlResourceSetId)
6464          {
6465             if(searchSpc->monitoringSlotPeriodicityAndOffset)
6466             {
6467                if(searchSpc->monitoringSymbolsWithinSlot)
6468                {
6469                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
6470                   {
6471                      if(searchSpc->nrofCandidates)
6472                      {
6473                         if(searchSpc->searchSpaceType)
6474                         {
6475                            free(searchSpc->searchSpaceType->choice.ue_Specific);
6476                            free(searchSpc->searchSpaceType);
6477                         }
6478                         free(searchSpc->nrofCandidates);
6479                      }
6480                      free(searchSpc->monitoringSymbolsWithinSlot->buf);
6481                   }
6482                   free(searchSpc->monitoringSymbolsWithinSlot);
6483                }
6484                free(searchSpc->monitoringSlotPeriodicityAndOffset);
6485             }
6486             free(searchSpc->controlResourceSetId);
6487          }
6488       }
6489       for(searchSpcArrIdx = 0; searchSpcArrIdx < searchSpcList->list.count; searchSpcArrIdx++)
6490       {
6491          free(searchSpcList->list.array[searchSpcArrIdx]);
6492       }
6493       free(searchSpcList->list.array);
6494    }
6495 }
6496 /*******************************************************************
6497 *
6498 * @brief Function for free part for the memory allocated by aper_decoder
6499 *
6500 * @details
6501 *
6502 *    Function : freeAperDecodeBWPDlDedPdcchConfig
6503 *
6504 *    Functionality: Function to free BWPDlDedPdcchConfig
6505 *
6506 * @params[in]
6507 * @return void
6508 *
6509 * ****************************************************************/
6510
6511
6512 void freeAperDecodeBWPDlDedPdcchConfig(BWP_DownlinkDedicated_t *dlBwp)
6513 {
6514    uint8_t arrIdx1=0;
6515    uint8_t arrIdx2=0;
6516    struct PDCCH_Config *pdcchCfg=NULLP;
6517    struct ControlResourceSet *controlRSet=NULLP;
6518    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
6519
6520    if(dlBwp->pdcch_Config->choice.setup)
6521    {
6522       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
6523       if(pdcchCfg->controlResourceSetToAddModList)
6524       {
6525          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
6526          if(controlRSetList->list.array)
6527          {
6528             controlRSet = controlRSetList->list.array[arrIdx2];
6529             if(controlRSet)
6530             {
6531                if(controlRSet->frequencyDomainResources.buf)
6532                {
6533                   if(controlRSet->pdcch_DMRS_ScramblingID)
6534                   {
6535                      if(pdcchCfg->searchSpacesToAddModList)
6536                      {
6537                         freeAperDecodePdcchSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
6538                         free(pdcchCfg->searchSpacesToAddModList);
6539                      }
6540                      free(controlRSet->pdcch_DMRS_ScramblingID);
6541                   }
6542                   free(controlRSet->frequencyDomainResources.buf);
6543                }
6544             }
6545             for(arrIdx1 = 0; arrIdx1 <controlRSetList->list.count; arrIdx1++)
6546             {
6547                free(controlRSetList->list.array[arrIdx1]);
6548             }
6549             free(controlRSetList->list.array);
6550          }
6551          free(pdcchCfg->controlResourceSetToAddModList);
6552       }
6553       free(dlBwp->pdcch_Config->choice.setup);
6554    }
6555 }
6556 /*******************************************************************
6557 *
6558 * @brief Function to free PdschTimeDomAllocationList
6559 *     where the memory allocated by aper_decoder
6560 *
6561 * @details
6562 *
6563 *    Function : freeAperDecodePdschTimeDomAllocationList
6564 *
6565 *    Functionality: Function to free PdschTimeDomAllocationList
6566 *
6567 * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
6568 * @return void
6569 *
6570 * ****************************************************************/
6571
6572
6573 void freeAperDecodePdschTimeDomAllocationList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
6574 {
6575    uint8_t arrIdx=0;
6576
6577    if(timeDomAllocList->choice.setup)
6578    {
6579       if(timeDomAllocList->choice.setup->list.array)
6580       {
6581          for(arrIdx = 0; arrIdx <timeDomAllocList->choice.setup->list.count ; arrIdx++)
6582          {
6583             free(timeDomAllocList->choice.setup->list.array[arrIdx]);
6584          }
6585          free(timeDomAllocList->choice.setup->list.array);
6586       }
6587       free(timeDomAllocList->choice.setup);
6588    }
6589 }
6590
6591 /*******************************************************************
6592 *
6593 * @brief Function to free BWPDlDedPdschConfig
6594 *        where the memory allocated by aper_decoder
6595 *
6596 * @details
6597 *
6598 *    Function : freeAperDecodeBWPDlDedPdschConfig
6599 *
6600 *    Functionality: Function to free BWPDlDedPdschConfig
6601 *
6602 * @params[in] BWP_DownlinkDedicated_t *dlBwp
6603 * @return void
6604 *
6605 * ****************************************************************/
6606
6607
6608 void freeAperDecodeBWPDlDedPdschConfig(BWP_DownlinkDedicated_t *dlBwp)
6609 {
6610    struct PDSCH_Config *pdschCfg=NULLP;
6611    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
6612    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
6613    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
6614
6615    if(dlBwp->pdsch_Config->choice.setup)
6616    {
6617       pdschCfg=dlBwp->pdsch_Config->choice.setup;
6618       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
6619       {
6620          if(pdschCfg->pdsch_TimeDomainAllocationList)
6621          {
6622             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
6623             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
6624             {
6625                prbBndlType=&pdschCfg->prb_BundlingType;
6626                free(prbBndlType->choice.staticBundling);
6627                free(pdschCfg->maxNrofCodeWordsScheduledByDCI);
6628             }
6629             freeAperDecodePdschTimeDomAllocationList(timeDomAllocList);
6630             free(pdschCfg->pdsch_TimeDomainAllocationList);
6631          }
6632          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
6633          if(dmrsDlCfg->choice.setup)
6634          {
6635             free(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition);
6636             free(dmrsDlCfg->choice.setup);
6637          }
6638          free(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA);
6639       }
6640       free(dlBwp->pdsch_Config->choice.setup);
6641    }
6642 }
6643 /*******************************************************************
6644 *
6645 * @brief Function to free PuschTimeDomAllocListCfg
6646                  where the memory allocated by aper_decoder
6647 *
6648 * @details
6649 *
6650 *    Function : freeAperDecodePuschTimeDomAllocListCfg
6651 *
6652 *    Functionality: Function to free PuschTimeDomAllocListCfg
6653 *
6654 * @params[in] PUSCH_Config_t *puschCfg
6655 * @return void
6656 *
6657 * ****************************************************************/
6658
6659
6660 void freeAperDecodePuschTimeDomAllocListCfg(PUSCH_Config_t *puschCfg)
6661 {
6662    uint8_t arrIdx=0;
6663    uint8_t arrIdx1=0;
6664    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
6665
6666    if(puschCfg->pusch_TimeDomainAllocationList)
6667    {
6668       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
6669       if(timeDomAllocList_t->choice.setup)
6670       {
6671          if(timeDomAllocList_t->choice.setup->list.array)
6672          {
6673             free(timeDomAllocList_t->choice.setup->list.array[arrIdx1]->k2);
6674             for(arrIdx = 0; arrIdx<timeDomAllocList_t->choice.setup->list.count; arrIdx++)
6675             {
6676                free(timeDomAllocList_t->choice.setup->list.array[arrIdx]);
6677             }
6678             free(timeDomAllocList_t->choice.setup->list.array);
6679          }
6680          free(timeDomAllocList_t->choice.setup);
6681       }
6682       free(puschCfg->transformPrecoder);
6683       free(puschCfg->pusch_TimeDomainAllocationList);
6684    }
6685 }
6686 /*******************************************************************
6687 *
6688 * @brief Function to free InitialUlBWPConfig where memory allocated by aper_decoder
6689 *
6690 * @details
6691 *
6692 *    Function : freeAperDecodeInitialUlBWPConfig
6693 *
6694 *    Functionality: Function to free InitialUlBWPConfig
6695 *
6696 * @params[in]  BWP_UplinkDedicated_t *ulBwp
6697 * @return void
6698 *
6699 * ****************************************************************/
6700
6701
6702 void freeAperDecodeInitialUlBWPConfig(BWP_UplinkDedicated_t *ulBwp)
6703 {
6704    uint8_t  rSetIdx =0;
6705    uint8_t  rsrcIdx =0;
6706    SRS_Config_t   *srsCfg = NULLP;
6707    PUSCH_Config_t *puschCfg = NULLP;
6708    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
6709    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
6710    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
6711    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
6712
6713    if(ulBwp->pusch_Config)
6714    {
6715       if(ulBwp->pusch_Config->choice.setup)
6716       {
6717          puschCfg=ulBwp->pusch_Config->choice.setup;
6718          if(puschCfg->dataScramblingIdentityPUSCH)
6719          {
6720             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
6721             {
6722                freeAperDecodePuschTimeDomAllocListCfg(puschCfg);
6723                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
6724                if(dmrsUlCfg->choice.setup)
6725                {
6726                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
6727                   {
6728                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
6729                      {
6730                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0);
6731                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled);
6732                      }
6733                      free(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition);
6734                   }
6735                   free(dmrsUlCfg->choice.setup);
6736                }
6737                free(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA);
6738             }
6739             free(puschCfg->dataScramblingIdentityPUSCH);
6740          }
6741          free(ulBwp->pusch_Config->choice.setup);
6742       }
6743       free(ulBwp->pusch_Config);
6744
6745       /* Free SRS-Config */
6746       if(ulBwp->srs_Config)
6747       {
6748          if(ulBwp->srs_Config->choice.setup)
6749          {
6750             srsCfg = ulBwp->srs_Config->choice.setup;
6751
6752             /* Free Resource Set to add/mod list */
6753             if(srsCfg->srs_ResourceSetToAddModList)
6754             {
6755                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
6756                if(rsrcSetList->list.array)
6757                {
6758                   rSetIdx = 0;
6759
6760                   /* Free SRS resource Id list in this SRS resource set */
6761                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
6762                   {
6763                      rsrcIdList =
6764                         rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
6765
6766                      if(rsrcIdList->list.array)
6767                      {
6768                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count;
6769                               rsrcIdx++)
6770                         {
6771                            free(rsrcIdList->list.array[rsrcIdx]);
6772                         }
6773                         free(rsrcIdList->list.array);
6774                      }
6775                      free(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList);
6776                   }
6777
6778                   /* Free resource type info for this SRS resource set */
6779
6780                   free(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic);
6781
6782                   /* Free memory for each resource set */
6783                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
6784                   {
6785                      free(rsrcSetList->list.array[rSetIdx]);
6786                   }
6787                   free(rsrcSetList->list.array);
6788                }
6789                free(srsCfg->srs_ResourceSetToAddModList);
6790             }
6791
6792             /* Free resource to add/modd list */
6793             if(srsCfg->srs_ResourceToAddModList)
6794             {
6795                resourceList = srsCfg->srs_ResourceToAddModList;
6796                if(resourceList->list.array)
6797                {
6798                   rsrcIdx = 0;
6799
6800                   free(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2);
6801                   free(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic);
6802
6803                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
6804                   {
6805                      free(resourceList->list.array[rsrcIdx]);
6806                   }
6807                   free(resourceList->list.array);
6808                }
6809                free(srsCfg->srs_ResourceToAddModList);
6810             }
6811
6812             free(ulBwp->srs_Config->choice.setup);
6813          }
6814          free(ulBwp->srs_Config);
6815       }
6816    }
6817 }
6818 /*******************************************************************
6819 *
6820 * @brief Function to free initialUplinkBWPConfig where memory allocated by aper_decoder
6821 *
6822 * @details
6823 *
6824 *    Function : freeAperDecodeinitialUplinkBWPConfig
6825 *
6826 *    Functionality: Function to free initialUplinkBWPConfig
6827 *
6828 * @params[in] UplinkConfig_t *ulCfg
6829 * @return void
6830 *
6831 * ****************************************************************/
6832
6833
6834 void freeAperDecodeinitialUplinkBWPConfig(UplinkConfig_t *ulCfg)
6835 {
6836    BWP_UplinkDedicated_t *ulBwp=NULLP;
6837    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
6838
6839    if(ulCfg->initialUplinkBWP)
6840    {
6841       ulBwp=ulCfg->initialUplinkBWP;
6842       if(ulCfg->firstActiveUplinkBWP_Id)
6843       {
6844          if(ulCfg->pusch_ServingCellConfig)
6845          {
6846             puschCfg=ulCfg->pusch_ServingCellConfig;
6847             if(puschCfg->choice.setup)
6848             {
6849                if(puschCfg->choice.setup->ext1)
6850                {
6851                   free(puschCfg->choice.setup->ext1->processingType2Enabled);
6852                   free(puschCfg->choice.setup->ext1->maxMIMO_Layers);
6853                   free(puschCfg->choice.setup->ext1);
6854                }
6855                free(puschCfg->choice.setup);
6856             }
6857             free(ulCfg->pusch_ServingCellConfig);
6858          }
6859          free(ulCfg->firstActiveUplinkBWP_Id);
6860       }
6861       freeAperDecodeInitialUlBWPConfig(ulBwp);
6862       free(ulCfg->initialUplinkBWP);
6863    }
6864 }
6865
6866 /*******************************************************************
6867  *
6868  * @brief Function to free DuUeCfg
6869  *
6870  * @details
6871  *
6872  *    Function : freeDuUeCfg
6873  *
6874  *    Functionality: Function to free DuUeCfg
6875  *
6876  * @params[in] DuUeCfg *ueCfg
6877  * @return void
6878  *
6879  * ****************************************************************/
6880 void freeDuUeCfg(DuUeCfg *ueCfg)
6881 {
6882    uint8_t lcIdx = 0;
6883    uint8_t arrIdx = 0;
6884    SpCellConfig_t *spCellCfg = NULLP;
6885    ServingCellConfig_t *srvCellCfg = NULLP;
6886    BWP_DownlinkDedicated_t *dlBwp = NULLP;
6887    MAC_CellGroupConfig_t *macCellGrpCfg = NULLP;
6888    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
6889    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList = NULLP;
6890    struct RLC_Config *rlcConfig = NULLP;
6891    struct LogicalChannelConfig *macLcConfig = NULLP;
6892    struct SchedulingRequestConfig *schedulingRequestConfig = NULLP;
6893    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList = NULLP;
6894    struct TAG_Config *tagConfig = NULLP;
6895    struct TAG_Config__tag_ToAddModList *tagList = NULLP;
6896    struct MAC_CellGroupConfig__phr_Config *phrConfig = NULLP;
6897    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg = NULLP;
6898    CellGroupConfigRrc_t *cellGrpCfg = ueCfg->cellGrpCfg;
6899
6900    if(ueCfg->ueNrCapability)
6901    {
6902       freeAperDecodeUeNrCapability(ueCfg->ueNrCapability);
6903       DU_FREE(ueCfg->ueNrCapability, sizeof(UE_NR_Capability_t));
6904       ueCfg->ueNrCapability = NULLP;
6905    }
6906
6907    if(ueCfg->cellGrpCfg)
6908    {
6909
6910       rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6911       if(rlcBearerList)
6912       {
6913          if(rlcBearerList->list.array)
6914          {
6915             for(arrIdx=0; arrIdx<rlcBearerList->list.count; arrIdx++)
6916             {
6917                if(rlcBearerList->list.array[arrIdx])
6918                {
6919                   rlcConfig   = rlcBearerList->list.array[arrIdx]->rlc_Config;
6920                   macLcConfig = rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig;
6921
6922                   if(rlcBearerList->list.array[arrIdx]->servedRadioBearer)
6923                   {
6924                      free(rlcBearerList->list.array[arrIdx]->servedRadioBearer);
6925                   }
6926                   if(rlcConfig)
6927                   {
6928                      if(rlcConfig->choice.am)
6929                      {
6930                         free(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength);
6931                         free(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength);
6932                         free(rlcConfig->choice.am);
6933                      }
6934                      free(rlcBearerList->list.array[arrIdx]->rlc_Config);
6935                   }
6936                   if(macLcConfig)
6937                   {
6938                      if(macLcConfig->ul_SpecificParameters)
6939                      {
6940                         free(macLcConfig->ul_SpecificParameters->schedulingRequestID);
6941                         free(macLcConfig->ul_SpecificParameters->logicalChannelGroup);
6942                         free(macLcConfig->ul_SpecificParameters);
6943                      }
6944                      free(rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig);
6945                   }
6946                   free(rlcBearerList->list.array[arrIdx]);
6947                }
6948             }
6949             free(rlcBearerList->list.array);
6950          }
6951          free(cellGrpCfg->rlc_BearerToAddModList);
6952       }
6953
6954       macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
6955       if(macCellGrpCfg)
6956       {
6957          schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
6958          if(schedulingRequestConfig)
6959          {
6960             schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
6961             if(schReqList)
6962             {
6963                if(schReqList->list.array)
6964                {
6965                   for(arrIdx=0;arrIdx<schReqList->list.count; arrIdx++)
6966                   {
6967                      if(schReqList->list.array[arrIdx])
6968                      {
6969                         free(schReqList->list.array[arrIdx]->sr_ProhibitTimer);
6970                         free(schReqList->list.array[arrIdx]);
6971                      }
6972                   }
6973                   free(schReqList->list.array);
6974                }
6975                free(schedulingRequestConfig->schedulingRequestToAddModList);
6976             }
6977             free(macCellGrpCfg->schedulingRequestConfig);
6978          }
6979          if(macCellGrpCfg->bsr_Config)
6980          {
6981             free(macCellGrpCfg->bsr_Config);
6982          }
6983          tagConfig = macCellGrpCfg->tag_Config;
6984          if(tagConfig)
6985          {
6986             tagList = tagConfig->tag_ToAddModList;
6987             if(tagList)
6988             {
6989                if(tagList->list.array)
6990                {
6991                   for(arrIdx=0; arrIdx<tagList->list.count; arrIdx++)
6992                   {
6993                      free(tagList->list.array[arrIdx]);
6994                   }
6995                   free(tagList->list.array);
6996                }
6997                free(tagConfig->tag_ToAddModList);
6998             }
6999             free(tagConfig);
7000          }
7001
7002          phrConfig = macCellGrpCfg->phr_Config;
7003          if(phrConfig)
7004          {
7005             free(phrConfig->choice.setup);
7006             free(phrConfig);
7007          }
7008
7009          free(macCellGrpCfg);
7010       }
7011
7012       phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
7013       if(phyCellGrpCfg)
7014       {
7015          free(phyCellGrpCfg->p_NR_FR1);
7016          free(phyCellGrpCfg);
7017       }
7018
7019       spCellCfg = cellGrpCfg->spCellConfig;
7020       if(spCellCfg)
7021       {
7022          if(spCellCfg->servCellIndex)
7023          {
7024             if(spCellCfg->rlmInSyncOutOfSyncThreshold)
7025             {
7026                if(spCellCfg->spCellConfigDedicated)
7027                {
7028                   srvCellCfg = spCellCfg->spCellConfigDedicated;
7029                   if(srvCellCfg->initialDownlinkBWP)
7030                   {
7031                      dlBwp = srvCellCfg->initialDownlinkBWP;
7032                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
7033                      {
7034                         if(srvCellCfg->defaultDownlinkBWP_Id)
7035                         {
7036                            if(srvCellCfg->uplinkConfig)
7037                            {
7038
7039                               if(srvCellCfg->pdsch_ServingCellConfig)
7040                               {
7041                                  pdschCfg=
7042                                     srvCellCfg->pdsch_ServingCellConfig;
7043                                  if(pdschCfg->choice.setup)
7044                                  {
7045
7046                                     free(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH);
7047                                     free(pdschCfg->choice.setup);
7048                                  }
7049
7050                                  free(srvCellCfg->pdsch_ServingCellConfig);
7051                               }
7052
7053                               freeAperDecodeinitialUplinkBWPConfig(srvCellCfg->uplinkConfig);
7054                               free(srvCellCfg->uplinkConfig);
7055                            }
7056                            free(srvCellCfg->defaultDownlinkBWP_Id);
7057                         }
7058
7059                         free(srvCellCfg->firstActiveDownlinkBWP_Id);
7060                      }
7061                      if(dlBwp->pdcch_Config)
7062                      {
7063                         if(dlBwp->pdsch_Config)
7064                         {
7065                            freeAperDecodeBWPDlDedPdschConfig(dlBwp);
7066                            free(dlBwp->pdsch_Config);
7067                         }
7068                         freeAperDecodeBWPDlDedPdcchConfig(dlBwp);
7069                         free(dlBwp->pdcch_Config);
7070                      }
7071                      free(srvCellCfg->initialDownlinkBWP);
7072                   }
7073
7074                   free(spCellCfg->spCellConfigDedicated);
7075                }
7076                free(spCellCfg->rlmInSyncOutOfSyncThreshold);
7077             }
7078             free(spCellCfg->servCellIndex);
7079          }
7080          free(spCellCfg);
7081       }
7082       DU_FREE(ueCfg->cellGrpCfg, sizeof(CellGroupConfigRrc_t));
7083       ueCfg->cellGrpCfg = NULLP;
7084    }
7085    if(ueCfg->ambrCfg)
7086    {
7087       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->ambrCfg, sizeof(AmbrCfg));
7088    }
7089    for(lcIdx = 0; lcIdx < ueCfg->numRlcLcs; lcIdx++)
7090    {
7091       freeRlcLcCfg(&ueCfg->rlcLcCfg[lcIdx]);
7092    }
7093    for(lcIdx = 0; lcIdx < ueCfg->numMacLcs; lcIdx++)
7094    {
7095       freeMacLcCfg(&ueCfg->macLcCfg[lcIdx]);
7096    }
7097    for(lcIdx = 0; lcIdx < ueCfg->numDrb; lcIdx++)
7098    {
7099       DU_FREE(ueCfg->upTnlInfo[lcIdx].tnlCfg1, sizeof(GtpTnlCfg));
7100    }
7101 }
7102
7103 /*******************************************************************
7104  *
7105  * @brief Function to free UecontextSetupDb
7106  *
7107  * @details
7108  *
7109  *    Function : freeF1UeDb
7110  *
7111  *    Functionality: Function to free UecontextSetupDb
7112  *
7113  * @params[in] UecontextSetupDb *
7114  * @return void
7115  *
7116  * ****************************************************************/
7117
7118 void freeF1UeDb(F1UeContextSetupDb *f1UeDb)
7119 {
7120
7121    if(f1UeDb->dlRrcMsg)
7122    {
7123       if(f1UeDb->dlRrcMsg->rrcMsgPdu)
7124       {
7125         //DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,\
7126                f1UeDb->dlRrcMsg->rrcMsgPdu, f1UeDb->dlRrcMsg->rrcMsgSize);
7127       }
7128       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
7129    }
7130    freeDuUeCfg(&f1UeDb->duUeCfg);
7131    memset(f1UeDb, 0, sizeof(F1UeContextSetupDb));
7132    DU_FREE(f1UeDb, sizeof(F1UeContextSetupDb));
7133 }
7134
7135 /*******************************************************************
7136  *
7137  * @brief Function to build Am cfg Info
7138  *
7139  * @details
7140  *
7141  *    Function : extractRlcAmCfg
7142  *
7143  *    Functionality: Function to build Am cfg Info
7144  *
7145  * @params[in] AmBearerCfg *
7146  *             void *
7147  *
7148  * @return ROK/RFAILED
7149  *
7150  * ****************************************************************/
7151
7152 void extractRlcAmCfg(AmBearerCfg *amCfgToSet, struct RLC_Config__am *rlcAmCfg)
7153 {
7154    if(rlcAmCfg)
7155    {
7156       /* UL AM */
7157       if(rlcAmCfg->dl_AM_RLC.sn_FieldLength)
7158       {
7159          amCfgToSet->ulAmCfg.snLenUl = *(rlcAmCfg->dl_AM_RLC.sn_FieldLength);
7160          /*TODO: Check the timer value when sent by real CU */
7161          amCfgToSet->ulAmCfg.reAssemTmr = rlcAmCfg->dl_AM_RLC.t_Reassembly;
7162          amCfgToSet->ulAmCfg.statProhTmr = rlcAmCfg->dl_AM_RLC.t_StatusProhibit;
7163       }
7164
7165       /* DL AM */
7166       if(rlcAmCfg->ul_AM_RLC.sn_FieldLength)
7167       {
7168          amCfgToSet->dlAmCfg.snLenDl = *(rlcAmCfg->ul_AM_RLC.sn_FieldLength);
7169          amCfgToSet->dlAmCfg.pollRetxTmr = rlcAmCfg->ul_AM_RLC.t_PollRetransmit;
7170          amCfgToSet->dlAmCfg.pollPdu   = rlcAmCfg->ul_AM_RLC.pollPDU;
7171          amCfgToSet->dlAmCfg.pollByte  = rlcAmCfg->ul_AM_RLC.pollByte;
7172          amCfgToSet->dlAmCfg.maxRetxTh = rlcAmCfg->ul_AM_RLC.maxRetxThreshold;
7173       }
7174    }
7175 }
7176
7177 /*******************************************************************
7178  *
7179  * @brief Function to build Um Bi Info
7180  *
7181  * @details
7182  *
7183  *    Function : extractRlcUmBiCfg
7184  *
7185  *    Functionality: Function to build Um Bi Info
7186  *
7187  * @params[in] UmBiDirBearerCfg *
7188  *             void *
7189  *
7190  * @return ROK/RFAILED
7191  *
7192  * ****************************************************************/
7193
7194 void extractRlcUmBiCfg(UmBiDirBearerCfg *umBiCfgToSet, struct RLC_Config__um_Bi_Directional *rlcBiCfg)
7195 {
7196    if(rlcBiCfg)
7197    {
7198       /* UL UM BI DIR Cfg */
7199       if(rlcBiCfg->dl_UM_RLC.sn_FieldLength)
7200       {
7201          umBiCfgToSet->ulUmCfg.snLenUlUm  = *(rlcBiCfg->dl_UM_RLC.sn_FieldLength);
7202          umBiCfgToSet->ulUmCfg.reAssemTmr = rlcBiCfg->dl_UM_RLC.t_Reassembly;
7203       }
7204
7205       /* DL UM BI DIR Cfg */
7206       if(rlcBiCfg->ul_UM_RLC.sn_FieldLength)
7207          umBiCfgToSet->dlUmCfg.snLenDlUm  = *(rlcBiCfg->ul_UM_RLC.sn_FieldLength);
7208    }
7209 }
7210
7211 /*******************************************************************
7212  *
7213  * @brief Function to build Um Ul Info
7214  *
7215  * @details
7216  *
7217  *    Function : extractRlcUmUlCfg
7218  *
7219  *    Functionality: Function to build Um Ul Info
7220  *
7221  * @params[in] UmUniDirUlBearerCfg *
7222  *             void *
7223  *
7224  * @return ROK/RFAILED
7225  *
7226  * ****************************************************************/
7227
7228 void extractRlcUmUlCfg(UmUniDirUlBearerCfg *umUlCfgToSet, struct RLC_Config__um_Uni_Directional_DL *umUlCfg)
7229 {
7230    if(umUlCfg)
7231    {
7232       if(umUlCfg->dl_UM_RLC.sn_FieldLength)
7233       {
7234          umUlCfgToSet->ulUmCfg.snLenUlUm  = *(umUlCfg->dl_UM_RLC.sn_FieldLength);
7235          umUlCfgToSet->ulUmCfg.reAssemTmr = umUlCfg->dl_UM_RLC.t_Reassembly;
7236       }
7237    }
7238 }
7239
7240 /*******************************************************************
7241  *
7242  * @brief Function to build Um Uni Dl Info
7243  *
7244  * @details
7245  *
7246  *    Function : extractRlcUmDlCfg
7247  *
7248  *    Functionality: Function to build Um Uni Dl Info
7249  *
7250  * @params[in] UmUniDirDlBearerCfg *
7251  *             void *
7252  *
7253  * @return ROK/RFAILED
7254  *
7255  * ****************************************************************/
7256 void extractRlcUmDlCfg(UmUniDirDlBearerCfg *umDlCfgToSet, struct RLC_Config__um_Uni_Directional_UL *umDlCfg)
7257 {
7258    if(umDlCfg)
7259    {
7260       if(umDlCfg->ul_UM_RLC.sn_FieldLength)
7261          umDlCfgToSet->dlUmCfg.snLenDlUm  = *(umDlCfg->ul_UM_RLC.sn_FieldLength);
7262    }
7263 }
7264
7265 /*******************************************************************
7266  *
7267  * @brief Function to extractRlcModeCfg
7268  *
7269  * @details
7270  *
7271  *    Function : extractRlcModeCfg
7272  *
7273  *    Functionality: Function to extractRlcModeCfg
7274  *
7275  * @params[in] RLC_Config_t *
7276  *             RlcBearerCfg *
7277  *             void  *
7278  * @return ROK/RFAILED
7279  *
7280  * ****************************************************************/
7281 void extractRlcModeCfg(uint8_t rlcMode, RlcBearerCfg *rlcDbCfg, RLC_Config_t *lcCfg)
7282 {
7283    if(lcCfg)
7284    {
7285       switch(rlcMode)
7286       {
7287          case RLC_AM :
7288             {
7289                if(lcCfg->choice.am)
7290                {
7291                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.amCfg, sizeof(AmBearerCfg));
7292                   if(rlcDbCfg->u.amCfg)
7293                      extractRlcAmCfg(rlcDbCfg->u.amCfg, lcCfg->choice.am);
7294                }
7295                break;
7296             }
7297          case RLC_UM_BI_DIRECTIONAL :
7298             {
7299                if(lcCfg->choice.um_Bi_Directional)
7300                {
7301                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
7302                   if(rlcDbCfg->u.umBiDirCfg)
7303                      extractRlcUmBiCfg(rlcDbCfg->u.umBiDirCfg, lcCfg->choice.um_Bi_Directional);
7304                }
7305                break;
7306             }
7307          case RLC_UM_UNI_DIRECTIONAL_UL :
7308             {
7309                if(lcCfg->choice.um_Uni_Directional_DL)
7310                {
7311                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
7312                   if(rlcDbCfg->u.umUniDirUlCfg)
7313                      extractRlcUmUlCfg(rlcDbCfg->u.umUniDirUlCfg, lcCfg->choice.um_Uni_Directional_DL);
7314                }
7315                break;
7316             }
7317          case RLC_UM_UNI_DIRECTIONAL_DL :
7318             {
7319                if(lcCfg->choice.um_Uni_Directional_UL)
7320                {
7321                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
7322                   if(rlcDbCfg->u.umUniDirDlCfg)
7323                      extractRlcUmDlCfg(rlcDbCfg->u.umUniDirDlCfg, lcCfg->choice.um_Uni_Directional_UL);
7324                }
7325                break;
7326             }
7327          default:
7328             DU_LOG("\nERROR  -->  DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
7329             break;
7330       }
7331    }
7332 }
7333
7334 /*******************************************************************
7335  *
7336  * @brief Function to extract extractUlLcCfg
7337  *
7338  * @details
7339  *
7340  *    Function : extractUlLcCfg
7341  *
7342  *    Functionality: Function to extract extractUlLcCfg
7343  *
7344  * @params[in] UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg
7345  * @return void
7346  *
7347  * ****************************************************************/
7348
7349 void extractUlLcCfg(UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg)
7350 {
7351    if(ulLcCfg)
7352    {
7353       if(ulLcCfg->ul_SpecificParameters)
7354       {
7355          f1UlLcCfg->priority = \
7356             ulLcCfg->ul_SpecificParameters->priority;
7357       if(ulLcCfg->ul_SpecificParameters->logicalChannelGroup)
7358       {
7359          f1UlLcCfg->lcGroup = \
7360            *(ulLcCfg->ul_SpecificParameters->logicalChannelGroup);
7361       }
7362       if(ulLcCfg->ul_SpecificParameters->schedulingRequestID)
7363       {
7364          f1UlLcCfg->schReqId = \
7365            *(ulLcCfg->ul_SpecificParameters->schedulingRequestID);
7366       }
7367       f1UlLcCfg->pbr = \
7368          ulLcCfg->ul_SpecificParameters->prioritisedBitRate;
7369       f1UlLcCfg->bsd = \
7370          ulLcCfg->ul_SpecificParameters->bucketSizeDuration;
7371       }
7372    }
7373 }
7374
7375 /*******************************************************************
7376  *
7377  * @brief Function to procRlcLcCfg
7378  *
7379  * @details
7380  *
7381  *    Function : procRlcLcCfg
7382  *
7383  *    Functionality: Function to procRlcLcCfg
7384  *
7385  * @params[in] rbId, lcId, rbType, rlcMod
7386  *             RLC_Config_t *, RlcBearerCfg * ,
7387  * @return void
7388  *
7389  * ****************************************************************/
7390
7391 void procRlcLcCfg(uint8_t rbId, uint8_t lcId, uint8_t rbType, uint8_t rlcMode,\
7392    uint8_t configType, RLC_Config_t *f1RlcCfg, RlcBearerCfg *lcCfg)
7393 {
7394
7395    lcCfg->rbId   = rbId;
7396    lcCfg->configType = configType;
7397
7398    if(rbType == RB_TYPE_SRB)
7399    {
7400       lcCfg->rbType = RB_TYPE_SRB;
7401       lcCfg->lcId   = rbId;
7402       lcCfg->lcType = LCH_DCCH;
7403       lcCfg->rlcMode = RLC_AM;
7404    }
7405    else if(rbType == RB_TYPE_DRB)
7406    {
7407       lcCfg->rbType = RB_TYPE_DRB;
7408       lcCfg->lcId   = lcId;
7409       lcCfg->lcType = LCH_DTCH;
7410       lcCfg->rlcMode = rlcMode;
7411    }
7412    if(f1RlcCfg) /* rlc mode config recived */
7413    {
7414       extractRlcModeCfg(lcCfg->rlcMode, lcCfg, f1RlcCfg);
7415    }
7416 }
7417
7418
7419
7420 /*******************************************************************
7421  *
7422  * @brief Fills DrbQos Info received by CU
7423  *
7424  * @details
7425  *
7426  *    Function : extractQosInfo
7427  *
7428  *    Functionality: Fills DrbQos Info received  by CU
7429  *
7430  * @params[in] DrbQosInfo *qosToAdd,
7431  *             QoSFlowLevelQoSParameters_t *qosFlowCfg
7432  * @return void
7433  *
7434  * ****************************************************************/
7435
7436 void extractQosInfo(DrbQosInfo *qosToAdd, QoSFlowLevelQoSParameters_t *qosFlowCfg)
7437 {
7438    qosToAdd->fiveQiType = qosFlowCfg->qoS_Characteristics.present;
7439    qosToAdd->u.nonDyn5Qi.fiveQi     =\
7440          qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
7441    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow)
7442    {
7443       qosToAdd->u.nonDyn5Qi.avgWindow = \
7444         *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
7445    }
7446    qosToAdd->u.nonDyn5Qi.maxDataBurstVol = \
7447       *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
7448    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel)
7449    {
7450       qosToAdd->u.nonDyn5Qi.priorLevel = \
7451          *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel);
7452    }
7453    qosToAdd->ngRanRetPri.priorityLevel = \
7454       qosFlowCfg->nGRANallocationRetentionPriority.priorityLevel;
7455    qosToAdd->ngRanRetPri.preEmptionCap = \
7456       qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionCapability;
7457    qosToAdd->ngRanRetPri.preEmptionVul = \
7458       qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionVulnerability;
7459    if(qosFlowCfg->gBR_QoS_Flow_Information)
7460    {
7461       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateDl, \
7462          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.buf, \
7463          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.size);
7464       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateUl, \
7465          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.buf, \
7466          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.size);
7467       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateDl,\
7468          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.buf, \
7469          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.size);
7470       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateUl,\
7471          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.buf, \
7472          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.size);
7473    }
7474    qosToAdd->pduSessionId = 0;
7475    qosToAdd->ulPduSessAggMaxBitRate = 0;
7476 }
7477
7478 /*******************************************************************
7479  *
7480  * @brief Function to extract GTP Tunnel Info from CU
7481  *
7482  * @details
7483  *
7484  *    Function : extractUpTnlInfo
7485  *
7486  *    Functionality: Function to extract GTP Tunnel Info from CU
7487  *
7488  * @params[in] F1AP message
7489  * @return ROK/RFAILED
7490  *
7491  * ****************************************************************/
7492
7493 uint8_t extractUpTnlInfo(uint8_t drbId, uint8_t configType,\
7494    ULUPTNLInformation_ToBeSetup_List_t *tnlInfo, UpTnlCfg *upTnlInfo)
7495 {
7496    uint8_t tnlIdx;
7497    uint32_t ipv4_du = 0;
7498    GTPTunnel_t *gtpTunnel = NULLP;
7499
7500    upTnlInfo->drbId = drbId;
7501    upTnlInfo->configType = configType;
7502 #ifdef O1_ENABLE
7503    cmInetAddr((S8*)g_cfg.DU_IPV4_Addr, &ipv4_du);
7504 #else
7505    cmInetAddr((char *)DU_IP_V4_ADDR, &ipv4_du);
7506 #endif
7507
7508    for(tnlIdx=0; tnlIdx < tnlInfo->list.count; tnlIdx++)
7509    {
7510       if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
7511       {
7512          if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel)
7513          {
7514             gtpTunnel = tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel;
7515             DU_ALLOC(upTnlInfo->tnlCfg1, sizeof(GtpTnlCfg));
7516             if(upTnlInfo->tnlCfg1 == NULLP)
7517             {
7518                DU_LOG("\nERROR  -->  F1AP : extractUpTnlInfo: Failed to allocate mmeory for tunnel cfg 1");
7519                return RFAILED;
7520             }
7521             bitStringToInt(&gtpTunnel->transportLayerAddress, &upTnlInfo->tnlCfg1->ulTnlAddress);
7522             upTnlInfo->tnlCfg1->dlTnlAddress = ipv4_du;
7523             if(gtpTunnel->gTP_TEID.size > 0)
7524             {
7525                teIdStringToInt(gtpTunnel->gTP_TEID.buf, &upTnlInfo->tnlCfg1->teId);
7526             }
7527          }
7528          break;
7529       }
7530    }
7531    return ROK;
7532 }
7533 /*******************************************************************
7534 *
7535 * @brief Function to extract Drb Qos Cfg Info from CU
7536 *
7537 * @details
7538 *
7539 *    Function : extractDrbQosCfg
7540 *
7541 *    Functionality: Function to extract Drb Qos Cfg Info from CU
7542 *
7543 * @params[in] DRB_Information_t *drbInfo, LcCfg *macLcToAdd
7544 * @return ROK/RFAILED
7545 *
7546 * ****************************************************************/
7547
7548 uint8_t extractDrbQosCfg(DRB_Information_t *drbInfo, LcCfg *macLcToAdd )
7549 {
7550    if(!macLcToAdd->drbQos)
7551    {
7552       DU_ALLOC_SHRABL_BUF(macLcToAdd->drbQos, sizeof(DrbQosInfo));
7553       if(macLcToAdd->drbQos == NULLP)
7554       {
7555          DU_LOG("\nERROR  -->  DUAPP:Memory failed at allocating DrbQos at extractDrbCfg()");
7556          return RFAILED;
7557       }
7558
7559    }
7560    if(drbInfo->dRB_QoS.qoS_Characteristics.present == QoS_Characteristics_PR_non_Dynamic_5QI)
7561    {
7562       extractQosInfo(macLcToAdd->drbQos, &drbInfo->dRB_QoS);
7563       macLcToAdd->dlLcCfg.lcp = macLcToAdd->drbQos->ngRanRetPri.priorityLevel;
7564    }
7565    if(!macLcToAdd->snssai)
7566    {
7567       DU_ALLOC_SHRABL_BUF(macLcToAdd->snssai, sizeof(Snssai));
7568       if(macLcToAdd->snssai == NULLP)
7569       {
7570          DU_LOG("\nERROR  -->  DUAPP : Memory failed at allocating SNSSAI at extractDrbCfg()");
7571          return RFAILED;
7572       }
7573    }
7574    memcpy(&macLcToAdd->snssai->sst, drbInfo->sNSSAI.sST.buf, \
7575          drbInfo->sNSSAI.sST.size);
7576    if(drbInfo->sNSSAI.sD)
7577    {
7578       memcpy(macLcToAdd->snssai->sd, drbInfo->sNSSAI.sD->buf, \
7579             drbInfo->sNSSAI.sD->size);
7580    }
7581    return ROK;
7582 }
7583 /*******************************************************************
7584  *
7585  * @brief Function to extract DRB info received from CU
7586  *
7587  * @details
7588  *
7589  *    Function : extractDrbCfg
7590  *
7591  *    Functionality: Function to extract DRB info received from CU
7592  *
7593  * @params[in] F1AP message
7594  * @return void
7595  *
7596  * ****************************************************************/
7597 uint8_t extractDrbCfg(DRBs_ToBeSetup_Item_t *drbItem,DRBs_ToBeSetupMod_Item_t *drbSetupModItem,\
7598 LcCfg *macLcToAdd, UpTnlCfg *upTnlInfo)
7599 {
7600    DRB_Information_t *drbInfo = NULLP;
7601
7602    if(drbItem != NULLP)
7603    {
7604       if(extractUpTnlInfo(drbItem->dRBID, CONFIG_ADD, &drbItem->uLUPTNLInformation_ToBeSetup_List, upTnlInfo) != ROK)
7605       {
7606          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7607          return RFAILED;
7608       }
7609       if(drbItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7610       {
7611          if(drbItem->qoSInformation.choice.choice_extension->value.present == QoSInformation_ExtIEs__value_PR_DRB_Information)
7612          {
7613             drbInfo = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7614             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7615             {
7616                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7617                return RFAILED;
7618             }
7619          }
7620       }
7621    }
7622    else if(drbSetupModItem != NULLP)
7623    {
7624       if(extractUpTnlInfo(drbSetupModItem->dRBID, CONFIG_ADD, &drbSetupModItem->uLUPTNLInformation_ToBeSetup_List,\
7625       upTnlInfo) != ROK)
7626       {
7627          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7628          return RFAILED;
7629       }
7630       if(drbSetupModItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7631       {
7632          if(drbSetupModItem->qoSInformation.choice.choice_extension->value.present ==\
7633          QoSInformation_ExtIEs__value_PR_DRB_Information)
7634          {
7635             drbInfo = &drbSetupModItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7636             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7637             {
7638                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7639                return RFAILED;
7640             }
7641
7642          }
7643       }
7644    }
7645
7646    return ROK;
7647 }
7648
7649 /*******************************************************************
7650  *
7651  * @brief Function to extract RB info received from CU
7652  *
7653  * @details
7654  *
7655  *    Function : extractMacRbCfg
7656  *
7657  *    Functionality: Function to extract RB info received from CU
7658  *
7659  * @params[in] F1AP message
7660  * @return ROK/RFAILED
7661  *
7662  * ****************************************************************/
7663
7664 uint8_t extractMacRbCfg(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbCfg,\
7665 DRBs_ToBeSetupMod_Item_t *drbSetupModCfg,  LogicalChannelConfig_t *ulLcCfg, LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7666 {
7667    if(drbCfg != NULLP)
7668    {
7669       if(extractDrbCfg(drbCfg, NULL, lcCfg, upTnlInfo) != ROK)
7670       {
7671          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7672          return RFAILED;
7673       }
7674    }
7675    else if(drbSetupModCfg != NULLP)
7676    {
7677       if(extractDrbCfg(NULL, drbSetupModCfg, lcCfg, upTnlInfo) != ROK)
7678       {
7679          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7680          return RFAILED;
7681       }
7682    }
7683    else
7684    {
7685       lcCfg->drbQos = NULLP;
7686       lcCfg->snssai = NULLP;
7687       if(lcCfg->lcId == SRB2_LCID)
7688          lcCfg->dlLcCfg.lcp = LC_PRIORITY_3;
7689       else
7690          lcCfg->dlLcCfg.lcp = LC_PRIORITY_1;
7691    }
7692    if(ulLcCfg)
7693    {
7694       lcCfg->ulLcCfgPres = true;
7695       extractUlLcCfg(&lcCfg->ulLcCfg, ulLcCfg);
7696    }
7697    else
7698       lcCfg->ulLcCfgPres = false;
7699    return ROK;
7700 }
7701
7702 /*******************************************************************
7703  *
7704  * @brief Function processing LC config info received from CU
7705  *
7706  * @details
7707  *
7708  *    Function : procMacLcCfg
7709  *
7710  *    Functionality: Function processing LC config info received from CU
7711  *
7712  * @params[in] F1AP message
7713  * @return ROK/RFAILED
7714  *
7715  * ****************************************************************/
7716
7717 uint8_t procMacLcCfg(uint8_t lcId, uint8_t rbType, uint8_t configType,\
7718 DRBs_ToBeSetup_Item_t *drbItem, DRBs_ToBeSetupMod_Item_t *drbSetupModItem, LogicalChannelConfig_t *ulLcCfg,\
7719 LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7720 {
7721    uint8_t ret = ROK;
7722
7723    lcCfg->lcId = lcId;
7724    lcCfg->configType = configType;
7725    if(rbType == RB_TYPE_SRB)
7726    {
7727       ret = extractMacRbCfg(lcId, NULL,NULL, ulLcCfg, lcCfg, NULL);
7728    }
7729    else if(rbType == RB_TYPE_DRB)
7730    {
7731       if(drbItem != NULL)
7732         ret = extractMacRbCfg(lcId, drbItem, NULL, ulLcCfg, lcCfg, upTnlInfo);
7733       else if(drbSetupModItem != NULL)
7734         ret = extractMacRbCfg(lcId, NULL, drbSetupModItem, ulLcCfg, lcCfg, upTnlInfo);
7735    }
7736    return ret;
7737 }
7738
7739 /*******************************************************************
7740  *
7741  * @brief Function to extract Rlc cfg To Add/Mod in CellGrp Info
7742  *
7743  * @details
7744  *
7745  *    Function : extractRlcCfgToAddMod
7746  *
7747  *    Functionality: Function to extract Rlc cfg To Add/Mod in CellGrp Info
7748  *
7749  * @params[in] CellGroupConfigRrc__rlc_BearerTo pointer
7750  *             DuUeCfg Pointer
7751  * @return ROK/RFAILED
7752  *
7753  * ****************************************************************/
7754
7755 uint8_t extractRlcCfgToAddMod(struct CellGroupConfigRrc__rlc_BearerToAddModList *lcCfg, DuUeCfg *ueCfgDb)
7756 {
7757   uint8_t idx, rbId, lcId, rlcMode, rbType;
7758   RLC_Config_t *f1RlcCfg = NULLP;
7759   LogicalChannelConfig_t *macUlLcCfg = NULLP;
7760
7761   for(idx = 0; idx < lcCfg->list.count; idx++)
7762   {
7763      lcId = lcCfg->list.array[idx]->logicalChannelIdentity;
7764      if(lcCfg->list.array[idx]->servedRadioBearer)
7765      {
7766         /* RadioBearer for SRB/DRB */
7767         if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7768         RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
7769         {
7770            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.srb_Identity;
7771            rbType = RB_TYPE_SRB;
7772         }
7773         else if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7774         RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
7775         {
7776            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.drb_Identity;
7777            rbType = RB_TYPE_DRB;
7778         }
7779         else
7780         {
7781            DU_LOG("\nERROR  -->  No components present in Bearer config to ADD/MOD");
7782            return RFAILED;
7783         }
7784         /* MAC UL LC Config */
7785         if(lcCfg->list.array[idx]->mac_LogicalChannelConfig)
7786         {
7787            macUlLcCfg = lcCfg->list.array[idx]->mac_LogicalChannelConfig;
7788         }
7789      }
7790      else
7791      {
7792         DU_LOG("\nERROR  -->  DUAPP: Received RadioBearer config is NULL");
7793         return RFAILED;
7794      }
7795      /* RLC Mode Config */
7796      if(lcCfg->list.array[idx]->rlc_Config)
7797      {
7798         rlcMode  = lcCfg->list.array[idx]->rlc_Config->present;
7799         f1RlcCfg = lcCfg->list.array[idx]->rlc_Config;
7800      }
7801
7802      /* Filling RLC/MAC Config*/
7803      memset(&ueCfgDb->macLcCfg[idx], 0, sizeof(LcCfg));
7804      memset(&ueCfgDb->rlcLcCfg[idx], 0, sizeof(RlcBearerCfg));
7805      procRlcLcCfg(rbId, lcId, rbType, rlcMode, CONFIG_UNKNOWN, f1RlcCfg, &(ueCfgDb->rlcLcCfg[idx]));
7806      if(procMacLcCfg(lcId, rbType, CONFIG_UNKNOWN, NULL, NULL, macUlLcCfg, &ueCfgDb->macLcCfg[idx], NULL) != ROK)
7807      {
7808         DU_LOG("\nERROR  -->  DU APP : Failed while filling MAC LC config at extractRlcCfgToAddMod()");
7809         return RFAILED;
7810      }
7811      (ueCfgDb->numRlcLcs)++;
7812      (ueCfgDb->numMacLcs)++;
7813   }
7814   //TODO: To send the failure cause in UeContextSetupRsp
7815   return ROK;
7816 }
7817
7818 /*******************************************************************
7819  *
7820  * @brief DeAlloc pdsch serv cell config info
7821  *
7822  * @details
7823  *
7824  *    Function : freeMacPdschServCellInfo
7825  *
7826  *    Functionality: DeAlloc pdsch serv cell config info
7827  *
7828  * @params[in] PdschServCellCfg pointer
7829  * @return void
7830  *
7831  * ****************************************************************/
7832
7833 void freeMacPdschServCellInfo(PdschServCellCfg *pdsch)
7834 {
7835    if(pdsch->xOverhead)
7836    {
7837       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->xOverhead, sizeof(PdschXOverhead));
7838    }
7839    if(pdsch->codeBlkGrpFlushInd)
7840    {
7841       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->codeBlkGrpFlushInd, sizeof(bool));
7842    }
7843    if(pdsch->maxCodeBlkGrpPerTb)
7844    {
7845       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
7846    }
7847    if(pdsch->maxMimoLayers)
7848    {
7849       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxMimoLayers, sizeof(uint8_t));
7850    }
7851 }
7852
7853 /*******************************************************************
7854  *
7855  * @brief Free Serving cell Info
7856  *
7857  * @details
7858  *
7859  *    Function : freeMacServingCellInfo
7860  *
7861  *    Functionality: Free Serving cell Info
7862  *
7863  * @params[in] ServCellCfgInfo *srvCellCfg
7864  * @return void
7865  *
7866  * ****************************************************************/
7867 void freeMacServingCellInfo(ServCellCfgInfo *srvCellCfg)
7868 {
7869    uint8_t timeDomRsrcIdx;
7870
7871    if(srvCellCfg->initDlBwp.pdschPresent)
7872    {
7873       for(timeDomRsrcIdx = 0; timeDomRsrcIdx < srvCellCfg->initDlBwp.pdschCfg.numTimeDomRsrcAlloc; timeDomRsrcIdx++)
7874       {
7875          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, \
7876             srvCellCfg->initDlBwp.pdschCfg.timeDomRsrcAllociList[timeDomRsrcIdx].k0, sizeof(uint8_t));
7877       }
7878    }
7879
7880    freeMacPdschServCellInfo(&srvCellCfg->pdschServCellCfg);
7881    if(srvCellCfg->bwpInactivityTmr)
7882    {
7883       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
7884    }
7885
7886    if(srvCellCfg->initUlBwp.pucchPresent)
7887    {
7888       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->initUlBwp.pucchCfg.dlDataToUlAck, sizeof(PucchDlDataToUlAck));
7889    }
7890 }
7891
7892 /*******************************************************************
7893  *
7894  * @brief Free cell Grp Cfg Info
7895  *
7896  * @details
7897  *
7898  *    Function : freeUeReCfgCellGrpInfo
7899  *
7900  *    Functionality: Free cell Grp Cfg Info
7901  *
7902  * @params[in] MacUeCfg*  duUeCfg
7903  * @return void
7904  *
7905  * ****************************************************************/
7906
7907 void freeUeReCfgCellGrpInfo(MacUeCfg *macUeCfg)
7908 {
7909    freeMacServingCellInfo(&macUeCfg->spCellCfg.servCellCfg);
7910 }
7911
7912 /*******************************************************************
7913  *
7914  * @brief Fills Reconfig SchReqReConfig
7915  *
7916  * @details
7917  *
7918  *    Function : extractSchReqReConfig
7919  *
7920  *    Functionality: Fills Reconfig SchReqReConfig
7921  *
7922  * @params[in] SchedulingRequestConfig_t *cuSchedReq
7923  *             SchedReqCfg*  macSchedReq
7924  * @return void
7925  *
7926  * ****************************************************************/
7927 void extractSchReqReConfig(SchedulingRequestConfig_t *cuSchedReq, SchedReqCfg *macSchedReq)
7928 {
7929    uint8_t schReqIdx = 0;
7930    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqListToAdd = NULLP;
7931    struct SchedulingRequestConfig__schedulingRequestToReleaseList *schReqListToRel = NULLP;
7932
7933    if(cuSchedReq->schedulingRequestToAddModList)
7934    {
7935       schReqListToAdd = cuSchedReq->schedulingRequestToAddModList;
7936       if(schReqListToAdd->list.count)
7937       {
7938          macSchedReq->addModListCount = schReqListToAdd->list.count;
7939          for(schReqIdx = 0; schReqIdx < schReqListToAdd->list.count; schReqIdx++)
7940          {
7941             macSchedReq->addModList[schReqIdx].schedReqId = \
7942                schReqListToAdd->list.array[schReqIdx]->schedulingRequestId;
7943             macSchedReq->addModList[schReqIdx].srProhibitTmr = \
7944                *(schReqListToAdd->list.array[schReqIdx]->sr_ProhibitTimer);
7945             macSchedReq->addModList[schReqIdx].srTransMax    =\
7946                schReqListToAdd->list.array[schReqIdx]->sr_TransMax;
7947          }
7948       }
7949    }
7950    /* Scheduling Req To release */
7951    if(cuSchedReq->schedulingRequestToReleaseList)
7952    {
7953       schReqListToRel = cuSchedReq->schedulingRequestToReleaseList;
7954       if(schReqListToRel->list.count)
7955       {
7956          macSchedReq->relListCount = schReqListToRel->list.count;
7957          for(schReqIdx = 0; schReqIdx < schReqListToRel->list.count; schReqIdx++)
7958          {
7959             macSchedReq->relList[schReqIdx] = \
7960                *schReqListToRel->list.array[schReqIdx];
7961          }
7962       }
7963    }
7964 }
7965
7966 /*******************************************************************
7967  *
7968  * @brief Fills TagReconfig
7969  *
7970  * @details
7971  *
7972  *    Function : extractTagReconfig
7973  *
7974  *    Functionality: Fills extractTagReconfig
7975  *
7976  * @params[in] TAG_Config_t *cuTagCfg
7977  *             TagCfg *macTagCfg
7978  * @return void
7979  *
7980  * ****************************************************************/
7981
7982 void extractTagReconfig(TAG_Config_t *cuTagCfg, TagCfg *macTagCfg)
7983 {
7984   uint8_t tagIdx = 0;
7985   struct TAG_Config__tag_ToAddModList  *tagListToAddMod = NULLP;
7986   struct TAG_Config__tag_ToReleaseList *tagListToRel = NULLP;
7987
7988   /* Tag config to AddMod */
7989   if(cuTagCfg->tag_ToAddModList)
7990   {
7991      tagListToAddMod = cuTagCfg->tag_ToAddModList;
7992      if(tagListToAddMod->list.count)
7993      {
7994         macTagCfg->addModListCount = tagListToAddMod->list.count;
7995         for(tagIdx = 0; tagIdx < tagListToAddMod->list.count; tagIdx++)
7996         {
7997            macTagCfg->addModList[tagIdx].tagId =\
7998               tagListToAddMod->list.array[tagIdx]->tag_Id;
7999            macTagCfg->addModList[tagIdx].timeAlignTimer = \
8000
8001               tagListToAddMod->list.array[tagIdx]->timeAlignmentTimer;
8002         }
8003      }
8004   }
8005   /* Tag config to release */
8006   if(cuTagCfg->tag_ToReleaseList)
8007   {
8008      tagListToRel = cuTagCfg->tag_ToReleaseList;
8009      if(tagListToRel->list.count)
8010      {
8011         macTagCfg->relListCount = tagListToRel->list.count;
8012         for(tagIdx = 0; tagIdx < tagListToRel->list.count; tagIdx++)
8013         {
8014            macTagCfg->relList[tagIdx] = *tagListToRel->list.array[tagIdx];
8015         }
8016      }
8017   }
8018 }
8019
8020 /*******************************************************************
8021  *
8022  * @brief Fills PdcchCfg received by CU
8023  *
8024  * @details
8025  *
8026  *    Function : extractPdcchCfg
8027  *
8028  *    Functionality: Fills PdcchCfg received  by CU
8029  *
8030  * @params[in] PDCCH_Config_t *cuPdcchCfg,
8031  *             PdcchConfig *duPdcchCfg
8032  * @return void
8033  *
8034  * ****************************************************************/
8035
8036 void extractPdcchCfg(PDCCH_Config_t *cuPdcchCfg, PdcchConfig *macPdcchCfg)
8037 {
8038    uint8_t cRsetIdx = 0;
8039    uint8_t srchSpcIdx = 0;
8040
8041    struct PDCCH_Config__controlResourceSetToAddModList *cRsetToAddModList = NULLP;
8042    struct PDCCH_Config__controlResourceSetToReleaseList *cRsetToRelList = NULLP;
8043    struct PDCCH_Config__searchSpacesToAddModList *srchSpcToAddModList = NULLP;
8044    struct PDCCH_Config__searchSpacesToReleaseList *srchSpcToRelList = NULLP;
8045
8046
8047    /* Control Resource Set To Add/Mod List */
8048    if(cuPdcchCfg->controlResourceSetToAddModList)
8049    {
8050       cRsetToAddModList = cuPdcchCfg->controlResourceSetToAddModList;
8051       if(cRsetToAddModList->list.count)
8052       {
8053          macPdcchCfg->numCRsetToAddMod = cRsetToAddModList->list.count;
8054          for(cRsetIdx = 0; cRsetIdx < cRsetToAddModList->list.count; cRsetIdx++)
8055          {
8056             macPdcchCfg->cRSetToAddModList[cRsetIdx].cRSetId = \
8057               cRsetToAddModList->list.array[cRsetIdx]->controlResourceSetId;
8058             bitStringToInt(&cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources,\
8059                macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc);
8060             macPdcchCfg->cRSetToAddModList[cRsetIdx].duration = \
8061               cRsetToAddModList->list.array[cRsetIdx]->duration;
8062
8063             macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType = \
8064               cRsetToAddModList->list.array[cRsetIdx]->cce_REG_MappingType.present;
8065             if(macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType == CCE_REG_MAPPINGTYPE_PR_INTERLEAVED)
8066             {
8067                //TODO: handle the case for Interleaved
8068             }
8069             macPdcchCfg->cRSetToAddModList[cRsetIdx].precoderGranularity = \
8070               cRsetToAddModList->list.array[cRsetIdx]->precoderGranularity;
8071             if(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID)
8072             {
8073                macPdcchCfg->cRSetToAddModList[cRsetIdx].dmrsScramblingId= \
8074                   *(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID);
8075             }
8076          }
8077       }
8078
8079    }
8080    /* Control Resource Set To Release List */
8081    if(cuPdcchCfg->controlResourceSetToReleaseList)
8082    {
8083       cRsetToRelList = cuPdcchCfg->controlResourceSetToReleaseList;
8084       if(cRsetToRelList->list.count)
8085       {
8086          macPdcchCfg->numCRsetToRel = cRsetToRelList->list.count;
8087          for(cRsetIdx = 0; cRsetIdx < cRsetToRelList->list.count; cRsetIdx++)
8088          {
8089             macPdcchCfg->cRSetToRelList[cRsetIdx] = *(cRsetToRelList->list.array[cRsetIdx]);
8090          }
8091       }
8092    }
8093
8094    /* Search space To Add/Mod List */
8095    if(cuPdcchCfg->searchSpacesToAddModList)
8096    {
8097       srchSpcToAddModList = cuPdcchCfg->searchSpacesToAddModList;
8098       if(srchSpcToAddModList->list.count)
8099       {
8100          macPdcchCfg->numSearchSpcToAddMod = srchSpcToAddModList->list.count;
8101          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToAddModList->list.count; srchSpcIdx++)
8102          {
8103             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceId =\
8104                srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceId;
8105             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].cRSetId =\
8106                *(srchSpcToAddModList->list.array[srchSpcIdx]->controlResourceSetId);
8107             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset)
8108             {
8109                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset =\
8110                   srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset->present;
8111             }
8112             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot)
8113             {
8114                bitStringToInt(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot,\
8115                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSymbolsWithinSlot);
8116             }
8117             if(srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates)
8118             {
8119               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel1 = \
8120                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel1;
8121               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel2 = \
8122                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel2;
8123               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel4 = \
8124                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel4;
8125
8126               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel8 = \
8127                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel8;
8128
8129               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel16 = \
8130                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel16;
8131             }
8132             if(srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType)
8133             {
8134                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType =\
8135                   srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->present;
8136                if(macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType == SEARCHSPACETYPE_PR_UE_SPECIFIC)
8137                {
8138                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].ueSpecificDciFormat =\
8139                      srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->choice.ue_Specific->dci_Formats;
8140                }
8141
8142             }
8143          }
8144       }
8145    }
8146    /* Search space To Rel List */
8147    if(cuPdcchCfg->searchSpacesToReleaseList)
8148    {
8149       srchSpcToRelList = cuPdcchCfg->searchSpacesToReleaseList;
8150       if(srchSpcToRelList->list.count)
8151       {
8152          macPdcchCfg->numSearchSpcToRel = srchSpcToRelList->list.count;
8153          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToRelList->list.count; srchSpcIdx++)
8154          {
8155             macPdcchCfg->searchSpcToRelList[srchSpcIdx] =\
8156                *(srchSpcToRelList->list.array[srchSpcIdx]);
8157          }
8158       }
8159    }
8160 }
8161
8162 /*******************************************************************
8163  *
8164  * @brief Fills PdschCfg received by CU
8165  *
8166  * @details
8167  *
8168  *    Function : extractPdschCfg
8169  *
8170  *    Functionality: Fills PdschCfg received  by CU
8171  *
8172  * @params[in] PDSCH_Config_t *cuPdschCfg = Information which is send by CU,
8173  *                   which we have stored in F1UeContextSetupDb,
8174  *             PdschConfig *macPdschCfg = Used to Store the information which
8175  *                   needs to send in other layer, as well as this can be the variable
8176  *                   which stores the information in DuCb,
8177  *             PdschConfig *storedPdschCfg =  Null in case of sending the
8178  *                   information to other layer else it will have stored pdsch
8179  *                   configuration in copyOfmacUeCfg.
8180  * @return void
8181  *
8182  * ****************************************************************/
8183
8184 void extractPdschCfg(PDSCH_Config_t *cuPdschCfg, PdschConfig *macPdschCfg, PdschConfig *storedPdschCfg)
8185 {
8186    uint8_t timeDomIdx;
8187    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAlloc = NULLP;
8188
8189    if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
8190    {
8191       if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->present == \
8192             PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup)
8193       {
8194          if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup)
8195          {
8196             macPdschCfg->dmrsDlCfgForPdschMapTypeA.addPos = \
8197                *(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_AdditionalPosition);
8198          }
8199       }
8200    }
8201    macPdschCfg->resourceAllocType = cuPdschCfg->resourceAllocation;
8202    if(cuPdschCfg->pdsch_TimeDomainAllocationList)
8203    {
8204       timeDomAlloc = cuPdschCfg->pdsch_TimeDomainAllocationList;
8205       if(timeDomAlloc->present ==\
8206             PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup)
8207       {
8208          if(timeDomAlloc->choice.setup)
8209          {
8210             macPdschCfg->numTimeDomRsrcAlloc  = timeDomAlloc->choice.setup->list.count;
8211             for(timeDomIdx = 0; timeDomIdx < timeDomAlloc->choice.setup->list.count; timeDomIdx++)
8212             {
8213                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 = NULLP;
8214                if(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0)
8215                {
8216                   if(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 == NULL)
8217                   {
8218                      if(storedPdschCfg)
8219                      {
8220                         if(storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
8221                         {
8222                            macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 =\
8223                            storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0;
8224                         }
8225                         else
8226                         {
8227                            DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
8228                         }
8229                      }
8230                      else
8231                      {
8232                         DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
8233                      }
8234                      if(!macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
8235                      {
8236                         DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for k0 at extractPdschCfg()");
8237                         return RFAILED;
8238                      }
8239                   }
8240                   *(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0) = \
8241                   *(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0);
8242                }
8243                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
8244                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
8245                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
8246                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8247             }
8248          }
8249       }
8250    }
8251    macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
8252    if(cuPdschCfg->maxNrofCodeWordsScheduledByDCI)
8253       macPdschCfg->numCodeWordsSchByDci = *(cuPdschCfg->maxNrofCodeWordsScheduledByDCI);
8254    if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_staticBundling)
8255    {
8256       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
8257       if(cuPdschCfg->prb_BundlingType.choice.staticBundling)
8258       {
8259          if(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize)
8260          {
8261             macPdschCfg->bundlingInfo.StaticBundling.size = \
8262                *(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize);
8263          }
8264       }
8265    }
8266    else if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_dynamicBundling)
8267    {
8268       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
8269    }
8270
8271 }
8272
8273 /*******************************************************************
8274  *
8275  * @brief Fills PdschServingCellCfg received by CU
8276  *
8277  * @details
8278  *
8279  *    Function : extractPdschServingCellCfg
8280  *
8281  *    Functionality: Fills PdschCfg received  by CU
8282  *
8283  * @params[in] PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg,
8284  *             PdschServCellCfg *macUePdschSrvCellCfg
8285  * @return ROK/RFAILED
8286  *
8287  * ****************************************************************/
8288
8289 uint8_t extractPdschServingCellCfg(PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg, PdschServCellCfg *macUePdschSrvCellCfg)
8290 {
8291    if(cuPdschSrvCellCfg->codeBlockGroupTransmission)
8292    {
8293       if(cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup)
8294       {
8295          if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
8296          {
8297             *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
8298                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
8299          }
8300          else
8301          {
8302             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
8303             if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
8304             {
8305                *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
8306                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
8307             }
8308             else
8309             {
8310                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
8311                return RFAILED;
8312             }
8313          }
8314          if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
8315          {
8316             *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
8317                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
8318          }
8319          else
8320          {
8321             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->codeBlkGrpFlushInd , sizeof(bool));
8322             if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
8323             {
8324                *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
8325                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
8326             }
8327             else
8328             {
8329                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
8330                return RFAILED;
8331             }
8332          }
8333       }
8334    }
8335    if(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH)
8336    {
8337       macUePdschSrvCellCfg->numHarqProcForPdsch = *(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH);
8338    }
8339    if(cuPdschSrvCellCfg->ext1)
8340    {
8341       if(cuPdschSrvCellCfg->ext1->maxMIMO_Layers)
8342       {
8343         if(macUePdschSrvCellCfg->maxMimoLayers)
8344         {
8345            *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
8346         }
8347         else
8348         {
8349            DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxMimoLayers, sizeof(uint8_t));
8350            if(macUePdschSrvCellCfg->maxMimoLayers)
8351            {
8352               *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
8353            }
8354            else
8355            {
8356               DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
8357               return RFAILED;
8358            }
8359         }
8360       }
8361    }
8362    if(cuPdschSrvCellCfg->xOverhead)
8363    {
8364       if(macUePdschSrvCellCfg->xOverhead)
8365       {
8366          *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
8367       }
8368       else
8369       {
8370          DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->xOverhead, sizeof(PdschXOverhead));
8371          if(macUePdschSrvCellCfg->xOverhead)
8372          {
8373             *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
8374          }
8375          else
8376          {
8377             DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
8378             return RFAILED;
8379          }
8380       }
8381    }
8382    return ROK;
8383 }
8384
8385 /*******************************************************************
8386  *
8387  * @brief Fills PuschCfg received by CU
8388  *
8389  * @details
8390  *
8391  *    Function : extractPuschCfg
8392  *
8393  *    Functionality: Fills PuschCfg received  by CU
8394  *
8395  * @params[in] BWP_UplinkDedicated__pusch_Config *cuPuschCfg,
8396  *             PuschCfg *macPuschCfg
8397  * @return void
8398  *
8399  * ****************************************************************/
8400
8401 void extractPuschCfg(struct BWP_UplinkDedicated__pusch_Config *cuPuschCfg, PuschCfg *macPuschCfg)
8402 {
8403    uint8_t timeDomIdx = 0;
8404    DMRS_UplinkConfig_t *dmrsUlCfg = NULLP;
8405    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList = NULLP;
8406
8407    if(cuPuschCfg->present == BWP_UplinkDedicated__pusch_Config_PR_setup)
8408    {
8409       if(cuPuschCfg->choice.setup)
8410       {
8411          if(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH)
8412          {
8413              macPuschCfg->dataScramblingId = \
8414                 *(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH);
8415          }
8416          if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA)
8417          {
8418             if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->present == PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup)
8419             {
8420                if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup)
8421                {
8422                   dmrsUlCfg = (cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup);
8423                   if(dmrsUlCfg->dmrs_AdditionalPosition)
8424                   {
8425                      macPuschCfg->dmrsUlCfgForPuschMapTypeA.addPos =\
8426                         *(dmrsUlCfg->dmrs_AdditionalPosition);
8427                   }
8428                   if(dmrsUlCfg->transformPrecodingDisabled)
8429                   {
8430                      if(dmrsUlCfg->transformPrecodingDisabled->scramblingID0)
8431                      {
8432                         macPuschCfg->dmrsUlCfgForPuschMapTypeA.transPrecodDisabled.scramblingId0 = \
8433                            *(dmrsUlCfg->transformPrecodingDisabled->scramblingID0);
8434                      }
8435                   }
8436                }
8437             }
8438          }
8439          /*Res Alloc Type for UL */
8440          if(cuPuschCfg->choice.setup->resourceAllocation)
8441          {
8442             macPuschCfg->resourceAllocType = \
8443                cuPuschCfg->choice.setup->resourceAllocation;
8444          }
8445          if(cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList)
8446          {
8447             timeDomAllocList = cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList;
8448             if(timeDomAllocList->present == PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup)
8449             {
8450                if(timeDomAllocList->choice.setup)
8451                {
8452                   macPuschCfg->numTimeDomRsrcAlloc = timeDomAllocList->choice.setup->list.count;
8453                   for(timeDomIdx = 0; timeDomIdx <timeDomAllocList->choice.setup->list.count; timeDomIdx++)
8454                   {
8455                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].k2 = \
8456                         *(timeDomAllocList->choice.setup->list.array[timeDomIdx]->k2);
8457                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].mappingType = \
8458                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->mappingType;
8459                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbolAndLength = \
8460                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8461                   }
8462                }
8463             }
8464          }
8465          if(cuPuschCfg->choice.setup->transformPrecoder)
8466             macPuschCfg->transformPrecoder = *(cuPuschCfg->choice.setup->transformPrecoder);
8467       }
8468    }
8469 }
8470
8471 /*******************************************************************
8472  *
8473  * @brief Function to fill pucch Power Control
8474  *
8475  * @details
8476  *
8477  *    Function : extractPucchPowerControl
8478  *
8479  *    Functionality: Function to fill pucch Power Control
8480  *
8481  * @params[in] PucchPowerControl *pwrCtrl,
8482  *             struct PUCCH_PowerControl *cuPwrCtrlCfg
8483  * @return void
8484  *
8485  * ****************************************************************/
8486
8487 void extractPucchPowerControl(PucchPowerControl *pwrCtrl, struct PUCCH_PowerControl *cuPwrCtrlCfg)
8488 {
8489    uint8_t arrIdx;
8490
8491    if(cuPwrCtrlCfg->deltaF_PUCCH_f0)
8492       pwrCtrl->deltaF_Format0 = *cuPwrCtrlCfg->deltaF_PUCCH_f0;
8493    if(cuPwrCtrlCfg->deltaF_PUCCH_f1)
8494       pwrCtrl->deltaF_Format1 = *cuPwrCtrlCfg->deltaF_PUCCH_f1;
8495    if(cuPwrCtrlCfg->deltaF_PUCCH_f2)
8496       pwrCtrl->deltaF_Format2 = *cuPwrCtrlCfg->deltaF_PUCCH_f2;
8497    if(cuPwrCtrlCfg->deltaF_PUCCH_f3)
8498       pwrCtrl->deltaF_Format3 = *cuPwrCtrlCfg->deltaF_PUCCH_f3;
8499    if(cuPwrCtrlCfg->deltaF_PUCCH_f4)
8500       pwrCtrl->deltaF_Format4 = *cuPwrCtrlCfg->deltaF_PUCCH_f4;
8501    if(cuPwrCtrlCfg->p0_Set)
8502    {
8503       pwrCtrl->p0SetCount = cuPwrCtrlCfg->p0_Set->list.count;
8504       for(arrIdx=0; arrIdx < pwrCtrl->p0SetCount; arrIdx++)
8505       {
8506          pwrCtrl->p0Set[arrIdx].p0PucchId =\
8507             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Id;
8508          pwrCtrl->p0Set[arrIdx].p0PucchVal =\
8509             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Value;
8510       }
8511    }
8512    if(cuPwrCtrlCfg->pathlossReferenceRSs)
8513    {
8514       pwrCtrl->pathLossRefRSListCount = cuPwrCtrlCfg->pathlossReferenceRSs->list.count;
8515       for(arrIdx = 0; arrIdx < pwrCtrl->pathLossRefRSListCount; arrIdx++)
8516       {
8517          pwrCtrl->pathLossRefRSList[arrIdx].pathLossRefRSId =\
8518             cuPwrCtrlCfg->pathlossReferenceRSs->list.array[arrIdx]->pucch_PathlossReferenceRS_Id;
8519       }
8520    }
8521 }
8522
8523  /*******************************************************************
8524  *
8525  * @brief Function to extractResrcSetToAddModList sent by CU
8526  *
8527  * @details
8528  *
8529  *    Function : extractResrcSetToAddModList
8530  *
8531  *    Functionality: Fucntion to extractResrcSetToAddModList
8532  *
8533  * @params[in] PucchResrcSetCfg pointer,
8534  *             struct PUCCH_Config__resourceSetToAddModList pointer
8535  * @return void
8536  *
8537  * ****************************************************************/
8538
8539 void extractResrcSetToAddModList(PucchResrcSetCfg *macRsrcSetList, struct PUCCH_Config__resourceSetToAddModList *cuRsrcSetList)
8540 {
8541    uint8_t arrIdx, rsrcListIdx;
8542
8543    macRsrcSetList->resrcSetToAddModListCount = cuRsrcSetList->list.count;
8544    for(arrIdx = 0; arrIdx < macRsrcSetList->resrcSetToAddModListCount; arrIdx++)
8545    {
8546       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcSetId     =\
8547          cuRsrcSetList->list.array[arrIdx]->pucch_ResourceSetId;
8548       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount =\
8549          cuRsrcSetList->list.array[arrIdx]->resourceList.list.count;
8550       for(rsrcListIdx = 0; rsrcListIdx < macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount; rsrcListIdx++)
8551       {
8552          macRsrcSetList->resrcSetToAddModList[arrIdx].resrcList[rsrcListIdx] =\
8553             *cuRsrcSetList->list.array[arrIdx]->resourceList.list.array[rsrcListIdx];
8554       }
8555       macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize =\
8556          *cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1;
8557    }
8558 }/* End of extractResrcSetToAddModList */
8559
8560 /*******************************************************************
8561  *
8562  * @brief Fills extractResrcToAddModList sent by CU
8563  *
8564  * @details
8565  *
8566  *    Function : extractResrcToAddModList
8567  *
8568  *    Functionality: Fills extractResrcToAddModList
8569  *
8570  * @params[in] PucchResrcCfg pointer,
8571  *             struct PUCCH_Config__resourceToAddModList pointer
8572  * @return ROk/RFAILED
8573  *
8574  * ****************************************************************/
8575
8576 uint8_t extractResrcToAddModList(PucchResrcCfg *macResrcList, struct PUCCH_Config__resourceToAddModList *cuResrcList)
8577 {
8578    uint8_t arrIdx;
8579
8580    macResrcList->resrcToAddModListCount = cuResrcList->list.count;
8581    for(arrIdx = 0; arrIdx < macResrcList->resrcToAddModListCount; arrIdx++)
8582    {
8583       macResrcList->resrcToAddModList[arrIdx].resrcId      =\
8584         cuResrcList->list.array[arrIdx]->pucch_ResourceId;
8585       macResrcList->resrcToAddModList[arrIdx].startPrb     =\
8586         cuResrcList->list.array[arrIdx]->startingPRB;
8587       if(cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping)
8588       {
8589          macResrcList->resrcToAddModList[arrIdx].intraFreqHop =\
8590            *cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping;
8591       }
8592       if(cuResrcList->list.array[arrIdx]->secondHopPRB)
8593       {
8594          macResrcList->resrcToAddModList[arrIdx].secondPrbHop =\
8595            *cuResrcList->list.array[arrIdx]->secondHopPRB;
8596       }
8597       /* PUCCH RSRC FORMAT */
8598       if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format0)
8599       {
8600          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_0;
8601          if(cuResrcList->list.array[arrIdx]->format.choice.format0)
8602          {
8603             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0, sizeof(PucchFormat0));
8604             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0 == NULLP)
8605             {
8606                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
8607                return RFAILED;
8608             }
8609             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->initialCyclicShift =\
8610                cuResrcList->list.array[arrIdx]->format.choice.format0->initialCyclicShift;
8611             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->numSymbols =\
8612                cuResrcList->list.array[arrIdx]->format.choice.format0->nrofSymbols;
8613             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->startSymbolIdx =\
8614                cuResrcList->list.array[arrIdx]->format.choice.format0->startingSymbolIndex;
8615          }
8616       }
8617       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format1)
8618       {
8619          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_1;
8620          if(cuResrcList->list.array[arrIdx]->format.choice.format1)
8621          {
8622             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1, sizeof(PucchFormat1));
8623             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1 == NULLP)
8624             {
8625                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
8626                return RFAILED;
8627             }
8628             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->initialCyclicShift =\
8629                 cuResrcList->list.array[arrIdx]->format.choice.format1->initialCyclicShift;
8630             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->numSymbols =\
8631                 cuResrcList->list.array[arrIdx]->format.choice.format1->nrofSymbols;
8632             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->startSymbolIdx =\
8633                 cuResrcList->list.array[arrIdx]->format.choice.format1->startingSymbolIndex;
8634             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->timeDomOCC =\
8635                 cuResrcList->list.array[arrIdx]->format.choice.format1->timeDomainOCC;
8636          }
8637       }
8638       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format2)
8639       {
8640          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_2;
8641          if(cuResrcList->list.array[arrIdx]->format.choice.format2)
8642          {
8643             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
8644             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2 == NULLP)
8645             {
8646                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
8647                return RFAILED;
8648             }
8649             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numPrbs =\
8650                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofPRBs;
8651             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numSymbols =\
8652                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofSymbols;
8653             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->startSymbolIdx =\
8654                 cuResrcList->list.array[arrIdx]->format.choice.format2->startingSymbolIndex;
8655          }
8656       }
8657       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format3)
8658       {
8659          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_3;
8660          if(cuResrcList->list.array[arrIdx]->format.choice.format3)
8661          {
8662             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
8663             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3 == NULLP)
8664             {
8665                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
8666                return RFAILED;
8667             }
8668             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numPrbs =\
8669                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofPRBs;
8670             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numSymbols =\
8671                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofSymbols;
8672             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->startSymbolIdx =\
8673                 cuResrcList->list.array[arrIdx]->format.choice.format3->startingSymbolIndex;
8674          }
8675       }
8676       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format4)
8677       {
8678          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_4;
8679          if(cuResrcList->list.array[arrIdx]->format.choice.format4)
8680          {
8681             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4, sizeof(PucchFormat4));
8682             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4 == NULLP)
8683             {
8684                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
8685                return RFAILED;
8686             }
8687             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->numSymbols =\
8688                 cuResrcList->list.array[arrIdx]->format.choice.format4->nrofSymbols;
8689             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occLen =\
8690                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Length;
8691             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occIdx =\
8692                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Index;
8693             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->startSymbolIdx =\
8694                 cuResrcList->list.array[arrIdx]->format.choice.format4->startingSymbolIndex;
8695          }
8696       }
8697    }
8698    return ROK;
8699
8700 }/* End of extractResrcToAddModList */
8701
8702 /*******************************************************************
8703  *
8704  * @brief Fills fillPucchSchedReqPeriodAndOffset sent by CU
8705  *
8706  * @details
8707  *
8708  *    Function : fillPucchSchedReqPeriodAndOffset
8709  *
8710  *    Functionality: To fillPucchSchedReqPeriodAndOffset
8711  *
8712  * @params[in] macPeriodicty,
8713  *     SchedulingRequestResourceConfig__periodicityAndOffset pointer
8714  * @return void
8715  *
8716  * ****************************************************************/
8717
8718 void fillPucchSchedReqPeriodAndOffset(uint8_t macPeriodicty, uint16_t  macOffset,\
8719    struct SchedulingRequestResourceConfig__periodicityAndOffset *cuPeriodicty)
8720 {
8721    macPeriodicty = cuPeriodicty->present;
8722    switch(macPeriodicty)
8723    {
8724       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
8725          {
8726             macOffset     = cuPeriodicty->choice.sym2;
8727             break;
8728          }
8729       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
8730          {
8731             macOffset     = cuPeriodicty->choice.sym6or7;
8732             break;
8733          }
8734       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
8735          {
8736             macOffset     = cuPeriodicty->choice.sl1;
8737             break;
8738          }
8739       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
8740          {
8741             macOffset = cuPeriodicty->choice.sl2;
8742             break;
8743          }
8744       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
8745          {
8746             macOffset = cuPeriodicty->choice.sl4;
8747             break;
8748          }
8749       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
8750          {
8751             macOffset = cuPeriodicty->choice.sl5;
8752             break;
8753          }
8754       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
8755          {
8756             macOffset = cuPeriodicty->choice.sl8;
8757             break;
8758          }
8759       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
8760          {
8761             macOffset = cuPeriodicty->choice.sl10;
8762             break;
8763          }
8764       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
8765          {
8766             macOffset = cuPeriodicty->choice.sl16;
8767             break;
8768          }
8769       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
8770          {
8771             macOffset = cuPeriodicty->choice.sl20;
8772             break;
8773          }
8774       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
8775          {
8776             macOffset = cuPeriodicty->choice.sl40;
8777             break;
8778          }
8779       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
8780          {
8781             macOffset = cuPeriodicty->choice.sl80;
8782             break;
8783          }
8784       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
8785          {
8786             macOffset = cuPeriodicty->choice.sl160;
8787             break;
8788          }
8789       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
8790          {
8791             macOffset = cuPeriodicty->choice.sl320;
8792             break;
8793          }
8794       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
8795          {
8796             macOffset = cuPeriodicty->choice.sl640;
8797             break;
8798          }
8799       default :
8800          DU_LOG("\nERROR  -->  F1AP : Invalid periodicity %d", macPeriodicty);
8801    }
8802 }
8803
8804 /*******************************************************************
8805  *
8806  * @brief Function to extractPucchFormatCfg sent by CU
8807  *
8808  * @details
8809  *
8810  *    Function : extractPucchFormatCfg
8811  *
8812  *    Functionality: Function to extractPucchFormatCfg
8813  *
8814  * @params[in] PucchFormatCfg pointer,
8815  *             PUCCH_FormatConfig_t pointer
8816  * @return void
8817  *
8818  * ****************************************************************/
8819
8820 void extractPucchFormatCfg(PucchFormatCfg *macFormatCfg, PUCCH_FormatConfig_t *cuFormatCfg)
8821  {
8822     if(cuFormatCfg->interslotFrequencyHopping)
8823        macFormatCfg->interSlotFreqHop = *cuFormatCfg->interslotFrequencyHopping;
8824     if(cuFormatCfg->additionalDMRS)
8825        macFormatCfg->addDmrs = *cuFormatCfg->additionalDMRS;
8826     if(cuFormatCfg->maxCodeRate)
8827        macFormatCfg->maxCodeRate = *cuFormatCfg->maxCodeRate;
8828     if(cuFormatCfg->nrofSlots)
8829        macFormatCfg->numSlots = *cuFormatCfg->nrofSlots;
8830     if(cuFormatCfg->pi2BPSK)
8831        macFormatCfg->pi2BPSK = *cuFormatCfg->pi2BPSK;
8832     if(cuFormatCfg->simultaneousHARQ_ACK_CSI)
8833        macFormatCfg->harqAckCSI = *cuFormatCfg->simultaneousHARQ_ACK_CSI;
8834  }/* End of extractPucchFormatCfg */
8835
8836 /*******************************************************************
8837  *
8838  * @brief Function to extractSchedReqCfgToAddMod sent by CU
8839  *
8840  * @details
8841  *
8842  *    Function : extractSchedReqCfgToAddMod
8843  *
8844  *    Functionality: Function to extractSchedReqCfgToAddMod
8845  *
8846  * @params[in] PucchSchedReqCfg pointer,
8847  *      PUCCH_Config__schedulingRequestResourceToAddModList pointer
8848  * @return void
8849  *
8850  * ****************************************************************/
8851
8852 void extractSchedReqCfgToAddMod(PucchSchedReqCfg *macSchedReqCfg, struct PUCCH_Config__schedulingRequestResourceToAddModList *cuSchedReqList)
8853 {
8854    uint8_t arrIdx;
8855
8856    macSchedReqCfg->schedAddModListCount = cuSchedReqList->list.count;
8857    for(arrIdx = 0; arrIdx <  macSchedReqCfg->schedAddModListCount; arrIdx++)
8858    {
8859       macSchedReqCfg->schedAddModList[arrIdx].resrcId =\
8860          cuSchedReqList->list.array[arrIdx]->schedulingRequestResourceId;
8861       macSchedReqCfg->schedAddModList[arrIdx].requestId =\
8862          cuSchedReqList->list.array[arrIdx]->schedulingRequestID;
8863       if(cuSchedReqList->list.array[arrIdx]->periodicityAndOffset)
8864       {
8865          fillPucchSchedReqPeriodAndOffset(macSchedReqCfg->schedAddModList[arrIdx].periodicity,\
8866             macSchedReqCfg->schedAddModList[arrIdx].offset, cuSchedReqList->list.array[arrIdx]->periodicityAndOffset);
8867       }
8868       if(cuSchedReqList->list.array[arrIdx]->resource)
8869       {
8870          macSchedReqCfg->schedAddModList[arrIdx].resrc =\
8871             *cuSchedReqList->list.array[arrIdx]->resource;
8872       }
8873    }
8874
8875 }/* End of extractSchedReqCfgToAddMod */
8876
8877  /*******************************************************************
8878  *
8879  * @brief Fills PucchCfg received by CU
8880  *
8881  * @details
8882  *
8883  *    Function : extractPucchCfg
8884  *
8885  *    Functionality: Fills PucchCfg received  by CU
8886  *
8887  * @params[in] BWP_UplinkDedicated__pucch_Config *cuPucchCfg = Information which
8888  *                is send by CU, which we have stored in F1UeContextSetupDb,
8889  *             PucchCfg *macPucchCfg = Used to Store the information which
8890  *                needs to send in other layer, as well as this can be the variable
8891  *                which stores the information in DuCb,
8892  *             PucchCfg *storedPucchCfg = Null in case of sending the
8893  *                information to other layer else it will have Pucch Cfg which
8894  *                we have stored in copyOfmacUeCfg.
8895  * @return ROK/RFAILED
8896  *
8897  * ****************************************************************/
8898
8899 uint8_t extractPucchCfg(struct BWP_UplinkDedicated__pucch_Config *cuPucchCfg, PucchCfg *macPucchCfg,\
8900 PucchCfg *storedPucchCfg)
8901 {
8902    uint8_t arrIdx;
8903
8904    if(cuPucchCfg->present == BWP_UplinkDedicated__pucch_Config_PR_setup)
8905    {
8906       if(cuPucchCfg->choice.setup)
8907       {
8908          /* Resource Set Cfg */
8909          if(cuPucchCfg->choice.setup->resourceSetToAddModList)
8910          {
8911             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrcSet, sizeof(PucchResrcSetCfg));
8912             if(macPucchCfg->resrcSet == NULLP)
8913             {
8914                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
8915                return RFAILED;
8916             }
8917             memset(macPucchCfg->resrcSet, 0, sizeof(PucchResrcSetCfg));
8918             extractResrcSetToAddModList(macPucchCfg->resrcSet, cuPucchCfg->choice.setup->resourceSetToAddModList);
8919          }
8920
8921          /* Resource Cfg */
8922          if(cuPucchCfg->choice.setup->resourceToAddModList)
8923          {
8924             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrc, sizeof(PucchResrcCfg));
8925             if(macPucchCfg->resrc == NULLP)
8926             {
8927                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
8928                return RFAILED;
8929             }
8930             memset(macPucchCfg->resrc, 0, sizeof(PucchResrcCfg));
8931             extractResrcToAddModList(macPucchCfg->resrc, cuPucchCfg->choice.setup->resourceToAddModList);
8932          }
8933
8934          /* Format 1 Cfg */
8935          if(cuPucchCfg->choice.setup->format1)
8936          {
8937             DU_ALLOC_SHRABL_BUF(macPucchCfg->format1, sizeof(PucchFormatCfg));
8938             if(macPucchCfg->format1 == NULLP)
8939             {
8940                DU_LOG("\nERROR --> F1AP : Failed to extract format 1 Cfg in  extractPucchCfg()");
8941                return RFAILED;
8942             }
8943             memset(macPucchCfg->format1, 0, sizeof(PucchFormatCfg));
8944             extractPucchFormatCfg(macPucchCfg->format1,\
8945                cuPucchCfg->choice.setup->format1->choice.setup);
8946          }
8947
8948          /* Format 2 Cfg */
8949          if(cuPucchCfg->choice.setup->format2)
8950          {
8951             DU_ALLOC_SHRABL_BUF(macPucchCfg->format2, sizeof(PucchFormatCfg));
8952             if(macPucchCfg->format2 == NULLP)
8953             {
8954                DU_LOG("\nERROR --> F1AP : Failed to extract format 2 Cfg in  extractPucchCfg()");
8955                return RFAILED;
8956             }
8957             memset(macPucchCfg->format2, 0, sizeof(PucchFormatCfg));
8958             extractPucchFormatCfg(macPucchCfg->format2,\
8959                cuPucchCfg->choice.setup->format2->choice.setup);
8960          }
8961
8962          /* Format 3 Cfg */
8963          if(cuPucchCfg->choice.setup->format3)
8964          {
8965             DU_ALLOC_SHRABL_BUF(macPucchCfg->format3, sizeof(PucchFormatCfg));
8966             if(macPucchCfg->format3 == NULLP)
8967             {
8968                DU_LOG("\nERROR --> F1AP : Failed to extract format 3 Cfg in  extractPucchCfg()");
8969                return RFAILED;
8970             }
8971             memset(macPucchCfg->format3, 0, sizeof(PucchFormatCfg));
8972             extractPucchFormatCfg(macPucchCfg->format3,\
8973                cuPucchCfg->choice.setup->format3->choice.setup);
8974          }
8975
8976          /* Format 4 Cfg */
8977          if(cuPucchCfg->choice.setup->format4)
8978          {
8979             DU_ALLOC_SHRABL_BUF(macPucchCfg->format4, sizeof(PucchFormatCfg));
8980             if(macPucchCfg->format4 == NULLP)
8981             {
8982                DU_LOG("\nERROR --> F1AP : Failed to extract format 4 Cfg in  extractPucchCfg()");
8983                return RFAILED;
8984             }
8985             memset(macPucchCfg->format4, 0, sizeof(PucchFormatCfg));
8986             extractPucchFormatCfg(macPucchCfg->format4,\
8987                cuPucchCfg->choice.setup->format4->choice.setup);
8988          }
8989
8990          /* Sched Req List */
8991          if(cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList)
8992          {
8993             DU_ALLOC_SHRABL_BUF(macPucchCfg->schedReq, sizeof(PucchSchedReqCfg));
8994             if(macPucchCfg->schedReq == NULLP)
8995             {
8996                DU_LOG("\nERROR --> F1AP : Failed to extract schedReqCfg in  extractPucchCfg()");
8997                return RFAILED;
8998             }
8999             memset(macPucchCfg->schedReq, 0, sizeof(PucchSchedReqCfg));
9000             extractSchedReqCfgToAddMod(macPucchCfg->schedReq,\
9001             cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList);
9002          }
9003
9004          /*TODO: Add support for  Spatial Info */
9005
9006          /* MultiCsiCfg */
9007          if(cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList)
9008          {
9009             DU_ALLOC_SHRABL_BUF(macPucchCfg->multiCsiCfg, sizeof(PucchMultiCsiCfg));
9010             if(macPucchCfg->multiCsiCfg == NULLP)
9011             {
9012                DU_LOG("\nERROR --> F1AP : Failed to extract multiCsiCfg in  extractPucchCfg()");
9013                return RFAILED;
9014             }
9015             memset(macPucchCfg->multiCsiCfg, 0, sizeof(PucchMultiCsiCfg));
9016             macPucchCfg->multiCsiCfg->multiCsiResrcListCount = cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.count;
9017             for(arrIdx =0; arrIdx < macPucchCfg->multiCsiCfg->multiCsiResrcListCount; arrIdx++)
9018             {
9019                macPucchCfg->multiCsiCfg->multiCsiResrcList[arrIdx] =\
9020                  *cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.array[arrIdx];
9021             }
9022          }
9023
9024          /* Dl_DataToUL_ACK */
9025          if(cuPucchCfg->choice.setup->dl_DataToUL_ACK)
9026     {
9027        if(storedPucchCfg)
9028        {
9029           if(storedPucchCfg->dlDataToUlAck)
9030           {
9031              macPucchCfg->dlDataToUlAck = storedPucchCfg->dlDataToUlAck;
9032           }
9033           else
9034           {
9035             DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
9036           }
9037        }
9038        else
9039        {
9040           DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
9041        }
9042        if(macPucchCfg->dlDataToUlAck == NULLP)
9043        {
9044           DU_LOG("\nERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
9045           return RFAILED;
9046        }
9047        memset(macPucchCfg->dlDataToUlAck, 0, sizeof(PucchDlDataToUlAck));
9048        macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount = cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.count;
9049        for(arrIdx = 0; arrIdx < macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount; arrIdx++)
9050        {
9051           macPucchCfg->dlDataToUlAck->dlDataToUlAckList[arrIdx] =\
9052           *cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.array[arrIdx];
9053        }
9054          }
9055
9056          /* Power Control */
9057          if(cuPucchCfg->choice.setup->pucch_PowerControl)
9058          {
9059             DU_ALLOC_SHRABL_BUF(macPucchCfg->powerControl, sizeof(PucchPowerControl));
9060             if(macPucchCfg->powerControl == NULLP)
9061             {
9062                DU_LOG("\nERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
9063                return RFAILED;
9064             }
9065             extractPucchPowerControl(macPucchCfg->powerControl,\
9066                cuPucchCfg->choice.setup->pucch_PowerControl);
9067          }
9068       }
9069    }
9070    return ROK;
9071 }
9072
9073 /*******************************************************************
9074  *
9075  * @brief Fills ServingCellReconfig received by CU
9076  *
9077  * @details
9078  *
9079  *    Function : extractSpCellDedicatedCfg
9080  *
9081  *    Functionality: Fills ServingCellReconfig received  by CU
9082  *
9083  * @params[in] ServingCellConfig_t *cuSrvCellCfg = Information which is send by
9084  *                  CU, which we have stored in F1UeContextSetupDb,
9085  *             ServCellCfgInfo *macSrvCellCfg = Used to Store the information
9086  *                  which  needs to send in other layer, as well as this can be the
9087  *                  variable which stores the information in DuCb,
9088  *             ServCellCfgInfo *storedSrvCellCfg = Null in case of sending the
9089  *                  information to other layer else it will have ServCellCfgInfo which
9090  *                  we have stored in copyOfmacUeCfg.
9091  * @return ROK/RFAILD
9092  *
9093  * ****************************************************************/
9094 uint8_t extractSpCellDedicatedCfg(ServingCellConfig_t *cuSrvCellCfg, ServCellCfgInfo *macSrvCellCfg,\
9095 ServCellCfgInfo *storedSrvCellCfg)
9096 {
9097    uint8_t ret = ROK;
9098    BWP_DownlinkDedicated_t *dlBwp = NULLP;
9099    BWP_UplinkDedicated_t   *ulBwp = NULLP;
9100
9101    if(cuSrvCellCfg->initialDownlinkBWP)
9102    {
9103       dlBwp = ((BWP_DownlinkDedicated_t *)(cuSrvCellCfg->initialDownlinkBWP));
9104       if(dlBwp->pdcch_Config)
9105       {
9106          if(dlBwp->pdcch_Config->choice.setup)
9107          {
9108             macSrvCellCfg->initDlBwp.pdcchPresent = true;
9109             extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
9110          }
9111       }
9112       if(dlBwp->pdsch_Config)
9113       {
9114          if(dlBwp->pdsch_Config->choice.setup)
9115          {
9116             macSrvCellCfg->initDlBwp.pdschPresent = true;
9117
9118             if(storedSrvCellCfg)
9119             {
9120                if(!storedSrvCellCfg->initDlBwp.pdschPresent)
9121                {
9122                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
9123                }
9124                else
9125                {
9126                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg,\
9127                         &storedSrvCellCfg->initDlBwp.pdschCfg);
9128                }
9129             }
9130             else
9131             {
9132                extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
9133             }
9134          }
9135       }
9136    }
9137    if(cuSrvCellCfg->firstActiveDownlinkBWP_Id)
9138       macSrvCellCfg->firstActvDlBwpId = *(cuSrvCellCfg->firstActiveDownlinkBWP_Id);
9139    if(cuSrvCellCfg->defaultDownlinkBWP_Id)
9140       macSrvCellCfg->defaultDlBwpId = *(cuSrvCellCfg->defaultDownlinkBWP_Id);
9141    if(cuSrvCellCfg->bwp_InactivityTimer)
9142    {
9143       if(macSrvCellCfg->bwpInactivityTmr)
9144       {
9145          memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
9146       }
9147       else
9148       {
9149          macSrvCellCfg->bwpInactivityTmr = NULLP;
9150          DU_ALLOC_SHRABL_BUF(macSrvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
9151          if(macSrvCellCfg->bwpInactivityTmr)
9152          {
9153             memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
9154          }
9155          else
9156          {
9157             DU_LOG("\nERROR  --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
9158             return RFAILED;
9159          }
9160       }
9161    }
9162    if(cuSrvCellCfg->pdsch_ServingCellConfig)
9163    {
9164       if(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup)
9165       {
9166          ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
9167          if(ret == RFAILED)
9168          {
9169             DU_LOG("\nERROR --> F1AP : Failed at extractPdschServingCellCfg()");
9170             return RFAILED;
9171          }
9172       }
9173    }
9174    if(cuSrvCellCfg->uplinkConfig)
9175    {
9176       if(cuSrvCellCfg->uplinkConfig->initialUplinkBWP)
9177       {
9178          ulBwp = ((BWP_UplinkDedicated_t *)(cuSrvCellCfg->uplinkConfig->initialUplinkBWP));
9179          if(ulBwp->pusch_Config)
9180          {
9181             macSrvCellCfg->initUlBwp.puschPresent = true;
9182             extractPuschCfg(ulBwp->pusch_Config, &macSrvCellCfg->initUlBwp.puschCfg);
9183          }
9184          if(ulBwp->pucch_Config)
9185          {
9186             macSrvCellCfg->initUlBwp.pucchPresent = true;
9187             memset(&macSrvCellCfg->initUlBwp.pucchCfg, 0, sizeof(PucchCfg));
9188             if(storedSrvCellCfg)
9189             {
9190                if(!storedSrvCellCfg->initUlBwp.pucchPresent)
9191                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
9192                else
9193                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg,\
9194                   &storedSrvCellCfg->initUlBwp.pucchCfg);
9195             }
9196             else
9197             {
9198                extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
9199             }
9200          }
9201       }
9202       if(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id)
9203          macSrvCellCfg->firstActvUlBwpId = *(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id);
9204    }
9205    return ret;
9206 }
9207 /*******************************************************************
9208  *
9209  * @brief Fills Reconfig Cell group Info received by CU
9210  *
9211  * @details
9212  *
9213  *    Function : extractUeReCfgCellInfo
9214  *
9215  *    Functionality: Fills Reconfig Cell group Info received by CU
9216  *
9217  * @params[in] CellGroupConfigRrc_t *cellGrp = CellGroupConfigRrc_t information which
9218  *                       is send by CU, which we have stored in F1UeContextSetupDb
9219  *             MacUeCfg *MacUeCfg = Used to Store the information,
9220  *                      which needs to send in other layer, as well as this can be
9221  *                      the variable which stores the information in DuCb,
9222  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
9223  *                      information to other layer else it will have copyOfmacUeCfg
9224  *                      which we have stored in F1UeContextSetupDb.
9225  *
9226  * @return ROK/RFAILED
9227  *
9228  * ****************************************************************/
9229 uint8_t extractUeReCfgCellInfo(CellGroupConfigRrc_t *cellGrp, MacUeCfg *macUeCfg, MacUeCfg *storedMacUeCfg)
9230 {
9231    uint8_t ret = ROK;
9232    MAC_CellGroupConfig_t     *macCellGroup = NULLP;
9233    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
9234    SpCellConfig_t            *spcellCfg = NULLP;
9235    ServingCellConfig_t       *servCellCfg = NULLP;
9236
9237    if(cellGrp)
9238    {
9239       /* Fill MacCell Group Reconfig  */
9240       if(cellGrp->mac_CellGroupConfig)
9241       {
9242          macUeCfg->macCellGrpCfgPres = true;
9243          macCellGroup = ((MAC_CellGroupConfig_t *)(cellGrp->mac_CellGroupConfig));
9244          if(macCellGroup->schedulingRequestConfig)
9245          {
9246             extractSchReqReConfig(macCellGroup->schedulingRequestConfig, &macUeCfg->macCellGrpCfg.schReqCfg);
9247          }
9248          if(macCellGroup->tag_Config)
9249          {
9250             extractTagReconfig(macCellGroup->tag_Config, &macUeCfg->macCellGrpCfg.tagCfg);
9251          }
9252          if(macCellGroup->bsr_Config)
9253          {
9254             macUeCfg->macCellGrpCfg.bsrTmrCfg.periodicTimer = macCellGroup->bsr_Config->periodicBSR_Timer;
9255             macUeCfg->macCellGrpCfg.bsrTmrCfg.retxTimer     = macCellGroup->bsr_Config->retxBSR_Timer;
9256             if(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer)
9257             {
9258                macUeCfg->macCellGrpCfg.bsrTmrCfg.srDelayTimer  =\
9259                *(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer);
9260             }
9261          }
9262          if(macCellGroup->phr_Config)
9263          {
9264             if(macCellGroup->phr_Config->present == MAC_CellGroupConfig__phr_Config_PR_setup)
9265             {
9266                macUeCfg->macCellGrpCfg.phrCfgSetupPres = true;
9267                if(macCellGroup->phr_Config->choice.setup)
9268                {
9269                   macUeCfg->macCellGrpCfg.phrCfg.periodicTimer     = \
9270                   macCellGroup->phr_Config->choice.setup->phr_PeriodicTimer;
9271                   macUeCfg->macCellGrpCfg.phrCfg.prohibitTimer     = \
9272                   macCellGroup->phr_Config->choice.setup->phr_ProhibitTimer;
9273                   macUeCfg->macCellGrpCfg.phrCfg.txPowerFactor     = \
9274                   macCellGroup->phr_Config->choice.setup->phr_Tx_PowerFactorChange;
9275                   macUeCfg->macCellGrpCfg.phrCfg.multiplePHR       = \
9276                   macCellGroup->phr_Config->choice.setup->multiplePHR;
9277                   macUeCfg->macCellGrpCfg.phrCfg.dummy             = \
9278                   macCellGroup->phr_Config->choice.setup->dummy;
9279                   macUeCfg->macCellGrpCfg.phrCfg.phrType2OtherCell = \
9280                   macCellGroup->phr_Config->choice.setup->phr_Type2OtherCell;
9281                   macUeCfg->macCellGrpCfg.phrCfg.phrOtherCG        = \
9282                   macCellGroup->phr_Config->choice.setup->phr_ModeOtherCG;
9283                }
9284             }
9285          }
9286       }
9287       /* Fill Physical Cell Group Reconfig */
9288       if(cellGrp->physicalCellGroupConfig)
9289       {
9290          macUeCfg->phyCellGrpCfgPres = true;
9291          phyCellGrpCfg = ((PhysicalCellGroupConfig_t *)(cellGrp->physicalCellGroupConfig));
9292          if(phyCellGrpCfg->p_NR_FR1)
9293          {
9294             if(*(phyCellGrpCfg->p_NR_FR1) != macUeCfg->phyCellGrpCfg.pNrFr1)
9295                macUeCfg->phyCellGrpCfg.pNrFr1 = *(phyCellGrpCfg->p_NR_FR1);
9296          }
9297          macUeCfg->phyCellGrpCfg.pdschHarqAckCodebook = phyCellGrpCfg->pdsch_HARQ_ACK_Codebook;
9298       }
9299       /* Fill SpCell Reconfig */
9300       if(cellGrp->spCellConfig)
9301       {
9302          macUeCfg->spCellCfgPres = true;
9303          spcellCfg = ((SpCellConfig_t *)(cellGrp->spCellConfig));
9304          if(spcellCfg->servCellIndex)
9305          {
9306             macUeCfg->spCellCfg.servCellIdx = *(spcellCfg->servCellIndex);
9307          }
9308          /* Fill Serving cell Reconfig info */
9309          if(cellGrp->spCellConfig->spCellConfigDedicated)
9310          {
9311             servCellCfg = ((ServingCellConfig_t *)(cellGrp->spCellConfig->spCellConfigDedicated));
9312             if(storedMacUeCfg)
9313             {
9314                if(!storedMacUeCfg->spCellCfgPres)
9315                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
9316                else
9317                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg,\
9318                         &storedMacUeCfg->spCellCfg.servCellCfg);
9319             }
9320             else
9321             {
9322                ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
9323             }
9324             if(ret == RFAILED)
9325             {
9326                DU_LOG("\nERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
9327             }
9328          }
9329       }
9330    }
9331    return ret;
9332 }
9333 /*******************************************************************
9334 *
9335 * @brief free the memory allocated by decoder
9336 *
9337 * @details
9338 *
9339 *    Function : freeAperDecodeNrcgi
9340 *
9341 *    Functionality: Free Nrcgi values
9342 *
9343 * @params[in] NRCGI_t *nrcgi
9344 * @return void
9345 *
9346 * ****************************************************************/
9347
9348
9349 void freeAperDecodeNrcgi(NRCGI_t *nrcgi)
9350 {
9351     if(nrcgi->pLMN_Identity.buf != NULLP)
9352     {
9353        free(nrcgi->pLMN_Identity.buf);
9354     }
9355     if(nrcgi->nRCellIdentity.buf != NULLP)
9356     {
9357        free(nrcgi->nRCellIdentity.buf);
9358     }
9359 }
9360 /*******************************************************************
9361 *
9362 * @brief free the memory allocated by decoder
9363 *
9364 * @details
9365 *
9366 *    Function : freeAperDecodeCuToDuInfo
9367 *
9368 *    Functionality:  Free Cu To Du Information
9369 *
9370 * @params[in] CUtoDURRCInformation_t *rrcMsg
9371 * @return void
9372 *
9373 * ****************************************************************/
9374
9375
9376 void freeAperDecodeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
9377 {
9378    uint8_t ieIdx =0;
9379    uint8_t arrIdx =0;
9380
9381    if(rrcMsg->uE_CapabilityRAT_ContainerList)
9382    {
9383       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
9384          free(rrcMsg->uE_CapabilityRAT_ContainerList->buf);
9385       free(rrcMsg->uE_CapabilityRAT_ContainerList);
9386    }
9387
9388    if(rrcMsg->iE_Extensions)
9389    {
9390       if(rrcMsg->iE_Extensions->list.array)
9391       {
9392          for(ieIdx= 0; ieIdx < rrcMsg->iE_Extensions->list.count; ieIdx++)
9393          {
9394             if(rrcMsg->iE_Extensions->list.array[ieIdx])
9395             {
9396                switch(rrcMsg->iE_Extensions->list.array[ieIdx]->id)
9397                {
9398                   case ProtocolIE_ID_id_CellGroupConfig:
9399                      if(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
9400                      {
9401                         free(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf);
9402                      }
9403                      break;
9404                   default:
9405                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
9406                            rrcMsg->iE_Extensions->list.array[ieIdx]->id);
9407                      break;
9408                }
9409             }
9410          }
9411          for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
9412          {
9413             free(rrcMsg->iE_Extensions->list.array[arrIdx]);
9414          }
9415          free(rrcMsg->iE_Extensions->list.array);
9416
9417       }
9418
9419       free(rrcMsg->iE_Extensions);
9420    }
9421 }
9422 /*******************************************************************
9423 *
9424 * @brief free the memory allocated by decoder
9425 *
9426 * @details
9427 *
9428 *    Function : freeAperDecodeSplCellList
9429 *
9430 *    Functionality: Free Spl Cell List
9431                     where memory allocated by aper_decoder
9432 *
9433 * @params[in]  SCell_ToBeSetup_List_t *spCellLst
9434 * @return void
9435 *
9436 * ****************************************************************/
9437
9438
9439 void freeAperDecodeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
9440 {
9441     uint8_t  cellIdx =0;
9442
9443     if(spCellLst->list.array != NULLP)
9444     {
9445        for(cellIdx=0; cellIdx<spCellLst->list.count; cellIdx++)
9446        {
9447           if(cellIdx==0&&spCellLst->list.array[cellIdx]!=NULLP)
9448           {
9449              freeAperDecodeNrcgi(&spCellLst->list.array[cellIdx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
9450           }
9451           if(spCellLst->list.array[cellIdx]!=NULLP)
9452           {
9453              free(spCellLst->list.array[cellIdx]);
9454           }
9455        }
9456        free(spCellLst->list.array);
9457     }
9458 }
9459 /*******************************************************************
9460 *
9461 * @brief free the memory allocated by decoder
9462 *
9463 * @details
9464 *
9465 *    Function : freeAperDecodeSRBSetup
9466 *
9467 *    Functionality: added free part for the memory allocated by aper_decoder
9468 *
9469 * @params[in] SRBs_ToBeSetup_List_t *srbSet
9470 * @return void
9471 *
9472 ****************************************************************/
9473
9474
9475 void freeAperDecodeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
9476 {
9477     uint8_t srbIdx =0;
9478     if(srbSet->list.array != NULLP)
9479     {
9480        for(srbIdx=0; srbIdx<srbSet->list.count; srbIdx++)
9481        {
9482           if(srbSet->list.array[srbIdx]!=NULLP)
9483           {
9484              free(srbSet->list.array[srbIdx]);
9485           }
9486        }
9487        free(srbSet->list.array);
9488     }
9489 }
9490
9491 /*******************************************************************
9492 *
9493 * @brief free the memory allocated by decoder
9494 *
9495 * @details
9496 *
9497 *    Function : freeAperDecodeULTnlInfo
9498 *
9499 *    Functionality: added free part for the memory allocated by aper_decoder
9500 *
9501 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
9502 * @return void
9503 *
9504 * ****************************************************************/
9505
9506
9507 void freeAperDecodeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
9508 {
9509    uint8_t ulIdx=0;
9510    if(ulInfo->list.array != NULLP)
9511    {
9512       for(ulIdx=0; ulIdx<ulInfo->list.count; ulIdx++)
9513       {
9514          if(ulIdx==0&&ulInfo->list.array[ulIdx]!=NULLP)
9515          {
9516             if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
9517             {
9518                if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9519                      transportLayerAddress.buf != NULLP)
9520                {
9521                   if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
9522                         !=NULLP)
9523                   {
9524                      free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf);
9525                   }
9526                   free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9527                         transportLayerAddress.buf);
9528                }
9529                free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel);
9530             }
9531          }
9532          if(ulInfo->list.array[ulIdx]!=NULLP)
9533          {
9534             free(ulInfo->list.array[ulIdx]);
9535          }
9536       }
9537       free(ulInfo->list.array);
9538    }
9539 }
9540 /*******************************************************************
9541 *
9542 * @brief free the memory allocated by decoder
9543 *
9544 * @details
9545 *
9546 *    Function : freeAperDecodeDRBSetup
9547 *
9548 *    Functionality: free DRBSetup which is allocated by decoder
9549 *
9550 * @params[in]  DRBs_ToBeSetup_List_t *drbSet
9551 * @return void
9552 *
9553 * ****************************************************************/
9554
9555 void freeAperDecodeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
9556 {
9557    DRBs_ToBeSetup_Item_t *drbSetItem = NULLP;
9558    uint8_t  flowIdx =0;
9559    uint8_t  drbIdx =0;
9560
9561    if(drbSet->list.array != NULLP)
9562    {
9563       for(drbIdx=0; drbIdx<drbSet->list.count; drbIdx++)
9564       {
9565          if(drbIdx==0&&drbSet->list.array[drbIdx] != NULLP)
9566          {
9567             drbSetItem =&drbSet->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
9568             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
9569             {
9570                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9571                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
9572                {
9573                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9574                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9575                   {
9576                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9577                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9578                      {
9579
9580                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
9581                         {
9582
9583                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
9584                            {
9585
9586                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->\
9587                                     buf!=NULLP)
9588                               {
9589
9590                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
9591                                        flows_Mapped_To_DRB_List.list.array != NULLP)
9592                                  {
9593
9594                                     for(flowIdx=0;flowIdx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9595                                           DRB_Information.flows_Mapped_To_DRB_List.list.count; flowIdx++)
9596                                     {
9597
9598                                        if(flowIdx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9599                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9600                                        {
9601                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9602                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9603                                                 qoSFlowLevelQoSParameters.\
9604                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
9605                                           {
9606                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9607                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9608                                                    qoSFlowLevelQoSParameters.\
9609                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9610                                              {
9611
9612                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9613                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9614                                                       qoSFlowLevelQoSParameters.\
9615                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9616                                                 {
9617
9618
9619                                                    free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9620                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9621                                                          qoSFlowLevelQoSParameters.\
9622                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9623                                                 }
9624
9625                                                 free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9626                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9627                                                       qoSFlowLevelQoSParameters.\
9628                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9629                                              }
9630
9631                                              free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9632
9633                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9634                                                    qoSFlowLevelQoSParameters.\
9635                                                    qoS_Characteristics.choice.non_Dynamic_5QI);
9636                                           }
9637                                        }
9638                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9639                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9640                                        {
9641
9642                                           free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9643                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]);
9644                                        }
9645                                     }
9646
9647                                     free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9648                                           DRB_Information.flows_Mapped_To_DRB_List.list.array);
9649                                  }
9650
9651                                  free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9652                                        DRB_Information.sNSSAI.sD->buf);
9653                               }
9654
9655                               free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD);
9656                            }
9657
9658                            free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf);
9659
9660                         }
9661
9662                         free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9663
9664                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9665                      }
9666
9667                      free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9668                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9669                   }
9670
9671                   free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9672                         qoS_Characteristics.choice.non_Dynamic_5QI);
9673                }
9674                free(drbSetItem->qoSInformation.choice.choice_extension);
9675             }
9676             freeAperDecodeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
9677             if(drbSetItem->uLConfiguration)
9678             {
9679                free(drbSetItem->uLConfiguration);
9680             }
9681          }
9682          if(drbSet->list.array[drbIdx]!=NULLP)
9683          {
9684             free(drbSet->list.array[drbIdx]);
9685          }
9686       }
9687       free(drbSet->list.array);
9688    }
9689 }
9690
9691
9692 /*******************************************************************
9693  *
9694  * @brief builds Mac Cell Cfg
9695  *
9696  * @details
9697  *
9698  *    Function : procUeReCfgCellInfo
9699  *
9700  *    Functionality: builds Mac Cell Cfg
9701  *
9702  * @params[in] MacUeCfg *macUeCfgToSend = Used to Store the information which
9703  *                       needs to send in other layer, as well as this can be
9704  *                       the variable which stores the information in DuCb.
9705  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
9706  *                       information to other layer else it will have copyOfmacUeCfg
9707  *                       which we have stored in F1UeContextSetupDb
9708  *             void *cellInfo = CellGroupConfigRrc_t information which is send
9709  *                        by CU, which we have stored in F1UeContextSetupDb
9710  *
9711  * @return void
9712  *
9713  * ****************************************************************/
9714 uint8_t procUeReCfgCellInfo(MacUeCfg *macUeCfgToSend,MacUeCfg *storedMacUeCfg, void *cellInfo)
9715 {
9716    uint8_t ret = ROK;
9717    CellGroupConfigRrc_t *cellGrp = NULLP;
9718
9719    if(cellInfo)
9720    {
9721       cellGrp = (CellGroupConfigRrc_t *)cellInfo;
9722       ret = extractUeReCfgCellInfo(cellGrp, macUeCfgToSend, storedMacUeCfg);
9723       if(ret == RFAILED)
9724          DU_LOG("\nERROR  -->  F1AP : Failed at procUeReCfgCellInfo()");
9725    }
9726    if(ret == RFAILED)
9727    {
9728       freeUeReCfgCellGrpInfo(macUeCfgToSend);
9729    }
9730    return ret;
9731 }
9732
9733 /*******************************************************************
9734  *
9735  * @brief Filling modulation info in mac ue cfg
9736  *
9737  * @details
9738  *
9739  *    Function : duFillModulationDetails
9740  *
9741  *    Functionality: Filling modulation info in mac ue cfg
9742  *
9743  * @params[in] MAC UE Config to be updated
9744  *             Current UE configuration
9745  *             UE NR capability from CU
9746  * @return ROK     - success
9747  *         RFAILED - failure
9748  *
9749  * ****************************************************************/
9750 void duFillModulationDetails(MacUeCfg *ueCfg, MacUeCfg *oldUeCfg, void *ueCap)
9751 {
9752    UE_NR_Capability_t *ueNrCap=NULLP;
9753
9754    if(!ueCap)
9755    {
9756       memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9757       memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9758    }
9759    else
9760    {
9761       ueNrCap = (UE_NR_Capability_t *)ueCap;
9762
9763       /* Filling DL modulation info */
9764       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsDownlinkPerCC && \
9765          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0] && \
9766          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL)
9767       {
9768          switch(*(ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL))
9769          {
9770             case ModulationOrder_qpsk:
9771                {
9772                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
9773                   break;
9774                }
9775             case ModulationOrder_qam16:
9776                {
9777                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM16;
9778                   break;
9779                }
9780             case ModulationOrder_qam64:
9781                {
9782                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM64;
9783                   ueCfg->dlModInfo.mcsIndex = PDSCH_MCS_INDEX;
9784                   ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64;
9785                   break;
9786                }
9787             case ModulationOrder_qam256:
9788                {
9789                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM256;
9790                   break;
9791                }
9792             default:
9793                {
9794                   DU_LOG("\nERROR  -->  DU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
9795                   memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9796                   break;
9797                }
9798          }
9799       }
9800       else
9801       {
9802          memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9803       }
9804
9805       /* Filling UL modulation info */
9806       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsUplinkPerCC && \
9807          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0] && \
9808          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL)
9809       {
9810          switch(*(ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL))
9811          {
9812             case ModulationOrder_qpsk:
9813                {
9814                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
9815                   break;
9816                }
9817             case ModulationOrder_qam16:
9818                {
9819                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM16;
9820                   ueCfg->ulModInfo.mcsIndex = PUSCH_MCS_INDEX;
9821                   ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64;
9822                   break;
9823                }
9824             case ModulationOrder_qam64:
9825                {
9826                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM64;
9827                   break;
9828                }
9829             case ModulationOrder_qam256:
9830                {
9831                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM256;
9832                   break;
9833                }
9834             default:
9835                {
9836                   DU_LOG("\nERROR  -->  DU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
9837                   memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9838                   break;
9839                }
9840          }
9841       }
9842       else
9843       {
9844          memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9845       }
9846    }
9847 }
9848
9849 /*******************************************************************
9850  *
9851  * @brief Function to extract cellGrp Info present in cutoDu cont
9852  *
9853  * @details
9854  *
9855  *    Function : extractCellGrpInfo
9856  *
9857  *    Functionality: Function to extract cellGrp Info present
9858  *                   in cutoDu cont
9859  *
9860  * @params[in] ProtocolExtensionContainer_4624P16_t pointer
9861  *
9862  * @return CellGroupConfigRrc_t *
9863  *
9864  * ****************************************************************/
9865
9866 CellGroupConfigRrc_t *extractCellGrpInfo(ProtocolExtensionContainer_4624P16_t *protocolIeExtn,\
9867       DuUeCfg *ueCfgDb)
9868 {
9869    uint8_t idx2 =0;
9870    uint16_t id =0;
9871    uint16_t recvBufLen =0;
9872    CellGroupConfigRrc_t *cellGrpCfg = NULLP;
9873    CUtoDURRCInformation_ExtIEs_t *extIeInfo = NULLP;
9874    asn_dec_rval_t rval; /* Decoder return value */
9875    memset(&rval, 0, sizeof(asn_dec_rval_t));
9876
9877    if(protocolIeExtn)
9878    {
9879       for(idx2 = 0; idx2 < protocolIeExtn->list.count; idx2++)
9880       {
9881          extIeInfo = ((CUtoDURRCInformation_ExtIEs_t *)(protocolIeExtn->list.array[idx2]));
9882          id = extIeInfo->id;
9883          switch(id)
9884          {
9885             case ProtocolIE_ID_id_CellGroupConfig:
9886             {
9887                recvBufLen = extIeInfo->extensionValue.choice.CellGroupConfig.size;
9888                /* decoding the CellGroup Buf received */
9889                DU_ALLOC(cellGrpCfg, sizeof(CellGroupConfigRrc_t));
9890                if(cellGrpCfg)
9891                {
9892                   memset(cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
9893                   rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfg,
9894                      extIeInfo->extensionValue.choice.CellGroupConfig.buf, recvBufLen, 0, 0);
9895                   if(rval.code == RC_FAIL || rval.code == RC_WMORE)
9896                   {
9897                      DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
9898                      return NULLP;
9899                   }
9900                   xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfg);
9901                   if(extractRlcCfgToAddMod(cellGrpCfg->rlc_BearerToAddModList, ueCfgDb))
9902                      return NULLP;
9903                }
9904                break;
9905             }
9906             default:
9907                DU_LOG("\nERROR  -->  F1AP : Invalid IE received CUtoDURRCInformation:%d at decodeCellGrpCfg()", id);
9908                break;
9909          }
9910       }
9911    }
9912    return cellGrpCfg;
9913 }
9914
9915 /*******************************************************************
9916  *
9917  * @brief Fills Srb List received by CU
9918  *
9919  * @details
9920  *
9921  *    Function : procSrbListToSetup
9922  *
9923  *    Functionality: Fills Srb List received  by CU
9924  *
9925  * @params[in] SRBs_ToBeSetup_Item_t *cuSrbItem
9926  *             LcCfg pointer
9927  *             RlcBearerCfg pointer
9928  * @return void
9929  *
9930  * ****************************************************************/
9931 uint8_t procSrbListToSetup(SRBs_ToBeSetup_Item_t * srbItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd)
9932 {
9933    uint8_t ret = ROK;
9934
9935    /* Filling RLC INFO */
9936    procRlcLcCfg(srbItem->sRBID, srbItem->sRBID, RB_TYPE_SRB, RLC_AM, CONFIG_ADD, NULL, rlcLcToAdd);
9937
9938    /* Filling MAC INFO */
9939    ret = procMacLcCfg(srbItem->sRBID, RB_TYPE_SRB, CONFIG_ADD, NULL,NULL, NULL, macLcToAdd, NULL);
9940    if(ret == RFAILED)
9941    {
9942       DU_LOG("\nERROR  -->  F1AP : Failed at MAC LC Cfg in procSrbListToSetup()");
9943       return ret;
9944    }
9945    return ret;
9946 }
9947
9948
9949
9950 /*******************************************************************
9951  *
9952  * @brief extract Srb List received by CU
9953  *
9954  * @details
9955  *
9956  *    Function : extractSrbListToSetup
9957  *
9958  *    Functionality: extract Srb List received by CU
9959  *                   for both MAC and RLC
9960  *
9961  * @params[in] SRBs_ToBeSetup_Item_t pointer
9962  *             DuUeCfg pointer
9963  * @return ROK/RFAIED
9964  *
9965  * ****************************************************************/
9966
9967 uint8_t extractSrbListToSetup(SRBs_ToBeSetup_List_t *srbCfg, DuUeCfg *ueCfgDb)
9968 {
9969    uint8_t ret, srbIdx;
9970    SRBs_ToBeSetup_Item_t *srbItem = NULLP;
9971
9972    if(srbCfg)
9973    {
9974       for(srbIdx = 0; srbIdx < srbCfg->list.count; srbIdx++)
9975       {
9976          srbItem = &srbCfg->list.array[srbIdx]->value.choice.SRBs_ToBeSetup_Item;
9977          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
9978          {
9979             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in MAC");
9980             ret = RFAILED;
9981             break;
9982          }
9983          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
9984          {
9985             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in RLC");
9986             ret = RFAILED;
9987             break;
9988          }
9989          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
9990          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
9991          ret = procSrbListToSetup(srbItem, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
9992             &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs]);
9993          ueCfgDb->numRlcLcs++;
9994          ueCfgDb->numMacLcs++;
9995          if(ret == RFAILED)
9996          {
9997             DU_LOG("\nERROR  -->  F1AP:  Failed at extractSrbListToSetup()");
9998             break;
9999          }
10000       }
10001    }
10002    else
10003       ret = RFAILED;
10004
10005    return ret;
10006 }
10007
10008 /*******************************************************************
10009  *
10010  * @brief Fills Drb List received by CU
10011  *
10012  * @details
10013  *
10014  *    Function : procDrbListToSetup
10015  *
10016  *    Functionality: Fills Drb List received by CU
10017  *                   for both MAC and RLC
10018  *
10019  * @params[in] SRBs_ToBeSetup_Item_t pointer
10020  *             LcCfg pointer,
10021  *             RlcBearerCfg pointer
10022  * @return void
10023  *
10024  * ****************************************************************/
10025
10026 uint8_t procDrbListToSetup(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbItem,\
10027 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd, UpTnlCfg *upTnlInfo)
10028 {
10029
10030    if(drbItem != NULLP)
10031    {
10032       /* Filling RLC INFO */
10033       procRlcLcCfg(drbItem->dRBID, lcId, RB_TYPE_DRB, drbItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd);
10034
10035       /* Filling MAC INFO */
10036       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, drbItem, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
10037       {
10038          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetup()");
10039          return RFAILED;
10040       }
10041    }
10042    else if(drbSetupModItem != NULLP)
10043    {
10044       procRlcLcCfg(drbSetupModItem->dRBID, lcId, RB_TYPE_DRB, drbSetupModItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd);
10045
10046       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, NULL, drbSetupModItem, NULL, macLcToAdd, upTnlInfo) != ROK)
10047       {
10048          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetup()");
10049          return RFAILED;
10050       }
10051    }
10052    return ROK;
10053 }
10054
10055 /*******************************************************************
10056  *
10057  * @brief extract Drb List received by CU
10058  *
10059  * @details
10060  *
10061  *    Function : extractDrbListToSetup
10062  *
10063  *    Functionality: extract Drb List received by CU
10064  *                   for both MAC and RLC
10065  *
10066  * @params[in] DRBs_ToBeSetup_Item_t pointer
10067  *             DuUeCfg pointer
10068  * @return ROK/RFAIED
10069  *
10070  * ****************************************************************/
10071
10072 uint8_t extractDrbListToSetup(uint8_t lcId, DRBs_ToBeSetup_List_t *drbCfg,DRBs_ToBeSetupMod_List_t *drbSetupModCfg,\
10073 uint8_t drbCount, DuUeCfg *ueCfgDb)
10074 {
10075    uint8_t ret, drbIdx;
10076    DRBs_ToBeSetup_Item_t *drbItem = NULLP;
10077    DRBs_ToBeSetupMod_ItemIEs_t *drbSetupModItem = NULLP;
10078
10079    ret = ROK;
10080    if(drbCount > 0)
10081    {
10082       for(drbIdx = 0; drbIdx < drbCount; drbIdx++)
10083       {
10084          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
10085          {
10086             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in MAC at extractDrbListToSetup()");
10087             ret = RFAILED;
10088             break;
10089          }
10090          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
10091          {
10092             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in RLC at extractDrbListToSetup()");
10093             ret = RFAILED;
10094             break;
10095          }
10096          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
10097          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
10098
10099          if(drbCfg != NULL)
10100          {
10101             drbItem = &drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
10102             ret = procDrbListToSetup(lcId, drbItem, NULL, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
10103                &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], &ueCfgDb->upTnlInfo[ueCfgDb->numDrb]);
10104             if(ret == RFAILED)
10105             {
10106                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetup()");
10107                break;
10108             }
10109          }
10110          else if(drbSetupModCfg != NULL)
10111          {
10112             drbSetupModItem = (DRBs_ToBeSetupMod_ItemIEs_t *) drbSetupModCfg->list.array[drbIdx];
10113             ret = procDrbListToSetup(lcId, NULL, &(drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item) ,\
10114             &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs],\
10115             &ueCfgDb->upTnlInfo[ueCfgDb->numDrb]);
10116             if(ret == RFAILED)
10117             {
10118                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetup()");
10119                break;
10120             }
10121          }
10122          ueCfgDb->numRlcLcs++;
10123          ueCfgDb->numMacLcs++;
10124          ueCfgDb->numDrb++;
10125          if(ret == RFAILED)
10126          {
10127             DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetup()");
10128             break;
10129          }
10130       }
10131    }
10132    else
10133       ret = RFAILED;
10134
10135    return ret;
10136 }
10137
10138 /*******************************************************************
10139  *
10140  * @brief Function to extract Dl RRC Msg received from CU
10141  *
10142  * @details
10143  *
10144  *    Function : extractDlRrcMsg
10145  *
10146  *    Functionality: Function to extract Dl RRC Msg received from CU
10147  *
10148  * @params[in] F1AP message
10149  * @return ROK     - success
10150  *         RFAILED - failure
10151  *
10152  * ****************************************************************/
10153
10154 uint8_t extractDlRrcMsg(uint32_t gnbDuUeF1apId, uint32_t gnbCuUeF1apId, \
10155    F1DlRrcMsg *dlRrcMsg, RRCContainer_t *rrcContainer)
10156 {
10157    uint8_t ret = ROK;
10158    dlRrcMsg->rrcMsgSize = rrcContainer->size;
10159    if(dlRrcMsg->rrcMsgSize > 0)
10160    {
10161       DU_ALLOC_SHRABL_BUF(dlRrcMsg->rrcMsgPdu, dlRrcMsg->rrcMsgSize);
10162       if(!dlRrcMsg->rrcMsgPdu)
10163       {
10164          DU_LOG("\nERROR  --> DU APP : Memory allocation failed for RRC Msg in extractDlRrcMsg()");
10165          ret = RFAILED;
10166       }
10167       else
10168       {
10169          dlRrcMsg->gnbDuUeF1apId = gnbDuUeF1apId;
10170          dlRrcMsg->gnbCuUeF1apId = gnbCuUeF1apId;
10171          dlRrcMsg->srbId = SRB1_LCID;
10172          memcpy(dlRrcMsg->rrcMsgPdu, rrcContainer->buf, dlRrcMsg->rrcMsgSize);
10173       }
10174    }
10175    return ret;
10176 }
10177
10178 /*******************************************************************
10179  *
10180  * @brief Extract UE capability info
10181  *
10182  * @details
10183  *
10184  *    Function : extractUeCapability
10185  *
10186  *    Functionality: Extract UE capability info and stores in ue Cb
10187  *
10188  * @params[in] Octet string of UE capability RAT container list
10189  * @return ROK     - success
10190  *         RFAILED - failure
10191  *
10192  * ****************************************************************/
10193 UE_NR_Capability_t *extractUeCapability(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf, DuUeCb *ueCb)
10194 {
10195    uint8_t  idx;
10196    uint16_t recvBufLen;
10197    asn_dec_rval_t rval;
10198    UE_NR_Capability_t  *ueNrCap = NULLP;
10199    UE_CapabilityRAT_ContainerListRRC_t  *ueCapRatContList = NULLP;
10200
10201    /* Decoding UE Capability RAT Container List */
10202    recvBufLen = ueCapablityListBuf->size;
10203    DU_ALLOC(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10204    if(!ueCapRatContList)
10205    {
10206       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
10207       return NULLP;
10208    }
10209    memset(ueCapRatContList, 0, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10210    memset(&rval, 0, sizeof(asn_dec_rval_t));
10211    rval = aper_decode(0, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, (void **)&ueCapRatContList,
10212           ueCapablityListBuf->buf, recvBufLen, 0, 0);
10213    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10214    {
10215       DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
10216       return NULLP;
10217    }
10218    xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, ueCapRatContList);
10219
10220    /* Free encoded buffer after decoding */
10221
10222    for(idx = 0; idx < ueCapRatContList->list.count; idx++)
10223    {
10224       if(ueCapRatContList->list.array[idx]->rat_Type == RAT_Type_nr)
10225       {
10226          /* Decoding UE NR Capability */
10227           recvBufLen = ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.size;
10228           DU_ALLOC(ueNrCap, sizeof(UE_NR_Capability_t));
10229           if(!ueNrCap)
10230           {
10231              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
10232              DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10233              return NULLP;
10234           }
10235           memset(ueNrCap, 0, sizeof(UE_NR_Capability_t));
10236           memset(&rval, 0, sizeof(asn_dec_rval_t));
10237           rval = aper_decode(0, &asn_DEF_UE_NR_Capability, (void **)&ueNrCap,
10238                  ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf, recvBufLen, 0, 0);
10239           if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10240           {
10241              DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
10242              return NULLP;
10243           }
10244           xer_fprint(stdout, &asn_DEF_UE_NR_Capability, ueNrCap);
10245
10246           /* Free encoded buffer after decoding */
10247           free(ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf);
10248       }
10249       free(ueCapRatContList->list.array[idx]);
10250    }
10251
10252    /* Free Memory*/
10253    free(ueCapRatContList->list.array);
10254    DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10255    return ueNrCap;
10256 }
10257
10258 /*******************************************************************
10259 *
10260 * @brief free UE context setup request from CU
10261 *
10262 * @details
10263 *
10264 *    Function : freeAperDecodeF1UeContextSetupReq
10265 *
10266 *    Functionality: freeing part for the memory allocated by aper_decoder
10267 *
10268 * @params[in] F1AP message
10269 * @return ROK     - success
10270 *         RFAILED - failure
10271 *
10272 * ****************************************************************/
10273 void freeAperDecodeF1UeContextSetupReq(UEContextSetupRequest_t   *ueSetReq)
10274 {
10275    uint8_t ieIdx = 0;
10276
10277    if(ueSetReq->protocolIEs.list.array != NULLP)
10278    {
10279       for(ieIdx = 0; ieIdx < ueSetReq->protocolIEs.list.count; ieIdx++)
10280       {
10281          if(ueSetReq->protocolIEs.list.array[ieIdx])
10282          {
10283             switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
10284             {
10285                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10286                   break;
10287                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10288                   break;
10289                case ProtocolIE_ID_id_SpCell_ID:
10290                   freeAperDecodeNrcgi(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
10291                   break;
10292                case ProtocolIE_ID_id_ServCellIndex:
10293                   break;
10294                case ProtocolIE_ID_id_SpCellULConfigured:
10295                   break;
10296                case ProtocolIE_ID_id_CUtoDURRCInformation:
10297
10298                   freeAperDecodeCuToDuInfo(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation);
10299                   break;
10300                case ProtocolIE_ID_id_SCell_ToBeSetup_List:
10301
10302                   freeAperDecodeSplCellList(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SCell_ToBeSetup_List);
10303                   break;
10304                case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
10305
10306                   freeAperDecodeSRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List);
10307                   break;
10308                case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
10309
10310                   freeAperDecodeDRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List);
10311                   break;
10312                case ProtocolIE_ID_id_RRCContainer:
10313                   {
10314
10315                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf != NULLP)
10316                      {
10317
10318                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
10319                      }
10320                      break;
10321                   }
10322                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10323                   break;
10324                case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
10325                   {
10326                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf)
10327                      {
10328                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf);
10329                      }
10330                      break;
10331                   }
10332                default:
10333                   DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld " ,ueSetReq->protocolIEs.list.array[ieIdx]->id);
10334             }
10335             free(ueSetReq->protocolIEs.list.array[ieIdx]);
10336          }
10337       }
10338       free(ueSetReq->protocolIEs.list.array);
10339    }
10340 }
10341 /*******************************************************************
10342  *
10343  * @brief Process UE context setup request from CU
10344  *
10345  * @details
10346  *
10347  *    Function : procF1UeContextSetupReq
10348  *
10349  *    Functionality: Process UE context setup request from CU
10350  *
10351  * @params[in] F1AP message
10352  * @return ROK     - success
10353  *         RFAILED - failure
10354  *
10355  * ****************************************************************/
10356 uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
10357 {
10358    uint8_t  ret=0, ieIdx=0, ueIdx=0, lcId=0, cellIdx=0;
10359    bool ueCbFound = false;
10360    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0, bitRateSize=0;
10361    DuUeCb   *duUeCb = NULL;
10362    UEContextSetupRequest_t   *ueSetReq = NULL;
10363    DRBs_ToBeSetup_List_t *drbCfg = NULL;
10364
10365    ret = ROK;
10366
10367    ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
10368    for(ieIdx=0; (ieIdx < ueSetReq->protocolIEs.list.count && ret == ROK); ieIdx++)
10369    {
10370       switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
10371       {
10372          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10373             {
10374                gnbCuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
10375                break;
10376             }
10377          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10378             {
10379                gnbDuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
10380                break;
10381             }
10382          case ProtocolIE_ID_id_ServCellIndex:
10383             {
10384                cellIdx = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.ServCellIndex;
10385                for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
10386                {
10387                   if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
10388                         (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
10389                   {
10390                      ueCbFound = true;
10391                      duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
10392                      DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
10393                      if(duUeCb->f1UeDb)
10394                      {
10395                         memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
10396                         duUeCb->f1UeDb->actionType = UE_CTXT_SETUP;
10397                         duUeCb->f1UeDb->cellIdx = cellIdx;
10398                      }
10399                      else
10400                      {
10401                         DU_LOG("\nERROR  -->  F1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
10402                         ret = RFAILED;
10403                      }
10404                      break;
10405                   }
10406                   else
10407                      ueCbFound = false;
10408
10409                }
10410                if(!ueCbFound)
10411                {
10412                   DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
10413                   ret = RFAILED;
10414                }
10415                break;
10416             }
10417          case ProtocolIE_ID_id_SpCellULConfigured:
10418             /* Indicates whether the gNB-CU requests the gNB-DU to configure the uplink as no UL,
10419                UL, SUL or UL+SUL for the indicated cell for the UE */
10420             break;
10421          case ProtocolIE_ID_id_CUtoDURRCInformation:
10422             {
10423                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.uE_CapabilityRAT_ContainerList)
10424                {
10425                   duUeCb->f1UeDb->duUeCfg.ueNrCapability = \
10426                   extractUeCapability(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.\
10427                   uE_CapabilityRAT_ContainerList, duUeCb);
10428                }
10429                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.iE_Extensions)
10430                {
10431                   duUeCb->f1UeDb->duUeCfg.cellGrpCfg = extractCellGrpInfo(ueSetReq->protocolIEs.list.array[ieIdx]->\
10432                         value.choice.CUtoDURRCInformation.iE_Extensions, &duUeCb->f1UeDb->duUeCfg);
10433                   if(!duUeCb->f1UeDb->duUeCfg.cellGrpCfg)
10434                   {
10435                      DU_LOG("\nERROR  -->  F1AP: Failed to extract cell Grp Info");
10436                      //TODO: Update the failure cause in ue context Setup Response
10437                      ret = RFAILED;
10438                   }
10439                }
10440                break;
10441             }
10442          case ProtocolIE_ID_id_SCell_ToBeSetup_List:
10443             {
10444                DU_LOG("\nINFO   -->  DU_APP: Received SCell_ToBeSetup_List but  Not processing the list");
10445                break;
10446             }
10447          case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
10448             {
10449                if(extractSrbListToSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List,\
10450                &duUeCb->f1UeDb->duUeCfg))
10451                {
10452                   DU_LOG("\nERROR  -->  DU APP : Failed at extractSrbListToSetup()");
10453                   //TODO: Update the failure cause in ue context Setup Response
10454                   ret = RFAILED;
10455                }
10456                break;
10457             }
10458          case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
10459             {
10460                lcId = getDrbLcId(&duUeCb->drbBitMap);
10461                if(lcId != RFAILED)
10462                {
10463                   drbCfg = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List;
10464                   if(extractDrbListToSetup(lcId, drbCfg, NULL, drbCfg->list.count, &duUeCb->f1UeDb->duUeCfg))
10465                   {
10466                      DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetup()");
10467                      //TODO: Update the failure cause in ue context Setup Response
10468                      ret = RFAILED;
10469                   }
10470                }
10471                else
10472                   ret = RFAILED;
10473                break;
10474             }
10475          case ProtocolIE_ID_id_RRCContainer:
10476             {
10477                /* Filling Dl RRC Msg Info */
10478                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
10479                if(!duUeCb->f1UeDb->dlRrcMsg)
10480                {
10481                   DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
10482                   ret = RFAILED;
10483                }
10484                else
10485                {
10486                   duUeCb->f1UeDb->dlRrcMsgPres = true;
10487                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
10488                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
10489                         &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer);
10490                }
10491                break;
10492             }
10493          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10494             {
10495                if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
10496                {
10497                   duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
10498                }
10499                else
10500                {
10501                   DU_LOG("\nERROR  -->  Ignoring delivery report, since rrcContainer is not present");
10502                }
10503                break;
10504             }
10505          case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
10506             {
10507                /* MaximumBitRate Uplink */
10508                bitRateSize = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.size;
10509                if(bitRateSize > 0)
10510                {
10511                   DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.ambrCfg, bitRateSize);
10512                   if(!duUeCb->f1UeDb->duUeCfg.ambrCfg)
10513                   {
10514                      DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
10515                      ret = RFAILED;
10516                   }
10517                   else
10518                   {
10519                      memset(duUeCb->f1UeDb->duUeCfg.ambrCfg, 0, sizeof(AmbrCfg));
10520                      memcpy(&duUeCb->f1UeDb->duUeCfg.ambrCfg->ulBr,
10521                            ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf, bitRateSize);
10522                   }
10523                }
10524                else
10525                   ret = RFAILED;
10526                break;
10527             }
10528          default:
10529             {
10530                break;
10531             }
10532       }
10533    }
10534    if(ret == RFAILED)
10535    {
10536       /*TODO : Negative case*/
10537       // BuildAndSendUeContextSetupRsp(cellId,ueIdx);
10538       DU_LOG("\nERROR  -->  F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
10539    }
10540    else
10541       ret = duProcUeContextSetupRequest(duUeCb);
10542
10543    freeAperDecodeF1UeContextSetupReq(ueSetReq);
10544    return ret;
10545
10546 }
10547 /*******************************************************************
10548  * @brief Free the memory allocated for Dl Tunnel Info
10549  *
10550  * @details
10551  *
10552  *    Function : freeDlTnlInfo
10553  *
10554  *    Functionality:
10555  *       Free the memory allocated for Dl Tunnel Info
10556  *
10557  * @params[in] DLUPTNLInformation_ToBeSetup_List_t *
10558  * @return void
10559  *
10560  * ****************************************************************/
10561
10562 void freeDlTnlInfo(DLUPTNLInformation_ToBeSetup_List_t *tnlInfo)
10563 {
10564    uint8_t arrIdx = 0;
10565
10566    if(tnlInfo)
10567    {
10568       for(arrIdx=0; arrIdx < tnlInfo->list.count; arrIdx++)
10569       {
10570          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf,\
10571                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
10572          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf,\
10573                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
10574          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
10575          DU_FREE(tnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
10576       }
10577       DU_FREE(tnlInfo->list.array, tnlInfo->list.size);
10578    }
10579 }
10580
10581 /*******************************************************************
10582  * @brief Free the memory allocated for DRB setup List
10583  *
10584  * @details
10585  *
10586  *    Function : freeDrbSetupList
10587  *
10588  *    Functionality:
10589  *       Free the memory allocated for DRB setup list
10590  *
10591  * @params[in] DRBs_Setup_List_t *
10592  * @return void
10593  *
10594  * ****************************************************************/
10595 void freeDrbSetupList(DRBs_Setup_List_t *drbSetupList)
10596 {
10597    uint8_t arrIdx = 0;
10598    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
10599
10600    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
10601    {
10602       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
10603       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
10604       DU_FREE(drbSetupList->list.array[arrIdx],  sizeof(DRBs_Setup_Item_t));
10605    }
10606    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
10607 }
10608
10609 /*******************************************************************
10610  * @brief Free the memory allocated for UE Setup response
10611  *
10612  * @details
10613  *
10614  *    Function : FreeUeContextSetupRsp
10615  *
10616  *    Functionality:
10617  *       Free the memory allocated for UE Setup response
10618  *
10619  * @params[in] F1AP PDU for UE setup response
10620  * @return ROK     - success
10621  *         RFAILED - failure
10622  *
10623  * ****************************************************************/
10624 void FreeUeContextSetupRsp(F1AP_PDU_t *f1apMsg)
10625 {
10626    uint8_t idx;
10627    UEContextSetupResponse_t *ueSetRsp = NULLP;
10628
10629    if(f1apMsg)
10630    {
10631       if(f1apMsg->choice.successfulOutcome)
10632       {
10633          ueSetRsp = &f1apMsg->choice.successfulOutcome->value.choice.\
10634                     UEContextSetupResponse;
10635          if(ueSetRsp->protocolIEs.list.array)
10636          {
10637             for(idx = 0; idx < ueSetRsp->protocolIEs.list.count; idx++)
10638             {
10639                if(ueSetRsp->protocolIEs.list.array[idx])
10640                {
10641                   switch(ueSetRsp->protocolIEs.list.array[idx]->id)
10642                   {
10643                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10644                         break;
10645                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10646                         break;
10647                      case ProtocolIE_ID_id_DUtoCURRCInformation:
10648                         {
10649                            CellGroupConfig_t *cellGrpCfg = NULLP;
10650                            cellGrpCfg  = &ueSetRsp->protocolIEs.list.array[idx]->value.choice.\
10651                                          DUtoCURRCInformation.cellGroupConfig;
10652                            if(cellGrpCfg->buf != NULLP)
10653                            {
10654                               DU_FREE(cellGrpCfg->buf, cellGrpCfg->size);
10655                               cellGrpCfg = NULLP;
10656                            }
10657                            break;
10658                         }
10659                     case ProtocolIE_ID_id_DRBs_Setup_List:
10660                         {
10661                            freeDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
10662                            break;
10663                         }
10664                      default:
10665                         DU_LOG("\nERROR  -->  DUAPP: Invalid Id %ld at FreeUeContextSetupRsp()",\
10666                         ueSetRsp->protocolIEs.list.array[idx]->id);
10667                         break;
10668                   }
10669                   DU_FREE(ueSetRsp->protocolIEs.list.array[idx],\
10670                         sizeof(UEContextSetupResponseIEs_t));
10671                }
10672             }
10673             DU_FREE(ueSetRsp->protocolIEs.list.array, \
10674                   ueSetRsp->protocolIEs.list.size);
10675          }
10676          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
10677       }
10678       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10679    }
10680 }
10681
10682 /*******************************************************************
10683  *
10684  * @brief Builds Ue context Setup Rsp DU To CU Info
10685  *
10686  * @details
10687  *
10688  *    Function : EncodeUeCntxtDuToCuInfo
10689  *
10690  *    Functionality: Builds Ue context Setup Rsp DU To CU Info
10691  *
10692  * @params[in] CellGroupConfig_t *, CellGroupConfigRrc_t *
10693  *
10694  * @return ROK     - success
10695  *         RFAILED - failure
10696  *
10697  ******************************************************************/
10698
10699 uint8_t EncodeUeCntxtDuToCuInfo(CellGroupConfig_t *duToCuCellGrp, CellGroupConfigRrc_t *duCellGrpCfg)
10700 {
10701    asn_enc_rval_t        encRetVal;
10702
10703    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, duCellGrpCfg);
10704    memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
10705    encBufSize = 0;
10706    encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, duCellGrpCfg, PrepFinalEncBuf, encBuf);
10707    /* Encode results */
10708    if(encRetVal.encoded == ENCODE_FAIL)
10709    {
10710       DU_LOG( "\nERROR  -->  F1AP : Could not encode UeCntxtDuToCuInfo (at %s)\n",\
10711             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10712       return RFAILED;
10713    }
10714    else
10715    {
10716       DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
10717       for(int i=0; i< encBufSize; i++)
10718       {
10719          printf("%x",encBuf[i]);
10720       }
10721    }
10722    duToCuCellGrp->size = encBufSize;
10723    DU_ALLOC(duToCuCellGrp->buf, duToCuCellGrp->size);
10724    if(!duToCuCellGrp->buf)
10725    {
10726       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in UeCntxtDuToCuInfo");
10727    }
10728    memcpy(duToCuCellGrp->buf, encBuf, duToCuCellGrp->size);
10729    return ROK;
10730 }
10731
10732 /*******************************************************************
10733  *
10734  * @brief Fills Dl Gtp tunnel Info
10735  *
10736  * @details
10737  *
10738  *    Function : fillGtpTunnelforDl
10739  *
10740  *    Functionality: Fills Dl Gtp tunnel Info
10741  *
10742  * @params[in]
10743  *
10744  * @return ROK     - success
10745  *         RFAILED - failure
10746  *
10747  * ****************************************************************/
10748
10749 uint8_t fillGtpTunnelforDl(GTPTunnel_t *gtpDl, GtpTnlCfg *gtpUeCfg)
10750 {
10751    uint8_t bufSize = 0;
10752
10753    gtpDl->transportLayerAddress.size    = 4*sizeof(uint8_t);
10754    DU_ALLOC(gtpDl->transportLayerAddress.buf, gtpDl->transportLayerAddress.size);
10755    if(gtpDl->transportLayerAddress.buf == NULLP)
10756    {
10757       return RFAILED;
10758    }
10759    memcpy(gtpDl->transportLayerAddress.buf, &gtpUeCfg->dlTnlAddress, gtpDl->transportLayerAddress.size);
10760
10761    /*GTP TEID*/
10762    gtpDl->gTP_TEID.size = 4 * sizeof(uint8_t);
10763    DU_ALLOC(gtpDl->gTP_TEID.buf, gtpDl->gTP_TEID.size);
10764    if(gtpDl->gTP_TEID.buf == NULLP)
10765    {
10766       return RFAILED;
10767    }
10768    bufSize = 3; /*forming an Octect String*/
10769    fillTeIdString(bufSize, gtpUeCfg->teId, gtpDl->gTP_TEID.buf);
10770
10771    return ROK;
10772 }
10773
10774 /*******************************************************************
10775  *
10776  * @brief Fills DL Tunnel Setup List
10777  *
10778  * @details
10779  *
10780  *    Function : fillDlTnlSetupList
10781  *
10782  *    Functionality: Fills the DL Tunnel Setup List
10783  *
10784  * @params[in]
10785  *
10786  * @return ROK     - success
10787  *         RFAILED - failure
10788  *
10789  * ****************************************************************/
10790
10791 uint8_t fillDlTnlSetupList(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo, UpTnlCfg *tnlCfg)
10792 {
10793    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
10794
10795    eleCount = 1;
10796    dlTnlInfo->list.count = eleCount;
10797    dlTnlInfo->list.size = (eleCount * sizeof(DLUPTNLInformation_ToBeSetup_Item_t *));
10798
10799    /* Initialize the DL Tnl Setup List Members */
10800    DU_ALLOC(dlTnlInfo->list.array, dlTnlInfo->list.size);
10801    if(dlTnlInfo->list.array == NULLP)
10802    {
10803       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL Tnl Setup List in fillDlTnlSetupList()");
10804       ret = RFAILED;
10805    }
10806    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
10807    {
10808       DU_ALLOC(dlTnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
10809       if(dlTnlInfo->list.array[arrIdx] == NULLP)
10810       {
10811          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDlTnlSetupList()", arrIdx);
10812          return RFAILED;
10813       }
10814       dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
10815       DU_ALLOC(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
10816       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel == NULLP)
10817       {
10818          DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL tunnel info in fillDlTnlSetupList()");
10819          return RFAILED;
10820       }
10821       ret = fillGtpTunnelforDl(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel,\
10822                tnlCfg->tnlCfg1);
10823       if(ret != ROK)
10824          break;
10825    }
10826    return ret;
10827 }
10828
10829 /*******************************************************************
10830  *
10831  * @brief Fills the Drb Setup List for Ue Context Setup Response
10832  *
10833  * @details
10834  *
10835  *    Function : fillDrbSetupList
10836  *
10837  *    Functionality: Fills the Drb Setup List for Ue Context Setup Response
10838  *
10839  * @params[in]
10840  *
10841  * @return ROK     - success
10842  *         RFAILED - failure
10843  *
10844  * ****************************************************************/
10845 uint8_t fillDrbSetupList(DRBs_Setup_List_t *drbSetupList, DuUeCfg *ueCfg)
10846 {
10847    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
10848    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
10849
10850    eleCount = ueCfg->numDrb;
10851    drbSetupList->list.count = eleCount;
10852    drbSetupList->list.size = \
10853         (eleCount * sizeof(DRBs_Setup_Item_t *));
10854
10855    /* Initialize the Drb Setup List Members */
10856    DU_ALLOC(drbSetupList->list.array, drbSetupList->list.size);
10857    if(drbSetupList->list.array == NULLP)
10858    {
10859       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DRB Setup List in fillDrbSetupList()");
10860       ret = RFAILED;
10861    }
10862
10863    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
10864    {
10865       DU_ALLOC(drbSetupList->list.array[arrIdx], sizeof(DRBs_Setup_Item_t));
10866       if(drbSetupList->list.array[arrIdx] == NULLP)
10867       {
10868          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDrbSetupList()", arrIdx);
10869          return RFAILED;
10870       }
10871       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
10872       drbItemIe->id = ProtocolIE_ID_id_DRBs_Setup_Item;
10873       drbItemIe->criticality = Criticality_reject;
10874       drbItemIe->value.present = DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item;
10875       drbItemIe->value.choice.DRBs_Setup_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
10876       ret = fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List,\
10877           &ueCfg->upTnlInfo[arrIdx]);
10878       if(ret != ROK)
10879          break;
10880    }
10881    return ret;
10882 }
10883
10884 /*******************************************************************
10885  *
10886  * @brief Builds and sends the UE Setup Response
10887  *
10888  * @details
10889  *
10890  *    Function : BuildAndSendUeContextSetupRsp
10891  *
10892  *    Functionality: Constructs the UE Setup Response and sends
10893  *                   it to the DU through SCTP.
10894  *
10895  * @params[in] uint8_t cellId,uint8_t ueIdx
10896  *
10897  * @return ROK     - success
10898  *         RFAILED - failure
10899  *
10900  * ****************************************************************/
10901 uint8_t BuildAndSendUeContextSetupRsp(uint8_t cellId,uint8_t ueIdx)
10902 {
10903    uint8_t   idx, ret, cellIdx, elementCnt;
10904    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
10905    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
10906    asn_enc_rval_t  encRetVal;        /* Encoder return value */
10907    F1AP_PDU_t               *f1apMsg = NULLP;
10908    UEContextSetupResponse_t *ueSetRsp = NULLP;
10909    CellGroupConfigRrc_t     *cellGrpCfg = NULLP;
10910    DuUeCb                   *ueCb = NULLP;
10911
10912    DU_LOG("\n INFO   -->  F1AP : Building UE Context Setup Response for cellId %d, ueIdx %d\n", cellId, ueIdx);
10913
10914    while(true)
10915    {
10916       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10917       if(f1apMsg == NULLP)
10918       {
10919          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
10920          ret = RFAILED;
10921          break;
10922       }
10923
10924       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
10925       DU_ALLOC(f1apMsg->choice.successfulOutcome,
10926             sizeof(SuccessfulOutcome_t));
10927       if(f1apMsg->choice.successfulOutcome == NULLP)
10928       {
10929          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
10930          ret = RFAILED;
10931          break;
10932       }
10933
10934       f1apMsg->choice.successfulOutcome->procedureCode = \
10935                                                          ProcedureCode_id_UEContextSetup;
10936       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
10937       f1apMsg->choice.successfulOutcome->value.present = \
10938                                                          SuccessfulOutcome__value_PR_UEContextSetupResponse;
10939
10940       ueSetRsp =
10941          &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
10942       elementCnt = 4;
10943       ueSetRsp->protocolIEs.list.count = elementCnt;
10944       ueSetRsp->protocolIEs.list.size = \
10945                                         elementCnt * sizeof(UEContextSetupResponse_t *);
10946
10947       /* Initialize the UESetup members */
10948       DU_ALLOC(ueSetRsp->protocolIEs.list.array, \
10949             ueSetRsp->protocolIEs.list.size);
10950       if(ueSetRsp->protocolIEs.list.array == NULLP)
10951       {
10952          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
10953          ret = RFAILED;
10954          break;
10955       }
10956
10957       for(idx=0; idx<elementCnt; idx++)
10958       {
10959          DU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
10960                sizeof(UEContextSetupResponseIEs_t));
10961          if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
10962          {
10963             DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
10964             ret = RFAILED;
10965             break;
10966          }
10967       }
10968       /* Fetching Ue Cb Info*/
10969       GET_CELL_IDX(cellId, cellIdx);
10970       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
10971       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
10972       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
10973
10974       idx = 0;
10975       /*GNB CU UE F1AP ID*/
10976       ueSetRsp->protocolIEs.list.array[idx]->id = \
10977                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
10978       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10979       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
10980                                                              UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
10981       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
10982
10983       /*GNB DU UE F1AP ID*/
10984       idx++;
10985       ueSetRsp->protocolIEs.list.array[idx]->id = \
10986                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
10987       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10988       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
10989                                                              UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
10990       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
10991
10992
10993       /*DUtoCURRC Information */
10994       idx++;
10995       ueSetRsp->protocolIEs.list.array[idx]->id  = \
10996                                                    ProtocolIE_ID_id_DUtoCURRCInformation;
10997       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10998       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
10999                                                             UEContextSetupResponseIEs__value_PR_DUtoCURRCInformation;
11000       if(ueCb->f1UeDb)
11001       {
11002          if(ueCb->f1UeDb->duUeCfg.cellGrpCfg)
11003          {
11004             cellGrpCfg = (CellGroupConfigRrc_t*)ueCb->f1UeDb->duUeCfg.cellGrpCfg;
11005             ret = EncodeUeCntxtDuToCuInfo(&ueSetRsp->protocolIEs.list.array[idx]->value.\
11006                      choice.DUtoCURRCInformation.cellGroupConfig, cellGrpCfg);
11007             if(ret == RFAILED)
11008             {
11009                DU_LOG("\nERROR  -->  F1AP : Failed to EncodeUeCntxtDuToCuInfo in BuildAndSendUeContextSetupRsp()");
11010                freeF1UeDb(ueCb->f1UeDb);
11011                ueCb->f1UeDb = NULLP;
11012                break;
11013             }
11014          }
11015       }
11016       else
11017       {
11018          DU_LOG("\nERROR  -->  F1AP : Failed to form DUtoCU RRCInfo at BuildAndSendUeContextSetupRsp()");
11019          ret = RFAILED;
11020          break;
11021       }
11022
11023       /* Drb Setup List */
11024       idx++;
11025       ueSetRsp->protocolIEs.list.array[idx]->id  = \
11026                                  ProtocolIE_ID_id_DRBs_Setup_List;
11027       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11028       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
11029                                  UEContextSetupResponseIEs__value_PR_DRBs_Setup_List;
11030       ret = fillDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List,\
11031                &ueCb->f1UeDb->duUeCfg);
11032       if(ret == RFAILED)
11033       {
11034          DU_LOG("\nERROR  -->  F1AP : Failed to fillDrbSetupList in BuildAndSendUeContextSetupRsp()");
11035          freeF1UeDb(ueCb->f1UeDb);
11036          ueCb->f1UeDb = NULLP;
11037          break;
11038       }
11039
11040        /* Free UeContext Db created during Ue context Req */
11041        freeF1UeDb(ueCb->f1UeDb);
11042        ueCb->f1UeDb = NULLP;
11043
11044       /* TODO: To send Drb list */
11045       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11046
11047       /* Encode the UE context setup response type as APER */
11048       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
11049       encBufSize = 0;
11050       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11051             encBuf);
11052       /* Encode results */
11053       if(encRetVal.encoded == ENCODE_FAIL)
11054       {
11055          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Response structure (at %s)\n",\
11056                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11057          ret = RFAILED;
11058          break;
11059       }
11060       else
11061       {
11062          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Setup Response\n");
11063          for(int i=0; i< encBufSize; i++)
11064          {
11065             printf("%x",encBuf[i]);
11066          }
11067       }
11068
11069       /* Sending  msg  */
11070       if(sendF1APMsg()  != ROK)
11071       {
11072          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Response failed");
11073          ret = RFAILED;
11074          break;
11075       }
11076       break;
11077    }
11078    FreeUeContextSetupRsp(f1apMsg);
11079    return ret;
11080 }/* End of BuildAndSendUeContextSetupRsp */
11081 /*******************************************************************
11082 *
11083 * @brief  Build And Send Ue Context Rsp
11084 *
11085 * @details
11086 *
11087 *    Function : BuildAndSendUeCtxtRsp
11088 *
11089 *    Functionality : Build And Send Ue Context Rsp
11090
11091 * @params[in]
11092 * @return sucess = ROK
11093 *         failure = RFAILED
11094 *
11095 * ****************************************************************/
11096 uint8_t BuildAndSendUeCtxtRsp(uint8_t cellId, uint8_t ueIdx)
11097 {
11098    uint8_t cellIdx = 0, actionType = 0;
11099
11100    GET_CELL_IDX(cellId, cellIdx);
11101    actionType = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].f1UeDb->actionType;
11102
11103    switch(actionType)
11104    {
11105       case UE_CTXT_SETUP:
11106          {
11107             BuildAndSendUeContextSetupRsp(cellId,ueIdx);
11108             break;
11109          }
11110       case UE_CTXT_MOD:
11111          {
11112             BuildAndSendUeContextModRsp(cellId, ueIdx);
11113             break;
11114          }
11115       default:
11116          DU_LOG("ERROR  -->  F1AP: Invalid Action Type %d at BuildAndSendUeCtxtRsp()", actionType);
11117          break;
11118
11119    }
11120    return ROK;
11121 }
11122
11123 /*******************************************************************
11124  *
11125  * @brief deallocating the memory of  F1reset msg
11126  *
11127  * @details
11128  *
11129  *    Function : FreeF1ResetReq
11130  *
11131  *    Functionality :
11132  *         - freeing memory of F1reset request msg
11133  *
11134  * @params[in]
11135  * @return void
11136  *
11137  *
11138  * ****************************************************************/
11139 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
11140 {
11141    uint8_t idx =0 ;
11142    Reset_t *f1ResetMsg;
11143
11144    if(f1apMsg)
11145    {
11146       if(f1apMsg->choice.initiatingMessage)
11147       {
11148          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11149
11150          if(f1ResetMsg->protocolIEs.list.array)
11151          {
11152             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
11153             {
11154                if(f1ResetMsg->protocolIEs.list.array[idx])
11155                {
11156                   DU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
11157                }
11158             }
11159             DU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
11160          }
11161          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11162       }
11163       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11164    }
11165 }
11166 /*******************************************************************
11167  *
11168  * @brief Build and Send F1reset request
11169  *
11170  * @details
11171  *
11172  *    Function : BuildAndSendF1ResetReq
11173  *
11174  *    Functionality:
11175  *         - Build and Send F1reset request msg
11176  *
11177  * @params[in]
11178  * @return ROK     - success
11179  *         RFAILED - failure
11180  *
11181  * ****************************************************************/
11182 uint8_t BuildAndSendF1ResetReq()
11183 {
11184    uint8_t          elementCnt=0;
11185    uint8_t          idx=0;
11186    uint8_t          ret= RFAILED;
11187    Reset_t          *f1ResetMsg = NULLP;
11188    F1AP_PDU_t       *f1apMsg = NULLP;
11189    asn_enc_rval_t   encRetVal;
11190    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset request \n");
11191    do
11192    {
11193       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11194       if(f1apMsg == NULLP)
11195       {
11196          break;
11197       }
11198       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
11199       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11200       if(f1apMsg->choice.initiatingMessage == NULLP)
11201       {
11202          break;
11203       }
11204       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
11205       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
11206       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
11207
11208       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11209
11210       elementCnt = 3;
11211       f1ResetMsg->protocolIEs.list.count = elementCnt;
11212       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
11213
11214       /* Initialize the F1Setup members */
11215       DU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
11216       if(f1ResetMsg->protocolIEs.list.array == NULLP)
11217       {
11218          break;
11219       }
11220       for(idx=0; idx<elementCnt; idx++)
11221       {
11222          DU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
11223          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
11224          {
11225             break;
11226          }
11227       }
11228
11229       /*TransactionID*/
11230       idx=0;
11231       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
11232       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11233       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
11234       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
11235
11236       /*Cause*/
11237       idx++;
11238       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
11239       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
11240       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
11241       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
11242       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
11243
11244       /*Reset Type*/
11245       idx++;
11246       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
11247       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11248       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
11249       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
11250       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
11251
11252       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11253
11254       /* Encode the F1SetupRequest type as APER */
11255       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11256       encBufSize = 0;
11257       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11258             encBuf);
11259
11260       /* Encode results */
11261       if(encRetVal.encoded == ENCODE_FAIL)
11262       {
11263          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
11264                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11265          break;
11266       }
11267       else
11268       {
11269          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1Reset\n");
11270          for(idx=0; idx< encBufSize; idx++)
11271          {
11272             printf("%x",encBuf[idx]);
11273          }
11274       }
11275
11276       if(sendF1APMsg() != ROK)
11277       {
11278          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
11279          break;
11280       }
11281
11282       ret = ROK;
11283       break;
11284    }while(true);
11285
11286    FreeF1ResetReq(f1apMsg);
11287    return ret;
11288 }
11289 /*******************************************************************
11290  *
11291  * @brief Build And Send F1ResetAck
11292  *
11293  * @details
11294  *
11295  *    Function : BuildAndSendF1ResetAck
11296  *
11297  *    Functionality:
11298  *         - Build And Send  F1ResetRSP
11299  *
11300  * @return ROK     - success
11301  *         RFAILED - failure
11302  *
11303  * ****************************************************************/
11304 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
11305 {
11306    uint8_t idx;
11307    ResetAcknowledge_t *f1ResetAck;
11308
11309    if(f1apMsg)
11310    {
11311       if(f1apMsg->choice.successfulOutcome)
11312       {
11313          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
11314
11315          if(f1ResetAck->protocolIEs.list.array)
11316          {
11317             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
11318             {
11319                if(f1ResetAck->protocolIEs.list.array[idx])
11320                {
11321                   DU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
11322                }
11323             }
11324             DU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
11325          }
11326          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11327       }
11328       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11329    }
11330 }
11331
11332 /*******************************************************************
11333  *
11334  * @brief Build And Send F1ResetAck
11335  *
11336  * @details
11337  *
11338  *    Function : BuildAndSendF1ResetAck
11339  *
11340  *    Functionality:
11341  *         - Build And Send  F1ResetRSP
11342  *
11343  *  @params[in]
11344  * @return ROK     - success
11345  *         RFAILED - failure
11346  *
11347  * ****************************************************************/
11348 uint8_t BuildAndSendF1ResetAck()
11349 {
11350    uint8_t                idx = 0;
11351    uint8_t                elementCnt = 0;
11352    uint8_t                ret = RFAILED;
11353    F1AP_PDU_t             *f1apMsg = NULL;
11354    ResetAcknowledge_t     *f1ResetAck = NULLP;
11355    asn_enc_rval_t         encRetVal;
11356    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset Acknowledgment \n");
11357
11358    do{
11359       /* Allocate the memory for F1ResetRequest_t */
11360       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11361       if(f1apMsg == NULLP)
11362       {
11363          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11364          break;
11365       }
11366
11367       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
11368
11369       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11370       if(f1apMsg->choice.successfulOutcome == NULLP)
11371       {
11372          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11373          break;
11374       }
11375       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
11376       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
11377       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
11378
11379       elementCnt = 1;
11380
11381       f1ResetAck->protocolIEs.list.count = elementCnt;
11382       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
11383
11384       DU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
11385       if(f1ResetAck->protocolIEs.list.array == NULLP)
11386       {
11387          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
11388          break;
11389       }
11390
11391       for(idx=0; idx<elementCnt; idx++)
11392       {
11393          DU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
11394          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
11395          {
11396             break;
11397          }
11398       }
11399       /*TransactionID*/
11400       idx = 0;
11401       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
11402       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11403       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
11404       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
11405
11406       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11407
11408       /* Encode the F1SetupRequest type as UPER */
11409       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11410       encBufSize = 0;
11411       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
11412
11413       /* Check encode results */
11414       if(encRetVal.encoded == ENCODE_FAIL)
11415       {
11416          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
11417                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11418          break;
11419       }
11420       else
11421       {
11422          DU_LOG("\nDUBUG   -->  F1AP : Created APER encoded buffer for F1ResetAck\n");
11423          for(int i=0; i< encBufSize; i++)
11424          {
11425             printf("%x",encBuf[i]);
11426          }
11427       }
11428       /* Sending msg */
11429       if(sendF1APMsg() != ROK)
11430       {
11431          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Acknowledgement failed");
11432          break;
11433       }
11434
11435       ret = ROK;
11436       break;
11437    }while(true);
11438
11439    FreeF1ResetAck(f1apMsg);
11440    return ret;
11441 }
11442 /******************************************************************
11443 *
11444 * @brief free F1 reset msg allocated by aper_decoder
11445 *
11446 * @details
11447 *
11448 *    Function : freeAperDecodeF1ResetMsg
11449 *
11450 *    Functionality: free F1 reset msg allocated by aper_decoder
11451 *
11452 * @params[in] Reset_t *f1ResetMsg
11453 * @return void
11454 *
11455 * ****************************************************************/
11456
11457 void freeAperDecodeF1ResetMsg(Reset_t *f1ResetMsg)
11458 {
11459    uint8_t ieIdx =0;
11460    if(f1ResetMsg->protocolIEs.list.array)
11461    {
11462       for(ieIdx=0 ;ieIdx < f1ResetMsg->protocolIEs.list.count ; ieIdx++)
11463       {
11464          if(f1ResetMsg->protocolIEs.list.array[ieIdx])
11465          {
11466             free(f1ResetMsg->protocolIEs.list.array[ieIdx]);
11467          }
11468       }
11469       free(f1ResetMsg->protocolIEs.list.array);
11470    }
11471 }
11472
11473 /******************************************************************
11474  *
11475  * @brief Processes DL RRC Message Transfer  sent by CU
11476  *
11477  * @details
11478  *
11479  *    Function : procF1ResetReq
11480  *
11481  *    Functionality: Processes DL RRC Message Transfer sent by CU
11482  *
11483  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11484  * @return ROK     - success
11485  *         RFAILED - failure
11486  *
11487  * ****************************************************************/
11488 uint8_t procF1ResetReq(F1AP_PDU_t *f1apMsg)
11489 {
11490    /* we are currently not supporting Ue release. right now we are supporting only init case of fireset */
11491    uint8_t       ieIdx = 0;
11492    uint8_t        ret = ROK;
11493    Reset_t       *f1ResetMsg = NULLP;
11494
11495    DU_LOG("\nINFO   -->  Processing F1 reset request");
11496    f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11497
11498    for(ieIdx=0; ieIdx<f1ResetMsg->protocolIEs.list.count; ieIdx++)
11499    {
11500       switch(f1ResetMsg->protocolIEs.list.array[ieIdx]->id)
11501       {
11502          case ProtocolIE_ID_id_TransactionID:
11503             break;
11504
11505          case ProtocolIE_ID_id_Cause:
11506             break;
11507
11508          case ProtocolIE_ID_id_ResetType:
11509             {
11510                break;
11511             }
11512
11513          default:
11514             break;
11515       }
11516    }
11517    ret = BuildAndSendF1ResetAck();
11518    DU_LOG("\nINFO   -->  UE release is not supported for now");
11519
11520    freeAperDecodeF1ResetMsg(f1ResetMsg);
11521
11522    return ret;
11523 }
11524
11525 /*******************************************************************
11526  *
11527  * @brief free the RRC delivery report
11528  *
11529  * @details
11530  *
11531  *    Function : freeRrcDeliveryReport
11532  *
11533  *    Functionality: free the RRC delivery report
11534  *
11535  * @params[in]
11536  * @return ROK     - success
11537  *         RFAILED - failure
11538  *
11539  * ****************************************************************/
11540 void freeRrcDeliveryReport(F1AP_PDU_t  *f1apMsg )
11541 {
11542    uint8_t idx=0;
11543    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11544
11545    if(f1apMsg)
11546    {
11547       if(f1apMsg->choice.initiatingMessage)
11548       {
11549          rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11550          if(rrcDeliveryReport->protocolIEs.list.array)
11551          {
11552             for(idx =0 ;idx <rrcDeliveryReport->protocolIEs.list.count ;
11553                   idx++)
11554             {
11555                if(rrcDeliveryReport->protocolIEs.list.array[idx])
11556                {
11557                   DU_FREE(rrcDeliveryReport->protocolIEs.list.array[idx],
11558                         sizeof(RRCDeliveryReportIEs_t));
11559                }
11560             }
11561             DU_FREE(rrcDeliveryReport->protocolIEs.list.array,
11562                   rrcDeliveryReport->protocolIEs.list.size);
11563          }
11564          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11565       }
11566       DU_FREE(f1apMsg,
11567             sizeof(F1AP_PDU_t));
11568    }
11569 }
11570
11571 /*******************************************************************
11572 *
11573 * @brief Builds and sends the RRC delivery report
11574 *
11575 * @details
11576 *
11577 *    Function : BuildAndSendRrcDeliveryReport
11578 *
11579 *    Functionality: Builds and sends the RRC delivery report
11580 *
11581 * @params[in]
11582 *
11583 * @return ROK     - success
11584 *         RFAILED - failure
11585 *
11586 * ****************************************************************/
11587 uint8_t BuildAndSendRrcDeliveryReport(uint32_t gnbCuUeF1apId, \
11588    uint32_t gnbDuUeF1apId, RrcDeliveryReport *rrcDelivery)
11589 {
11590    uint8_t             ret = RFAILED;
11591    uint8_t             idx    = 0;
11592    uint8_t             idx1   = 0;
11593    uint8_t             elementCnt = 0;
11594    F1AP_PDU_t          *f1apMsg = NULLP;
11595    asn_enc_rval_t      encRetVal;
11596    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11597
11598    do{
11599
11600       DU_LOG("\nINFO   -->  F1AP : Building RRC delivery Message Transfer Message\n");
11601       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11602       if(f1apMsg == NULLP)
11603       {
11604          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11605          break;
11606       }
11607       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
11608       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11609       if(f1apMsg->choice.initiatingMessage == NULLP)
11610       {
11611          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU  failed");
11612          break;
11613       }
11614       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_RRCDeliveryReport;
11615       f1apMsg->choice.initiatingMessage->criticality   = Criticality_ignore;
11616       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RRCDeliveryReport;
11617
11618       rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11619       elementCnt = 4;
11620       rrcDeliveryReport->protocolIEs.list.count = elementCnt;
11621       rrcDeliveryReport->protocolIEs.list.size = elementCnt * sizeof(RRCDeliveryReportIEs_t *);
11622
11623       /* Initialize the F1Setup members */
11624       DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array, rrcDeliveryReport->protocolIEs.list.size);
11625       if(rrcDeliveryReport->protocolIEs.list.array == NULLP)
11626       {
11627          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRC Delivery  failed");
11628          break;
11629       }
11630       for(idx =0 ;idx <elementCnt; idx++)
11631       {
11632          DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array[idx], sizeof(RRCDeliveryReportIEs_t));
11633          if(rrcDeliveryReport->protocolIEs.list.array[idx] == NULLP)
11634          {
11635             break;
11636          }
11637       }
11638
11639       idx1 = 0;
11640
11641       /*GNB CU UE F1AP ID*/
11642       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11643       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
11644       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_CU_UE_F1AP_ID;
11645       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
11646
11647       /*GNB DU UE F1AP ID*/
11648       idx1++;
11649       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11650       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
11651       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_DU_UE_F1AP_ID;
11652       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
11653
11654       /*RRC delivery status*/
11655       idx1++;
11656       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_RRCDeliveryStatus;
11657       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
11658       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_RRCDeliveryStatus;
11659       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.delivery_status =\
11660       rrcDelivery->rrcDeliveryStatus.deliveryStatus;
11661       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.triggering_message =\
11662       rrcDelivery->rrcDeliveryStatus.triggeringMessage;
11663
11664       /* SRB ID */
11665       idx1++;
11666       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
11667       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
11668       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_SRBID;
11669       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.SRBID =  rrcDelivery->srbId;
11670
11671       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11672
11673       /* Encode the RRC DELIVERY REPORT type as APER */
11674       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11675       encBufSize = 0;
11676       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11677             encBuf);
11678
11679       /* Encode results */
11680       if(encRetVal.encoded == ENCODE_FAIL)
11681       {
11682          DU_LOG("\nERROR  -->  F1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
11683                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11684          break;
11685       }
11686       else
11687       {
11688          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for RRC Delivery Msg \n");
11689          for(idx=0; idx< encBufSize; idx++)
11690          {
11691             printf("%x",encBuf[idx]);
11692          }
11693       }
11694
11695       /* Sending msg */
11696       if(sendF1APMsg() != ROK)
11697       {
11698          DU_LOG("\nERROR  -->  F1AP : Sending RRC delivery  msg request failed");
11699          break;
11700       }
11701       ret = ROK;
11702       break;
11703
11704    }while(true);
11705
11706    freeRrcDeliveryReport(f1apMsg);
11707    return ret;
11708 }
11709
11710 /*******************************************************************
11711  *
11712  * @brief Processes cells to be activated
11713  *
11714  * @details
11715  *
11716  *    Function : extractCellsToBeActivated
11717  *
11718  *    Functionality:
11719  *      - Processes cells to be activated list received in F1SetupRsp
11720  *
11721  * @params[in] void
11722  * @return ROK     - success
11723  *         RFAILED - failure
11724  *
11725  * ****************************************************************/
11726
11727 uint8_t extractCellsToBeActivated(Cells_to_be_Activated_List_t cellsToActivate)
11728 {
11729    uint8_t  ret = ROK;
11730    uint16_t idx, nci, pci = 0;
11731    Cells_to_be_Activated_List_Item_t cell;
11732
11733    for(idx=0; idx<cellsToActivate.list.count; idx++)
11734    {
11735       nci = 0;
11736       cell = cellsToActivate.list.array[idx]->value.choice.Cells_to_be_Activated_List_Item;
11737       bitStringToInt(&cell.nRCGI.nRCellIdentity, &nci);
11738
11739       if(cell.nRPCI)
11740       {
11741          pci = *cell.nRPCI;
11742       }
11743       ret = duProcCellsToBeActivated(cell.nRCGI.pLMN_Identity.buf, nci, pci);
11744    }
11745    return ret;
11746 }
11747 /******************************************************************
11748 *
11749 * @brief Processes F1 Setup Response allocated by aper_decoder
11750 *
11751 * @details
11752 *
11753 *    Function : freeF1SetupRsp
11754 *
11755 *    Functionality: free F1 Setup Response allocated by aper_decoder
11756 *
11757 * @params[in] F1SetupResponse_t *f1SetRspMsg
11758 * @return void
11759 *
11760 * ****************************************************************/
11761
11762 void freeAperDecodeF1SetupRsp(F1SetupResponse_t *f1SetRspMsg)
11763 {
11764    uint8_t ieIdx =0;
11765    uint8_t arrIdx =0;
11766    Cells_to_be_Activated_List_t *cellToActivate =NULLP;
11767    RRC_Version_t      *rrcVer =NULLP;
11768
11769    if(f1SetRspMsg->protocolIEs.list.array)
11770    {
11771       for(ieIdx=0; ieIdx<f1SetRspMsg->protocolIEs.list.count; ieIdx++)
11772       {
11773          if(f1SetRspMsg->protocolIEs.list.array[ieIdx])
11774          {
11775             switch(f1SetRspMsg->protocolIEs.list.array[ieIdx]->id)
11776             {
11777                case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11778                   {
11779                      cellToActivate =
11780                         &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.Cells_to_be_Activated_List;
11781                      if(cellToActivate->list.array)
11782                      {
11783                         for(arrIdx=0; arrIdx<cellToActivate->list.count ; arrIdx++)
11784                         {
11785                            if(cellToActivate->list.array[arrIdx])
11786                            {
11787
11788                               if(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.\
11789                               pLMN_Identity.buf)
11790                               {
11791                                  if(cellToActivate->list.array[0]->value.choice.\
11792                                        Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf)
11793                                  {
11794                                     free(cellToActivate->list.array[0]->value.choice.\
11795                                           Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf);
11796                                  }
11797
11798                                  free(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
11799                                        nRCGI.pLMN_Identity.buf);
11800                               }
11801                               free(cellToActivate->list.array[arrIdx]);
11802                            }
11803                         }
11804                         free(cellToActivate->list.array);
11805                      }
11806                      break;
11807                   }
11808                case ProtocolIE_ID_id_TransactionID:
11809                   {
11810                      break;
11811                   }
11812                case ProtocolIE_ID_id_gNB_CU_Name:
11813                   {
11814                      free(f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_Name.buf);
11815                      break;
11816                   }
11817                case ProtocolIE_ID_id_GNB_CU_RRC_Version:
11818                   {
11819                      rrcVer = &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
11820                      if(rrcVer->latest_RRC_Version.buf)
11821                      {
11822                         if(rrcVer->iE_Extensions)
11823                         {
11824                            if(rrcVer->iE_Extensions->list.array)
11825                            {
11826                               if(rrcVer->iE_Extensions->list.array[0])
11827                               {
11828                                  if(rrcVer->iE_Extensions->list.\
11829                                        array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf)
11830                                  {
11831                                     free(rrcVer->iE_Extensions->list.\
11832                                           array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf);
11833                                  }
11834                                  free(rrcVer->iE_Extensions->list.array[0]);
11835                               }
11836                               free(rrcVer->iE_Extensions->list.array);
11837                            }
11838                            free(rrcVer->iE_Extensions);
11839                         }
11840                         free(rrcVer->latest_RRC_Version.buf);
11841                      }
11842                      break;
11843
11844                   }
11845                default:
11846                   {
11847                      DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
11848                            f1SetRspMsg->protocolIEs.list.array[ieIdx]->id);
11849                   }
11850             }
11851             free(f1SetRspMsg->protocolIEs.list.array[ieIdx]);
11852          }
11853       }
11854       free(f1SetRspMsg->protocolIEs.list.array);
11855    }
11856 }
11857 /******************************************************************
11858  *
11859  * @brief Processes F1 Setup Response sent by CU
11860  *
11861  * @details
11862  *
11863  *    Function : procF1SetupRsp
11864  *
11865  *    Functionality: Processes F1 Setup Response sent by CU
11866  *
11867  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11868  * @return ROK     - success
11869  *         RFAILED - failure
11870  *
11871  * ****************************************************************/
11872 uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg)
11873 {
11874    uint8_t ret = ROK;
11875    uint16_t idx =0;
11876    F1SetupResponse_t *f1SetRspMsg = NULLP;
11877    GNB_CU_Name_t     *cuName = NULLP;
11878    F1SetupRsp  f1SetRspDb;
11879    RRC_Version_t      *rrcVer =NULLP;
11880
11881    memset(&f1SetRspDb, 0, sizeof(F1SetupRsp));
11882
11883    DU_LOG("\nINFO   -->  F1AP : F1 Setup Response received");
11884    f1SetRspMsg = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
11885
11886    for(idx=0; idx<f1SetRspMsg->protocolIEs.list.count; idx++)
11887    {
11888       switch(f1SetRspMsg->protocolIEs.list.array[idx]->id)
11889       {
11890          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11891             {
11892                extractCellsToBeActivated(f1SetRspMsg->protocolIEs.list.array[idx]->\
11893                      value.choice.Cells_to_be_Activated_List);
11894                break;
11895             }
11896          case ProtocolIE_ID_id_TransactionID:
11897             {
11898                f1SetRspDb.transId = f1SetRspMsg->protocolIEs.list.array[idx]->\
11899                                     value.choice.TransactionID;
11900                break;
11901             }
11902          case ProtocolIE_ID_id_gNB_CU_Name:
11903             {
11904                cuName = &f1SetRspMsg->protocolIEs.list.array[idx]->\
11905                         value.choice.GNB_CU_Name;
11906                strcpy(f1SetRspDb.cuName, (const char*)cuName->buf);
11907                break;
11908             }
11909          case ProtocolIE_ID_id_GNB_CU_RRC_Version:
11910             {
11911                rrcVer = &f1SetRspMsg->protocolIEs.list.array[idx]->value.choice.RRC_Version;
11912                strcpy(f1SetRspDb.rrcVersion.rrcVer,
11913                      (const char*)rrcVer->latest_RRC_Version.buf);
11914                break;
11915             }
11916          default:
11917             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
11918                   f1SetRspMsg->protocolIEs.list.array[idx]->id);
11919       }
11920       duProcF1SetupRsp();
11921    }
11922
11923    freeAperDecodeF1SetupRsp(f1SetRspMsg);
11924    return ret;
11925 }
11926 /*******************************************************************
11927 *
11928 * @brief free GNB DU config update ack
11929 *
11930 * @details
11931 *
11932 *    Function : freeAperDecodeGnbDuAck
11933 *
11934 *    Functionality: Processes GNB DU config update ack And
11935 *                     added free part for the memory allocated by aper_decoder
11936 *
11937 * @params[in] F1AP_PDU_t ASN decoded F1AP message
11938 * @return ROK     - success
11939 *         RFAILED - failure
11940 *
11941 * ****************************************************************/
11942
11943 void freeAperDecodeGnbDuAck(GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck)
11944 {
11945    uint8_t ieIdx = 0;
11946
11947    if(gnbDuAck->protocolIEs.list.array)
11948    {
11949       for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
11950       {
11951          if(gnbDuAck->protocolIEs.list.array[ieIdx])
11952          {
11953             free(gnbDuAck->protocolIEs.list.array[ieIdx]);
11954          }
11955       }
11956       free(gnbDuAck->protocolIEs.list.array);
11957    }
11958 }
11959
11960 /*******************************************************************
11961 *
11962 * @brief Building  result of gnb-du config update ack output
11963 *
11964 * @details
11965 *
11966 *    Function : duProcGnbDuCfgUpdAckMsg
11967 *
11968 *    Functionality:
11969 *        Building output of gnb-du config update ack
11970 *
11971 * @params[in] transId
11972 * @return void
11973 *
11974 * ****************************************************************/
11975
11976 uint8_t duProcGnbDuCfgUpdAckMsg(uint8_t transId)
11977 {
11978    uint8_t  ieIdx=0, arrIdx=0,ret=ROK;
11979    uint8_t  ueId =0 , ueIdx =0;
11980    uint16_t cellId =0, cellIdx =0, crnti=0;
11981    CmLList *f1apPduNode = NULLP;
11982    ReservedF1apPduInfo *f1apPduInfo =NULLP;
11983    F1AP_PDU_t *f1apMsgPdu = NULLP;
11984    GNBDUConfigurationUpdate_t *gnbDuConfigUpdate = NULLP;
11985    BIT_STRING_t *cellIdentity=NULLP;
11986    struct Served_Cells_To_Delete_ItemIEs *deleteItemIe=NULLP;
11987    Served_Cells_To_Delete_List_t *cellsToDelete=NULLP;
11988    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
11989
11990    DU_LOG("\nINFO   -->  DU APP: GNB-DU config update Ack received ");
11991    f1apPduNode = searchFromReservedF1apPduList(transId);
11992    f1apPduInfo = (ReservedF1apPduInfo *)f1apPduNode->node;
11993    f1apMsgPdu = (F1AP_PDU_t *)f1apPduInfo->f1apMsg;
11994
11995    if(f1apMsgPdu)
11996    {
11997       if(f1apMsgPdu->choice.initiatingMessage)
11998       {
11999          gnbDuConfigUpdate = &f1apMsgPdu->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
12000          for(ieIdx=0; ieIdx < gnbDuConfigUpdate->protocolIEs.list.count; ieIdx++)
12001          {
12002             switch(gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->id)
12003             {
12004                case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
12005                   {
12006                      cellsToDelete = &gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
12007                                      Served_Cells_To_Delete_List;
12008                      if(cellsToDelete->list.array)
12009                      {
12010                         if(cellsToDelete->list.array[arrIdx])
12011                         {
12012                            deleteItemIe = (Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx];
12013                            deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
12014                            if(deleteItem->oldNRCGI.nRCellIdentity.buf)
12015                            {
12016                               cellIdentity = &deleteItem->oldNRCGI.nRCellIdentity;
12017                               bitStringToInt(cellIdentity, &cellId);
12018                            }
12019                         }
12020                      }
12021
12022                      GET_CELL_IDX(cellId, cellIdx);
12023                      if(duCb.actvCellLst[cellIdx] != NULLP)
12024                      {
12025                         if(duCb.actvCellLst[cellIdx]->numActvUes == 0)
12026                         {
12027                            duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
12028                            ret = duSendCellDeletReq(cellId);
12029                            if(ret == RFAILED)
12030                            {
12031                               DU_LOG("ERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to send cell delete\
12032                               request for cellId[%d]", cellId);
12033                            }
12034                         }
12035                         else
12036                         {
12037                            for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
12038                            {
12039                               crnti = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].crnti;
12040                               GET_UE_IDX(crnti,ueId);
12041                               ret = BuildAndSendUeContextReleaseReq(cellId, ueId);
12042                               if(ret == RFAILED)
12043                               {
12044                                  DU_LOG("ERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to build and send UE delete\
12045                                  request for cellId[%d]", cellId);
12046                               }
12047                            }
12048                         }
12049                      }
12050                      else
12051                      {
12052                         DU_LOG("ERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): CellId [%d] not found", cellId);
12053                         ret = RFAILED;
12054                      }
12055                      break;
12056                   }
12057
12058                default:
12059                   break;
12060             }
12061          }
12062       }
12063    }
12064
12065    FreeDUConfigUpdate(f1apMsgPdu);
12066    deleteFromReservedF1apPduList(f1apPduNode);
12067    return ret;
12068 }
12069
12070 /*******************************************************************
12071 *
12072 * @brief Processes GNB DU config update ack
12073 *
12074 * @details
12075 *
12076 *    Function : procF1GNBDUCfgUpdAck
12077 *
12078 *    Functionality: added free part for the memory allocated by aper_decoder
12079 *
12080 * @params[in] F1AP_PDU_t *f1apMsg
12081 * @return void
12082 *
12083 * ****************************************************************/
12084 uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
12085 {
12086    uint8_t ieIdx=0,transId=0;
12087    GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
12088
12089    DU_LOG("\nINFO   -->  F1AP : GNB-DU config update acknowledgment");
12090    gnbDuAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
12091
12092    for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
12093    {
12094       switch(gnbDuAck->protocolIEs.list.array[ieIdx]->id)
12095       {
12096          case ProtocolIE_ID_id_TransactionID:
12097             {
12098                transId = gnbDuAck->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
12099                break;
12100             }
12101          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
12102             {
12103                break;
12104             }
12105          default :
12106             {
12107                DU_LOG("\nERROR  -->  F1AP: procF1GNBDUCfgUpdAck(): Invalid IE Received: %ld", \
12108                      gnbDuAck->protocolIEs.list.array[ieIdx]->id);
12109                break;
12110             }
12111       }
12112    }
12113
12114    duProcGnbDuCfgUpdAckMsg(transId);
12115
12116 #if 0
12117    /* presently we are not supporting F1 Reset from DU to CU , we are only
12118     * supporting F1 Reset from CU to DU */
12119
12120    if(BuildAndSendF1ResetReq() != ROK)
12121    {
12122       return RFAILED;
12123    }
12124 #endif
12125
12126    freeAperDecodeGnbDuAck(gnbDuAck);
12127    return ROK;
12128 }
12129 /******************************************************************
12130 *
12131 * @brief free DL RRC Message Transfer allocated by aper_decoder
12132 *
12133 * @details
12134 *
12135 *    Function : freeAperDecodef1DlRrcMsg
12136 *
12137 *    Functionality: free DL RRC Message Transfer allocated by aper_decoder
12138 *
12139 * @params[in] DLRRCMessageTransfer_t *f1DlRrcMsg
12140 * @return ROK     - success
12141 *         RFAILED - failure
12142 *
12143 * ****************************************************************/
12144
12145 void freeAperDecodef1DlRrcMsg(DLRRCMessageTransfer_t *f1DlRrcMsg)
12146 {
12147    uint8_t ieIdx =0;
12148    RRCContainer_t *rrcContainer = NULLP;
12149
12150    if(f1DlRrcMsg->protocolIEs.list.array)
12151    {
12152       for(ieIdx=0; ieIdx<f1DlRrcMsg->protocolIEs.list.count; ieIdx++)
12153       {
12154          if(f1DlRrcMsg->protocolIEs.list.array[ieIdx])
12155          {
12156             switch(f1DlRrcMsg->protocolIEs.list.array[ieIdx]->id)
12157             {
12158                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12159                   break;
12160                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12161                   break;
12162                case ProtocolIE_ID_id_SRBID:
12163                   break;
12164                case ProtocolIE_ID_id_RRCContainer:
12165                   {
12166                      rrcContainer =&f1DlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
12167                      free(rrcContainer->buf);
12168                   }
12169                case ProtocolIE_ID_id_ExecuteDuplication:
12170                   break;
12171                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
12172                   break;
12173                   break;
12174             }
12175             free(f1DlRrcMsg->protocolIEs.list.array[ieIdx]);
12176          }
12177       }
12178       free(f1DlRrcMsg->protocolIEs.list.array);
12179    }
12180 }
12181 /******************************************************************
12182  *
12183  * @brief Processes DL RRC Message Transfer  sent by CU
12184  *
12185  * @details
12186  *
12187  *    Function : procF1DlRrcMsgTrans
12188  *
12189  *    Functionality: Processes DL RRC Message Transfer sent by CU
12190  *
12191  * @params[in] F1AP_PDU_t ASN decoded F1AP message
12192  * @return ROK     - success
12193  *         RFAILED - failure
12194  *
12195  * ****************************************************************/
12196 uint8_t procF1DlRrcMsgTrans(F1AP_PDU_t *f1apMsg)
12197 {
12198    uint8_t  idx, ret;
12199    DLRRCMessageTransfer_t *f1DlRrcMsg = NULLP;
12200    F1DlRrcMsg dlMsg;
12201    memset(&dlMsg, 0, sizeof(F1DlRrcMsg));
12202
12203    DU_LOG("\nINFO   -->  DU_APP : DL RRC message transfer Recevied");
12204    f1DlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
12205
12206    ret = ROK;
12207
12208    for(idx=0; idx<f1DlRrcMsg->protocolIEs.list.count; idx++)
12209    {
12210       switch(f1DlRrcMsg->protocolIEs.list.array[idx]->id)
12211       {
12212          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12213             {
12214                dlMsg.gnbCuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
12215                break;
12216             }
12217          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12218             {
12219                dlMsg.gnbDuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
12220                break;
12221             }
12222          case ProtocolIE_ID_id_SRBID:
12223             {
12224                dlMsg.srbId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
12225                break;
12226             }
12227          case ProtocolIE_ID_id_ExecuteDuplication:
12228             dlMsg.execDup = true;
12229             break;
12230
12231          case ProtocolIE_ID_id_RRCContainer:
12232             {
12233                if(f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0)
12234                {
12235                   dlMsg.rrcMsgSize = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
12236                   DU_ALLOC_SHRABL_BUF(dlMsg.rrcMsgPdu, dlMsg.rrcMsgSize);
12237                   if(dlMsg.rrcMsgPdu)
12238                   {
12239                      memcpy(dlMsg.rrcMsgPdu, f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
12240                         dlMsg.rrcMsgSize);
12241                   }
12242                   else
12243                   {
12244                      DU_LOG("\nERROR  -->  DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
12245                      return RFAILED;
12246                   }
12247                }
12248                else
12249                {
12250                   DU_LOG("\nERROR  -->  DU_APP : RRC Container Size is invalid:%ld",\
12251                   f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
12252                   return RFAILED;
12253                }
12254                break;
12255             }
12256          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
12257             {
12258                dlMsg.deliveryStatRpt = true;
12259                break;
12260             }
12261          default:
12262             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
12263                   f1DlRrcMsg->protocolIEs.list.array[idx]->id);
12264       }
12265    }
12266
12267    ret = duProcDlRrcMsg(&dlMsg);
12268
12269    freeAperDecodef1DlRrcMsg(f1DlRrcMsg);
12270    return ret;
12271 }
12272 /*******************************************************************
12273  *
12274 * @brief Builds the DRB to be Setup Mod list
12275 *
12276 * @details
12277 *
12278 *    Function :
12279 *
12280 *    Functionality: Constructs the DRB to be Setup Mod list
12281 *
12282 * @params[in] DRBs_SetupMod_List_t *drbSet
12283 *
12284 * @return ROK     - success
12285 *         RFAILED - failure
12286 *
12287 * ****************************************************************/
12288
12289 uint8_t BuildDrbSetupModList(DRBs_SetupMod_List_t *drbSet , DuUeCfg *ueCfg)
12290 {
12291    uint8_t arrIdx =0;
12292    uint8_t drbCnt =0;
12293    struct DRBs_SetupMod_ItemIEs *drbItemIe;
12294
12295    drbCnt = 1;
12296    drbSet->list.count = drbCnt;
12297    drbSet->list.size = drbCnt * sizeof(DRBs_SetupMod_ItemIEs_t *);
12298    DU_ALLOC(drbSet->list.array, drbSet->list.size);
12299    if(drbSet->list.array == NULLP)
12300    {
12301       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
12302       return  RFAILED;
12303    }
12304    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
12305    {
12306       DU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
12307       if(drbSet->list.array[arrIdx] == NULLP)
12308       {
12309               DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
12310               return  RFAILED;
12311       }
12312
12313       drbItemIe = (struct DRBs_SetupMod_ItemIEs *)drbSet->list.array[arrIdx];
12314       drbItemIe->id = ProtocolIE_ID_id_DRBs_SetupMod_Item;
12315       drbItemIe->criticality = Criticality_reject;
12316       drbItemIe->value.present = DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item;
12317       drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
12318       if(fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List,\
12319       &ueCfg->upTnlInfo[arrIdx])!= ROK)
12320       {
12321          DU_LOG("\nERROR  -->  F1AP : Failed to fill DlTnl SetupList in BuildDrbToBeSetupModList");
12322          return RFAILED;
12323       }
12324
12325    }
12326
12327    return ROK;
12328 }
12329 /*******************************************************************
12330 * @brief Free the memory allocated for DRB setup List
12331 *
12332 * @details
12333 *
12334 *    Function : FreeDrbSetupModList
12335 *
12336 *    Functionality:
12337 *       Free the memory allocated for DRB setup list
12338 *
12339 * @params[in] DRBs_Setup_List_t *
12340 * @return void
12341 *
12342 * ****************************************************************/
12343 void FreeDrbSetupModList(DRBs_SetupMod_List_t *drbSetupList)
12344 {
12345    uint8_t arrIdx = 0;
12346    DRBs_SetupMod_ItemIEs_t *drbItemIe = NULLP;
12347
12348    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
12349    {
12350       drbItemIe = ((DRBs_SetupMod_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
12351       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
12352       DU_FREE(drbSetupList->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
12353    }
12354    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
12355 }
12356 /*******************************************************************
12357 * @brief Free the memory allocated for UE Context Mod Response
12358 *
12359 * @details
12360 *
12361 *    Function : FreeUeContextModResp
12362 *
12363 *    Functionality:
12364 *       Free the memory allocated for UE Context Mod Response
12365 *
12366 * @params[in] F1AP_PDU_t *f1apMsg
12367 * @return void
12368 *
12369 * ****************************************************************/
12370
12371 void FreeUeContextModResp(F1AP_PDU_t *f1apMsg)
12372 {
12373    uint8_t ieIdx;
12374    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
12375    if(f1apMsg)
12376    {
12377       if(f1apMsg->choice.successfulOutcome)
12378       {
12379          ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
12380          if(ueContextModifyRes->protocolIEs.list.array)
12381          {
12382             for(ieIdx=0 ; ieIdx<ueContextModifyRes->protocolIEs.list.count; ieIdx++)
12383             {
12384                if(ueContextModifyRes->protocolIEs.list.array[ieIdx])
12385                {
12386                   switch(ueContextModifyRes->protocolIEs.list.array[ieIdx]->id)
12387                   {
12388                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12389                         break;
12390                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12391                         break;
12392                      case ProtocolIE_ID_id_DRBs_SetupMod_List:
12393                         {
12394                             FreeDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
12395                             value.choice.DRBs_SetupMod_List));
12396                             break;
12397                         }
12398                   }
12399                   DU_FREE(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
12400                }
12401
12402             }
12403             DU_FREE(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
12404          }
12405          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12406       }
12407       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12408    }
12409 }
12410
12411 /*****************************************************************i
12412 *
12413 * @brief Creating the ue context modifcation response and sending
12414 *
12415 * @details
12416 *
12417 *    Function : BuildAndSendUeContextModRsp
12418 *
12419 *    Functionality:
12420 *         - Creating the ue context modifcation response
12421 *
12422 * @params[in] uint8_t cellId,uint8_t ueIdx
12423 * @return ROK     - success
12424 *         RFAILED - failure
12425 *
12426 * ****************************************************************/
12427 uint8_t BuildAndSendUeContextModRsp(uint8_t cellId,uint8_t ueIdx)
12428 {
12429    uint8_t   ieIdx = 0;
12430    uint8_t   cellIdx =0;
12431    uint8_t   elementCnt = 0;
12432    uint8_t   ret = RFAILED;
12433    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
12434    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
12435    F1AP_PDU_t *f1apMsg = NULLP;
12436    asn_enc_rval_t         encRetVal;
12437    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
12438    DuUeCb                   *ueCb = NULLP;
12439
12440    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification response\n");
12441
12442    while(1)
12443    {
12444       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12445       if(f1apMsg == NULLP)
12446       {
12447          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
12448          break;
12449       }
12450
12451       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
12452
12453       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12454       if(f1apMsg->choice.successfulOutcome == NULLP)
12455       {
12456          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
12457          break;
12458       }
12459       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextModification;
12460       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
12461       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_UEContextModificationResponse;
12462
12463       ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
12464
12465       elementCnt = 3;
12466       ueContextModifyRes->protocolIEs.list.count = elementCnt;
12467       ueContextModifyRes->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationResponse_t*);
12468
12469       /* Initialize the UE context modification members */
12470       DU_ALLOC(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
12471       if(ueContextModifyRes->protocolIEs.list.array == NULLP)
12472       {
12473          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
12474          break;
12475       }
12476
12477       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
12478       {
12479          DU_ALLOC(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
12480          if(ueContextModifyRes->protocolIEs.list.array[ieIdx] == NULLP)
12481          {
12482             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
12483             break;
12484          }
12485       }
12486
12487       /* Fetching Ue Cb Info*/
12488       GET_CELL_IDX(cellId, cellIdx);
12489       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
12490       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
12491       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
12492
12493       ieIdx=0;
12494       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
12495       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12496       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
12497       UEContextModificationResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
12498       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
12499
12500       ieIdx++;
12501       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
12502       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12503       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present=\
12504       UEContextModificationResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
12505       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
12506
12507       ieIdx++;
12508       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_SetupMod_List;
12509       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12510       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
12511       UEContextModificationResponseIEs__value_PR_DRBs_SetupMod_List;
12512       if(ueCb->f1UeDb)
12513       {
12514          ret = BuildDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
12515                   value.choice.DRBs_SetupMod_List) , &ueCb->f1UeDb->duUeCfg);
12516          if(ret != ROK)
12517          {
12518             DU_LOG( "\nERROR  -->  F1AP : Failed to build drb setupmod List ");
12519             break;
12520          }
12521          freeF1UeDb(ueCb->f1UeDb);
12522          ueCb->f1UeDb = NULLP;
12523       }
12524       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12525
12526       /* Encode the F1SetupRequest type as APER */
12527       memset(encBuf, 0, ENC_BUF_MAX_LEN);
12528       encBufSize = 0;
12529       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,encBuf);
12530
12531       /* Encode results */
12532       if(encRetVal.encoded == ENCODE_FAIL)
12533       {
12534          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
12535                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12536          ret = RFAILED;
12537          break;
12538       }
12539       else
12540       {
12541          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Modification Response\n");
12542          for(int i=0; i< encBufSize; i++)
12543          {
12544             printf("%x",encBuf[i]);
12545          }
12546       }
12547
12548       /* Sending  msg  */
12549       if(sendF1APMsg() != ROK)
12550       {
12551          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Res Failed");
12552          ret = RFAILED;
12553          break;
12554       }
12555       break;
12556    }
12557    FreeUeContextModResp(f1apMsg);
12558    return ret;
12559 }
12560 /*******************************************************************
12561  *
12562  * @brief Deallocating the memory allocated by the aper decoder
12563  *          for QOSInfo
12564  *
12565  * @details
12566  *
12567  *    Function : freeAperDecodeQosInfo
12568  *
12569  *    Functionality:  Deallocating the memory allocated for QOSInfo
12570  *
12571  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
12572  *
12573  * @return void
12574  *
12575  * ****************************************************************/
12576
12577 void freeAperDecodeQosInfo(QoSFlowLevelQoSParameters_t *drbQos)
12578 {
12579    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
12580    {
12581       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
12582       {
12583          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
12584          {
12585             free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
12586          }
12587          free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
12588       }
12589       free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI);
12590    }
12591 }
12592 /*******************************************************************
12593  *
12594  * @brief Deallocating the memory allocated by the aper decoder
12595  *          for UlTnlInfoforDrb
12596  *
12597  * @details
12598  *
12599  *    Function : freeAperDecodeUlTnlInfoforDrbSetupMod
12600  *
12601  *    Functionality:  Deallocating memory allocated for UlTnlInfoforDrb
12602  *
12603  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
12604  *
12605  * @return void
12606  *
12607  * ****************************************************************/
12608 void freeAperDecodeUlTnlInfoforDrbSetupMod(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
12609 {
12610    uint8_t arrIdx =0;
12611
12612    if(ulInfo->list.array)
12613    {
12614       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
12615       {
12616          if(ulInfo->list.array[arrIdx])
12617          {
12618             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
12619             {
12620                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
12621                {
12622                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
12623                   {
12624                      free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12625                            gTP_TEID.buf);
12626                   }
12627                   free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12628                         transportLayerAddress.buf);
12629                }
12630                free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel);
12631             }
12632             free(ulInfo->list.array[arrIdx]);
12633          }
12634       }
12635       free(ulInfo->list.array);
12636    }
12637 }
12638 /*******************************************************************
12639  *
12640  * @brief Deallocating the memory allocated by the aper decoder
12641  *          for DrbSetupModItem
12642  *
12643  * @details
12644  *
12645  *    Function : freeAperDecodeDrbSetupModItem
12646  *
12647  *    Functionality:  Deallocating memory allocated for DrbSetupModItem
12648  *
12649  * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
12650  *
12651  * @return void
12652  *
12653  * ****************************************************************/
12654
12655 void freeAperDecodeDrbSetupModItem(DRBs_ToBeSetupMod_Item_t *drbItem)
12656 {
12657    uint8_t arrIdx =0;
12658    SNSSAI_t *snssai =NULLP;
12659    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
12660
12661    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
12662    switch(drbItem->qoSInformation.present)
12663    {
12664       case QoSInformation_PR_NOTHING:
12665          break;
12666       case QoSInformation_PR_eUTRANQoS:
12667          {
12668             if(drbItem->qoSInformation.choice.eUTRANQoS)
12669             {
12670                free(drbItem->qoSInformation.choice.eUTRANQoS);
12671             }
12672             break;
12673          }
12674       case QoSInformation_PR_choice_extension:
12675          {
12676             if(drbItem->qoSInformation.choice.choice_extension)
12677             {
12678                freeAperDecodeQosInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.\
12679                      DRB_Information.dRB_QoS);
12680                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
12681                if(snssai->sST.buf)
12682                {
12683                   free(snssai->sST.buf);
12684                }
12685                if(snssai->sD)
12686                {
12687                   if(snssai->sD->buf)
12688                   {
12689                      free(snssai->sD->buf);
12690                   }
12691                   free(snssai->sD);
12692                }
12693
12694                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.\
12695                          DRB_Information.flows_Mapped_To_DRB_List;
12696                if(flowMap->list.array)
12697                {
12698                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
12699                   {
12700                      if(flowMap->list.array[arrIdx] )
12701                      {
12702                         freeAperDecodeQosInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
12703                         free(flowMap->list.array[arrIdx]);
12704                      }
12705                   }
12706                   free(flowMap->list.array);
12707                }
12708
12709                free(drbItem->qoSInformation.choice.choice_extension);
12710             }
12711             break;
12712          }
12713
12714    }
12715    freeAperDecodeUlTnlInfoforDrbSetupMod(&drbItem->uLUPTNLInformation_ToBeSetup_List);
12716    if(drbItem->uLConfiguration)
12717    {
12718       free(drbItem->uLConfiguration);
12719    }
12720 }
12721
12722 /*******************************************************************
12723  *
12724  * @brief Deallocating the memory allocated by the aper decoder
12725  *          for DrbToBeSetupModList
12726  *
12727  * @details
12728  *
12729  *    Function : freeAperDecodeDrbToBeSetupModList
12730  *
12731  *    Functionality:  Deallocating memory allocated for DrbToBeSetupModList
12732  *
12733  * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
12734  *
12735  * @return void
12736  *
12737  * ****************************************************************/
12738
12739 void freeAperDecodeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
12740 {
12741    uint8_t arrIdx =0;
12742    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
12743
12744    if(drbSet->list.array)
12745    {
12746       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
12747       {
12748          if(drbSet->list.array[arrIdx] != NULLP)
12749          {
12750             if(arrIdx == 0)
12751             {
12752                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
12753                freeAperDecodeDrbSetupModItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
12754             }
12755             free(drbSet->list.array[arrIdx]);
12756          }
12757       }
12758       free(drbSet->list.array);
12759    }
12760
12761 }
12762 /*******************************************************************
12763  *
12764  * @brief Deallocating the memory allocated by the aper decoder
12765  *          for UeContextModificationReqMsg
12766  *
12767  * @details
12768  *
12769  *    Function : freeAperDecodeUeContextModificationReqMsg
12770  *
12771  *    Functionality:  Deallocating memory allocated for
12772  *                  UeContextModificationReqMsg
12773  *
12774  * @params[in] UEContextModificationRequest_t *UeContextModifyReq
12775  *
12776  * @return void
12777  *
12778  * ****************************************************************/
12779 void freeAperDecodeUeContextModificationReqMsg(UEContextModificationRequest_t *UeContextModifyReq )
12780 {
12781    uint8_t arrIdx, ieId;
12782
12783    if(UeContextModifyReq->protocolIEs.list.array)
12784    {
12785       for( arrIdx = 0 ; arrIdx<UeContextModifyReq->protocolIEs.list.count ; arrIdx++)
12786       {
12787          if(UeContextModifyReq->protocolIEs.list.array[arrIdx])
12788          {
12789             ieId = UeContextModifyReq->protocolIEs.list.array[arrIdx]->id;
12790             switch(ieId)
12791             {
12792                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12793                   break;
12794                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12795                   break;
12796                case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
12797                   {
12798                      freeAperDecodeDrbToBeSetupModList(&UeContextModifyReq->protocolIEs.list.array[arrIdx]->\
12799                            value.choice.DRBs_ToBeSetupMod_List);
12800                      break;
12801                   }
12802             }
12803             free(UeContextModifyReq->protocolIEs.list.array[arrIdx]);
12804          }
12805       }
12806       free(UeContextModifyReq->protocolIEs.list.array);
12807    }
12808 }
12809 /*******************************************************************
12810  *
12811  * @brief processing the F1 UeContextModificationReq
12812  *
12813  * @details
12814  *
12815  *    Function : procF1UeContextModificationReq
12816  *
12817  *    Functionality:  processing the F1 UeContextModificationReq
12818  *
12819  * @params[in] F1AP_PDU_t *f1apMsg
12820  *
12821  * @return
12822  * ****************************************************************/
12823 uint8_t procF1UeContextModificationReq(F1AP_PDU_t *f1apMsg)
12824 {
12825    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
12826    uint8_t  ret = ROK, ieIdx = 0, lcId =0,cellIdx=0, ueIdx=0;
12827    DuUeCb   *duUeCb = NULLP;
12828    DRBs_ToBeSetupMod_List_t *drbSetupModCfg;
12829    uint32_t gnbCuUeF1apId, gnbDuUeF1apId;
12830
12831    ueContextModifyReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
12832    for(ieIdx=0; (ieIdx < ueContextModifyReq->protocolIEs.list.count && ret == ROK); ieIdx++)
12833    {
12834       switch(ueContextModifyReq->protocolIEs.list.array[ieIdx]->id)
12835       {
12836          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12837             {
12838                gnbCuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
12839                break;
12840             }
12841          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12842             {
12843                gnbDuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
12844                break;
12845             }
12846          case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
12847             {
12848                for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
12849                {
12850                   for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
12851                   {
12852                      if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
12853                            (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
12854                      {
12855
12856                         duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
12857                         lcId = getDrbLcId(&duUeCb->drbBitMap);
12858                         if(lcId != RFAILED)
12859                         {
12860                            DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
12861                            if(duUeCb->f1UeDb)
12862                            {
12863                               duUeCb->f1UeDb->actionType = UE_CTXT_MOD;
12864                               drbSetupModCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
12865                               choice.DRBs_ToBeSetupMod_List;
12866                               if(extractDrbListToSetup(lcId, NULL, drbSetupModCfg ,drbSetupModCfg->list.count, \
12867                               &duUeCb->f1UeDb->duUeCfg))
12868                               {
12869                                  DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetup()");
12870                                  ret = RFAILED;
12871                               }
12872                            }
12873                         }
12874                         break;
12875                      }
12876                   }
12877                   if(ueIdx >= duCb.actvCellLst[cellIdx]->numActvUes)
12878                   {
12879                      DU_LOG("\nERROR  -->  DU APP : wrong values of gnbCuUeF1apId and gnbDuUeF1apId ");
12880                      ret = RFAILED;
12881                   }
12882                }
12883                break;
12884             }
12885       }
12886    }
12887    if(ret != RFAILED)
12888    {
12889       ret = duProcUeContextModReq(duUeCb);
12890    }
12891    freeAperDecodeUeContextModificationReqMsg(ueContextModifyReq);
12892    return ret;
12893 }
12894 /*****************************************************************i
12895 *
12896 * @brief Free memory allocated for UE Context Release Request
12897 *
12898 * @details
12899 *
12900 *    Function : FreeUeContextReleaseReq
12901 *
12902 *    Functionality:
12903 *         - Free memory allocated for UE Context Release Request
12904 *
12905 * @params[in] F1AP_PDU_t *f1apMsg
12906 * @return void
12907 *
12908 * *************************************************************/
12909 void FreeUeContextReleaseReq(F1AP_PDU_t *f1apMsg)
12910 {
12911    uint8_t ieIdx;
12912    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
12913
12914    if(f1apMsg)
12915    {
12916       if(f1apMsg->choice.initiatingMessage)
12917       {
12918          ueReleaseReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
12919          if(ueReleaseReq->protocolIEs.list.array)
12920          {
12921             for(ieIdx=0 ; ieIdx<ueReleaseReq->protocolIEs.list.count; ieIdx++)
12922             {
12923                DU_FREE(ueReleaseReq->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseRequest_t));
12924             }
12925             DU_FREE(ueReleaseReq->protocolIEs.list.array, ueReleaseReq->protocolIEs.list.size);
12926          }
12927          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
12928       }
12929       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12930    }
12931
12932 }
12933 /*****************************************************************i
12934 *
12935 * @brief Build and Send UE Context Release Request
12936 *
12937 * @details
12938 *
12939 *    Function : BuildAndSendUeContextReleaseReq
12940 *
12941 *    Functionality:
12942 *         - Build and Send UE Context Release Request
12943 *
12944 * @params[in]
12945 * @return ROK     - success
12946 *         RFAILED - failure
12947 *
12948 * *************************************************************/
12949 uint8_t BuildAndSendUeContextReleaseReq(uint16_t cellId, uint8_t ueIdx)
12950 {
12951    bool memAllocFail = false;
12952    uint8_t ieIdx =0;
12953    uint8_t ret = RFAILED;
12954    uint16_t cellIdx =0;
12955    uint16_t crnti = 0;
12956    uint8_t  elementCnt = 0;
12957    uint32_t  gnbCuUeF1apId =0;   /* gNB-CU UE F1AP Id */
12958    uint32_t  gnbDuUeF1apId =0;   /* gNB-DU UE F1AP Id */
12959    asn_enc_rval_t encRetVal;
12960    F1AP_PDU_t *f1apMsg = NULLP;
12961    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
12962
12963    DU_LOG("\nINFO  --> Building the UE Context Release Request");
12964    do
12965    {
12966       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12967       if(f1apMsg == NULLP)
12968       {
12969          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for f1apMsg");
12970          break;
12971       }
12972
12973       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
12974       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
12975       if(f1apMsg->choice.initiatingMessage == NULLP)
12976       {
12977          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for\
12978          initiatingMessage");
12979          break;
12980       }
12981       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextReleaseRequest;
12982       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
12983       f1apMsg->choice.initiatingMessage->value.present = \
12984       InitiatingMessage__value_PR_UEContextReleaseRequest;
12985
12986       ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
12987
12988       elementCnt = 2;
12989
12990       ueReleaseReq->protocolIEs.list.count = elementCnt;
12991       ueReleaseReq->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseRequest_t *);
12992
12993       /* Initialize the F1Setup members */
12994       DU_ALLOC(ueReleaseReq->protocolIEs.list.array,ueReleaseReq->protocolIEs.list.size);
12995       if(ueReleaseReq->protocolIEs.list.array == NULLP)
12996       {
12997          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE array");
12998          break;
12999       }
13000       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
13001       {
13002          DU_ALLOC(ueReleaseReq->protocolIEs.list.array[ieIdx],\
13003                sizeof(UEContextReleaseRequest_t));
13004          if(ueReleaseReq->protocolIEs.list.array[ieIdx] == NULLP)
13005          {
13006             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE elements");
13007             memAllocFail = true;
13008             break;
13009          }
13010       }
13011       if(memAllocFail == true)
13012          break;
13013
13014       /* Fetching Ue Cb Info*/
13015       GET_CELL_IDX(cellId, cellIdx);
13016       if(duCb.actvCellLst[cellIdx] == NULLP)
13017       {
13018          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): CellId[%d] does not exist", cellId);
13019          break;
13020       }
13021       else
13022       {
13023          GET_CRNTI(crnti, ueIdx);
13024          if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].crnti != crnti)
13025          {
13026             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): crnti[%d] does not exist", crnti);
13027             break;
13028          }
13029          gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
13030          gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
13031       }
13032
13033       ieIdx=0;
13034       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
13035       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13036       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present = \
13037       UEContextReleaseRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
13038       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
13039
13040       ieIdx++;
13041       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
13042       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13043       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present =\
13044       UEContextReleaseRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
13045       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
13046
13047       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13048
13049       /* Encode the F1SetupRequest type as APER */
13050       memset(encBuf, 0, ENC_BUF_MAX_LEN);
13051       encBufSize = 0;
13052       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
13053       /* Encode results */
13054       if(encRetVal.encoded == ENCODE_FAIL)
13055       {
13056          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseRequest structure (at %s)\n",\
13057                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13058          break;
13059       }
13060       else
13061       {
13062          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseRequest\n");
13063          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
13064          {
13065             printf("%x",encBuf[ieIdx]);
13066          }
13067       }
13068
13069       /* Sending msg */
13070       if(sendF1APMsg() != ROK)
13071       {
13072          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Request failed");
13073          break;
13074       }
13075       ret = ROK;
13076       break;
13077    }while(true);
13078
13079    FreeUeContextReleaseReq(f1apMsg);
13080    return ret;
13081 }
13082 /*****************************************************************i
13083  *
13084  * @brief Free memory allocated for UE Context Release Complete
13085  *
13086  * @details
13087  *
13088  *    Function : FreeUeContextReleaseComplete
13089  *
13090  *    Functionality:
13091  *         - Free memory allocated for UE Context Release Complete
13092  *
13093  * @params[in] F1AP_PDU_t *f1apMsg
13094  * @return void
13095  *
13096  * *************************************************************/
13097 void FreeUeContextReleaseComplete(F1AP_PDU_t *f1apMsg)
13098 {
13099    uint8_t ieIdx;
13100    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
13101
13102    if(f1apMsg)
13103    {
13104       if(f1apMsg->choice.successfulOutcome)
13105       {
13106          ueReleaseComplete =&f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
13107          if(ueReleaseComplete->protocolIEs.list.array)
13108          {
13109             for(ieIdx=0 ; ieIdx<ueReleaseComplete->protocolIEs.list.count; ieIdx++)
13110             {
13111                DU_FREE(ueReleaseComplete->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseComplete_t));
13112             }
13113             DU_FREE(ueReleaseComplete->protocolIEs.list.array, ueReleaseComplete->protocolIEs.list.size);
13114          }
13115          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
13116       }
13117       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
13118    }
13119
13120 }
13121 /*****************************************************************i
13122  *
13123  * @brief Build and Send UE Context Release Complete
13124  *
13125  * @details
13126  *
13127  *    Function : BuildAndSendUeContextReleaseComplete
13128  *
13129  *    Functionality:
13130  *         - Build and Send UE Context Release Complete
13131  *
13132  * @params[in]  cellId,  gnbCuUeF1apId, gnbDuUeF1apId
13133  * @return ROK     - success
13134  *         RFAILED - failure
13135  *
13136  * *************************************************************/
13137 uint8_t BuildAndSendUeContextReleaseComplete(uint16_t cellId, uint32_t gnbCuUeF1apId, uint32_t gnbDuUeF1apId)
13138 {
13139    bool memAllocFail = false;
13140    uint8_t ieIdx =0, ret = RFAILED, elementCnt = 0;
13141    asn_enc_rval_t encRetVal;
13142    F1AP_PDU_t *f1apMsg = NULLP;
13143    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
13144
13145    DU_LOG("\nINFO  --> Building the UE Context Release Complete");
13146    do
13147    {
13148       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
13149       if(f1apMsg == NULLP)
13150       {
13151          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for f1apMsg");
13152          break;
13153       }
13154
13155       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
13156       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
13157       if(f1apMsg->choice.successfulOutcome == NULLP)
13158       {
13159          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for\
13160                successfulOutcome");
13161          break;
13162       }
13163       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextRelease;
13164       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
13165       f1apMsg->choice.successfulOutcome->value.present = \
13166       SuccessfulOutcome__value_PR_UEContextReleaseComplete;
13167
13168       ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
13169
13170       elementCnt = 2;
13171       ueReleaseComplete->protocolIEs.list.count = elementCnt;
13172       ueReleaseComplete->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseComplete_t *);
13173
13174       /* Initialize the UE Release Complete members */
13175       DU_ALLOC(ueReleaseComplete->protocolIEs.list.array,ueReleaseComplete->protocolIEs.list.size);
13176       if(ueReleaseComplete->protocolIEs.list.array == NULLP)
13177       {
13178          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE array");
13179          break;
13180       }
13181       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
13182       {
13183          DU_ALLOC(ueReleaseComplete->protocolIEs.list.array[ieIdx],\
13184                sizeof(UEContextReleaseComplete_t));
13185          if(ueReleaseComplete->protocolIEs.list.array[ieIdx] == NULLP)
13186          {
13187             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE\
13188             elements");
13189             memAllocFail = true;
13190             break;
13191          }
13192       }
13193       if(memAllocFail == true)
13194          break;
13195
13196
13197       ieIdx=0;
13198       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
13199       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13200       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present = \
13201       UEContextReleaseCompleteIEs__value_PR_GNB_CU_UE_F1AP_ID;
13202       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
13203
13204       ieIdx++;
13205       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
13206       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13207       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present =\
13208       UEContextReleaseCompleteIEs__value_PR_GNB_DU_UE_F1AP_ID;
13209       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
13210
13211       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13212
13213       /* Encode the F1SetupComplete type as APER */
13214       memset(encBuf, 0, ENC_BUF_MAX_LEN);
13215       encBufSize = 0;
13216       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
13217       /* Encode results */
13218       if(encRetVal.encoded == ENCODE_FAIL)
13219       {
13220          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseComplete structure (at %s)\n",\
13221                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13222          break;
13223       }
13224       else
13225       {
13226          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseComplete\n");
13227          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
13228          {
13229             printf("%x",encBuf[ieIdx]);
13230          }
13231       }
13232
13233       /* Sending msg */
13234       if(sendF1APMsg() != ROK)
13235       {
13236          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Complete failed");
13237          break;
13238       }
13239       ret = ROK;
13240       break;
13241    }while(true);
13242
13243    if(ret == ROK)
13244    {
13245       duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
13246       ret = duSendCellDeletReq(cellId);
13247       if(ret != ROK)
13248       {
13249          DU_LOG("\nERROR  -->  F1AP: BuildAndSendUeContextReleaseComplete(): Failed to process cell\
13250                Delete req for CellId");
13251       }
13252    }
13253    FreeUeContextReleaseComplete(f1apMsg);
13254    return ret;
13255
13256 }
13257
13258 /*******************************************************************
13259 *
13260 * @brief added free part for the memory allocated by aper_decoder
13261 *
13262 * @details
13263 *
13264 *    Function : freeAperDecodeUeContextReleaseCommand
13265 *
13266 *    Functionality: added free part for the memory allocated by aper_decoder
13267 *
13268 * @params[in] F1AP_PDU_t *f1apMsg
13269 * @return void
13270 *
13271 * ****************************************************************/
13272 void freeAperDecodeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
13273 {
13274    uint8_t ieIdx=0;
13275    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
13276
13277    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
13278
13279    if(ueContextReleaseCommand->protocolIEs.list.array)
13280    {
13281       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
13282       {
13283          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
13284          {
13285             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
13286             {
13287                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13288                   break;
13289                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13290                   break;
13291                case ProtocolIE_ID_id_Cause:
13292                   break;
13293                case ProtocolIE_ID_id_RRCContainer:
13294                {
13295                   if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
13296                   {
13297                      free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
13298                   }
13299                   break;
13300                }
13301                default :
13302                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
13303                        ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
13304                   break;
13305             }
13306          }
13307          free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]);
13308       }
13309       free(ueContextReleaseCommand->protocolIEs.list.array);
13310    }
13311 }
13312 /*******************************************************************
13313 *
13314 * @brief processing of UE Context Release Command
13315 *
13316 * @details
13317 *
13318 *    Function : procF1UeContextReleaseCommand
13319 *
13320 *    Functionality: processing of UE Context Release Command
13321 *
13322 * @params[in] F1AP_PDU_t *f1apMsg
13323 * @return void
13324 *
13325 * ****************************************************************/
13326 uint8_t procF1UeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
13327 {
13328    uint8_t  ieIdx=0, ret=ROK, ueIdx=0;
13329    uint16_t cellIdx =0;
13330    bool ueIdxFound;
13331    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0;
13332    DuUeCb   *duUeCb = NULLP;
13333    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
13334
13335    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
13336
13337    if(ueContextReleaseCommand->protocolIEs.list.array)
13338    {
13339       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
13340       {
13341          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
13342          {
13343             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
13344             {
13345                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13346                   {
13347                      gnbCuUeF1apId= ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13348                                     value.choice.GNB_CU_UE_F1AP_ID;
13349                      break;
13350                   }
13351
13352                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13353                   {
13354                      gnbDuUeF1apId = ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13355                                      value.choice.GNB_DU_UE_F1AP_ID;
13356                      break;
13357                   }
13358
13359                case ProtocolIE_ID_id_Cause:
13360                   {
13361                      break;
13362                   }
13363
13364                case ProtocolIE_ID_id_RRCContainer:
13365                   {
13366                      for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
13367                      {
13368                         for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
13369                         {
13370                            if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
13371                                  (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
13372                            {
13373                               duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
13374                               DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
13375                               if(duUeCb->f1UeDb)
13376                               {
13377                                  memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
13378                                  duUeCb->f1UeDb->actionType = UE_CTXT_RELEASE;
13379                                  duUeCb->f1UeDb->cellIdx = cellIdx;
13380                                  /* Filling Dl RRC Msg Info */
13381                                  DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
13382                                  if(!duUeCb->f1UeDb->dlRrcMsg)
13383                                  {
13384                                     DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
13385                                     Memory allocation failed ");
13386                                     ret = RFAILED;
13387                                  }
13388                                  else
13389                                  {
13390                                     duUeCb->f1UeDb->dlRrcMsgPres = true;
13391                                     memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
13392                                     ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
13393                                           &ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13394                                           value.choice.RRCContainer);
13395                                  }
13396
13397                               }
13398                               else
13399                               {
13400                                  DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
13401                                  Memory allocation failed ");
13402                                  ret = RFAILED;
13403
13404                               }
13405
13406                               ueIdxFound = true;
13407                               break;
13408                            }
13409                         }
13410                         if(ueIdxFound == true)
13411                         {
13412                            break;
13413                         }
13414                      }
13415                      if(!ueIdxFound)
13416                      {
13417                         DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
13418                         ret = RFAILED;
13419                      }
13420
13421
13422                      break;
13423                   }
13424                default :
13425                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
13426                         ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
13427                   break;
13428             }
13429          }
13430       }
13431    }
13432    if(ret != RFAILED)
13433    {
13434       duProcUeContextReleaseCommand(duUeCb);
13435    }
13436    freeAperDecodeUeContextReleaseCommand(f1apMsg);
13437    return ret;
13438 }
13439 /**************************************************************
13440  *
13441  * @brief Handles received F1AP message and sends back response
13442  *
13443  * @details
13444  *
13445  *    Function : F1APMsgHdlr
13446  *
13447  *    Functionality:
13448  *         - Decodes received F1AP control message
13449  *         - Prepares response message, encodes and sends to SCTP
13450  *
13451  * @params[in]
13452  * @return ROK     - success
13453  *         RFAILED - failure
13454  *
13455  * ****************************************************************/
13456 void F1APMsgHdlr(Buffer *mBuf)
13457 {
13458    int i =0;
13459    char *recvBuf =NULLP;
13460    MsgLen copyCnt =0;
13461    MsgLen recvBufLen =0;
13462    F1AP_PDU_t *f1apMsg =NULLP;
13463    asn_dec_rval_t rval; /* Decoder return value */
13464    F1AP_PDU_t f1apasnmsg ;
13465    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
13466    ODU_PRINT_MSG(mBuf, 0,0);
13467
13468    /* Copy mBuf into char array to decode it */
13469    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
13470    DU_ALLOC(recvBuf, (Size)recvBufLen);
13471
13472    if(recvBuf == NULLP)
13473    {
13474       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
13475       return;
13476    }
13477    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
13478    {
13479       DU_LOG("\nERROR   -->  F1AP : Failed while copying %d", copyCnt);
13480       return;
13481    }
13482
13483    printf("\nDEBUG   -->  F1AP : Received flat buffer to be decoded : ");
13484    for(i=0; i< recvBufLen; i++)
13485    {
13486       printf("%x",recvBuf[i]);
13487    }
13488
13489    /* Decoding flat buffer into F1AP messsage */
13490    f1apMsg = &f1apasnmsg;
13491    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
13492
13493    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
13494    DU_FREE(recvBuf, (Size)recvBufLen);
13495
13496    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
13497    {
13498       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
13499       return;
13500    }
13501    printf("\n");
13502    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13503
13504    switch(f1apMsg->present)
13505    {
13506       case F1AP_PDU_PR_successfulOutcome:
13507          {
13508             switch(f1apMsg->choice.successfulOutcome->value.present)
13509             {
13510                case SuccessfulOutcome__value_PR_ResetAcknowledge:
13511                   {
13512                      DU_LOG("\nINFO   -->  F1AP : F1ResetAcknowledge is received successfully ");
13513                      break;
13514                   }
13515                case SuccessfulOutcome__value_PR_F1SetupResponse:
13516                   {
13517 #ifndef ODU_TEST_STUB
13518                      procF1SetupRsp(f1apMsg);
13519 #endif
13520                      break;
13521                   }
13522
13523                case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
13524                   {
13525                      procF1GNBDUCfgUpdAck(f1apMsg);
13526                      break;
13527                   }
13528
13529                default:
13530                   {
13531                      DU_LOG("\nERROR  -->  F1AP : Invalid type of SuccessfulOutcome__value_PR_ResetAcknowledge [%d]",\
13532                            f1apMsg->choice.successfulOutcome->value.present);
13533                      return;
13534                   }
13535             }/* End of switch(successfulOutcome) */
13536             free(f1apMsg->choice.successfulOutcome);
13537             break;
13538          }
13539       case F1AP_PDU_PR_initiatingMessage:
13540          {
13541             switch(f1apMsg->choice.initiatingMessage->value.present)
13542             {
13543                case InitiatingMessage__value_PR_Reset:
13544                   {
13545                      procF1ResetReq(f1apMsg);
13546                      break;
13547                   }
13548                case InitiatingMessage__value_PR_DLRRCMessageTransfer:
13549                   {
13550                      procF1DlRrcMsgTrans(f1apMsg);
13551                      break;
13552                   }
13553                case InitiatingMessage__value_PR_UEContextSetupRequest:
13554                   {
13555                      procF1UeContextSetupReq(f1apMsg);
13556                      break;
13557                   }
13558                case InitiatingMessage__value_PR_UEContextModificationRequest:
13559                   {
13560                      procF1UeContextModificationReq(f1apMsg);
13561                      break;
13562                   }
13563                case InitiatingMessage__value_PR_UEContextReleaseCommand:
13564                   {
13565                       procF1UeContextReleaseCommand(f1apMsg);
13566                       break;
13567                   }
13568                default:
13569                   {
13570                      DU_LOG("\nERROR  -->  F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
13571                            f1apMsg->choice.initiatingMessage->value.present);
13572                      return;
13573                   }
13574             }/* End of switch(initiatingMessage) */
13575             free(f1apMsg->choice.initiatingMessage);
13576             break;
13577          }
13578
13579       default:
13580          {
13581             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
13582             return;
13583          }
13584          free(f1apMsg);
13585
13586    }/* End of switch(f1apMsg->present) */
13587
13588 } /* End of F1APMsgHdlr */
13589
13590 /**********************************************************************
13591   End of file
13592  **********************************************************************/