src/du_app/du_f1ap_msg_hdl.c

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   4 #                                                                              #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
   6 #   you may not use this file except in compliance with the License.           #
   7 #   You may obtain a copy of the License at                                    #
   8 #                                                                              #
   9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10 #                                                                              #
  11 #   Unless required by applicable law or agreed to in writing, software        #
  12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
  14 #   See the License for the specific language governing permissions and        #
  15 #   limitations under the License.                                             #
  16 ################################################################################
  17 *******************************************************************************/
  18
  19 /* This file contains F1AP message handler functions */
  20 #include "common_def.h"
  21 #include "lrg.h"
  22 #include "legtp.h"
  23 #include "lkw.x"
  24 #include "lrg.x"
  25 #include "F1AP-PDU.h"
  26 #include "du_app_mac_inf.h"
  27 #include "du_cfg.h"
  28 #include "du_app_rlc_inf.h"
  29 #include "du_mgr_main.h"
  30 #include "du_utils.h"
  31 #include "RAT-Type.h"
  32 #include "FeatureSetUplinkPerCC.h"
  33 #include "FeatureSetDownlinkPerCC.h"
  34 #include "FeatureSets.h"
  35 #include "UE-NR-Capability.h"
  36 #include "UE-CapabilityRAT-Container.h"
  37 #include "UE-CapabilityRAT-ContainerListRRC.h"
  38 #include "GNB-DU-System-Information.h"
  39 #include "CellGroupConfigRrc.h"
  40 #include "MAC-CellGroupConfig.h"
  41 #include "SchedulingRequestConfig.h"
  42 #include "SchedulingRequestToAddMod.h"
  43 #include "BSR-Config.h"
  44 #include "TAG-Config.h"
  45 #include "TAG.h"
  46 #include "PHR-Config.h"
  47 #include "RLC-Config.h"
  48 #include "UL-AM-RLC.h"
  49 #include "DL-AM-RLC.h"
  50 #include "LogicalChannelConfig.h"
  51 #include "RLC-BearerConfig.h"
  52 #include "PhysicalCellGroupConfig.h"
  53 #include "SpCellConfig.h"
  54 #include "TDD-UL-DL-ConfigDedicated.h"
  55 #include "ServingCellConfig.h"
  56 #include "ControlResourceSet.h"
  57 #include "SearchSpace.h"
  58 #include "PDCCH-Config.h"
  59 #include "PDSCH-TimeDomainResourceAllocation.h"
  60 #include "PDSCH-TimeDomainResourceAllocationList.h"
  61 #include "PDSCH-CodeBlockGroupTransmission.h"
  62 #include "PDSCH-ServingCellConfig.h"
  63 #include "DMRS-DownlinkConfig.h"
  64 #include "PDSCH-Config.h"
  65 #include "BWP-DownlinkDedicated.h"
  66 #include "PUSCH-TimeDomainResourceAllocation.h"
  67 #include "PUSCH-TimeDomainResourceAllocationList.h"
  68 #include "DMRS-UplinkConfig.h"
  69 #include "PUSCH-Config.h"
  70 #include "SRS-ResourceId.h"
  71 #include "SRS-Resource.h"
  72 #include "SRS-ResourceSet.h"
  73 #include "SRS-Config.h"
  74 #include "BWP-UplinkDedicated.h"
  75 #include "PUSCH-ServingCellConfig.h"
  76 #include "UplinkConfig.h"
  77 #include "DUtoCURRCContainer.h"
  78 #include "GBR-QoSFlowInformation.h"
  79 #include "QoSFlowLevelQoSParameters.h"
  80 #include "PUCCH-Config.h"
  81 #include "PUCCH-ResourceSet.h"
  82 #include "PUCCH-Resource.h"
  83 #include "PUCCH-PowerControl.h"
  84 #include "P0-PUCCH.h"
  85 #include "PUCCH-PathlossReferenceRS.h"
  86 #include "PUCCH-format0.h"
  87 #include "PUCCH-format1.h"
  88 #include "PUCCH-format2.h"
  89 #include "PUCCH-format3.h"
  90 #include "PUCCH-format4.h"
  91 #include "PUCCH-FormatConfig.h"
  92 #include "SchedulingRequestResourceConfig.h"
  93 #include<ProtocolIE-Field.h>
  94 #include "ProtocolExtensionField.h"
  95 #include "odu_common_codec.h"
  96 #include "du_mgr.h"
  97 #include "du_cell_mgr.h"
  98 #include "du_f1ap_msg_hdl.h"
  99 #include "DRBs-Setup-Item.h"
 100 #include "DLUPTNLInformation-ToBeSetup-List.h"
 101 #include "DLUPTNLInformation-ToBeSetup-Item.h"
 102 #include "UPTransportLayerInformation.h"
 103 #include "GTPTunnel.h"
 104
 105 #ifdef O1_ENABLE
 106 #include "ConfigInterface.h"
 107 extern StartupConfig g_cfg;
 108 #endif
 109
 110 DuCfgParams duCfgParam;
 111
 112 /************************************************************************
 113  *
 114  * @brief Converts enum values into actual value of Poll retransmit timer
 115  *
 116  * @details
 117  *
 118  *    Function : getPollPdu
 119  *
 120  *    Functionality: Converts enum values into actual value of poll
 121  *    retransmit timer
 122  *
 123  * @params[in] Enum value of pollPdu
 124  * @return Actual value of pollPdu
 125  *
 126  * **********************************************************************/
 127
 128 uint16_t getPollRetxTmr(uint8_t pollRetxTmrCfg)
 129 {
 130    uint16_t pollRetxTmr;
 131
 132    /* All values of poll retx timer are at interval of 5ms.
 133     * This is valid upto 250ms
 134     * Hence converting the enum value to actual value by multiplying it to 5
 135     */
 136    if(pollRetxTmrCfg <= T_PollRetransmit_ms250)
 137       pollRetxTmr = (pollRetxTmrCfg + 1) * 5;
 138    else
 139    {
 140       switch(pollRetxTmrCfg)
 141       {
 142          case T_PollRetransmit_ms300:
 143             pollRetxTmr = 300;
 144             break;
 145          case T_PollRetransmit_ms350:
 146             pollRetxTmr = 350;
 147             break;
 148          case T_PollRetransmit_ms400:
 149             pollRetxTmr = 400;
 150             break;
 151          case T_PollRetransmit_ms450:
 152             pollRetxTmr = 450;
 153             break;
 154          case T_PollRetransmit_ms500:
 155             pollRetxTmr = 500;
 156             break;
 157          case T_PollRetransmit_ms800:
 158             pollRetxTmr = 800;
 159             break;
 160          default:
 161             DU_LOG("\nERROR  -->  F1AP: Invalid value of Poll Retransmit timer");
 162             pollRetxTmr = 0;
 163       }
 164    }
 165    return pollRetxTmr;
 166 }
 167
 168 /*******************************************************************
 169  *
 170  * @brief Converts enum values into actual value of PollPdu
 171  *
 172  * @details
 173  *
 174  *    Function : getPollPdu
 175  *
 176  *    Functionality: Converts enum values into actual value of PollPdu
 177  *
 178  * @params[in] Enum value of pollPdu
 179  * @return Actual value of pollPdu
 180  *
 181  * ****************************************************************/
 182 int32_t getPollPdu(uint8_t pollPduCfg)
 183 {
 184    int32_t pollPdu;
 185    switch(pollPduCfg)
 186    {
 187       case PollPDU_p4:
 188          pollPdu = 4;
 189          break;
 190       case PollPDU_p8:
 191          pollPdu = 8;
 192          break;
 193       case PollPDU_p16:
 194          pollPdu = 16;
 195          break;
 196       case PollPDU_p32:
 197          pollPdu = 32;
 198          break;
 199       case PollPDU_p64:
 200          pollPdu = 64;
 201          break;
 202       case PollPDU_p128:
 203          pollPdu = 128;
 204          break;
 205       case PollPDU_p256:
 206          pollPdu = 256;
 207          break;
 208       case PollPDU_p512:
 209          pollPdu = 512;
 210          break;
 211       case PollPDU_p1024:
 212          pollPdu = 1024;
 213          break;
 214       case PollPDU_p2048:
 215          pollPdu = 2048;
 216          break;
 217       case PollPDU_p4096:
 218          pollPdu = 4096;
 219          break;
 220       case PollPDU_p6144:
 221          pollPdu = 6144;
 222          break;
 223       case PollPDU_p8192:
 224          pollPdu = 8192;
 225          break;
 226       case PollPDU_p12288:
 227          pollPdu = 12288;
 228          break;
 229       case PollPDU_p16384:
 230          pollPdu = 16384;
 231          break;
 232       case PollPDU_p20480:
 233          pollPdu = 20480;
 234          break;
 235       case PollPDU_p24576:
 236          pollPdu = 24576;
 237          break;
 238       case PollPDU_p28672:
 239          pollPdu = 28672;
 240          break;
 241       case PollPDU_p32768:
 242          pollPdu = 32768;
 243          break;
 244       case PollPDU_p40960:
 245          pollPdu = 40960;
 246          break;
 247       case PollPDU_p49152:
 248          pollPdu = 49152;
 249          break;
 250       case PollPDU_p57344:
 251          pollPdu = 57344;
 252          break;
 253       case PollPDU_p65536:
 254          pollPdu = 65536;
 255          break;
 256       case PollPDU_infinity:
 257          pollPdu = -1;
 258          break;
 259       default:
 260          DU_LOG("\nERROR  -->  F1AP: Invalid value of poll pdu");
 261          pollPdu = 0;
 262          break;
 263    }
 264    return pollPdu;
 265 }
 266
 267 /*******************************************************************
 268  *
 269  * @brief Converts enum values into actual value of poll bytes
 270  *
 271  * @details
 272  *
 273  *    Function : getPollByte
 274  *
 275  *    Functionality: Converts enum values into actual value of pollBytes
 276  *
 277  * @params[in] Enum value
 278  * @return Actual value
 279  *
 280  * ****************************************************************/
 281 int32_t getPollByte(uint16_t pollBytesCfg)
 282 {
 283    int32_t pollBytes;
 284    switch(pollBytesCfg)
 285    {
 286       case PollByte_kB1:
 287          pollBytes = 1000;
 288          break;
 289       case PollByte_kB2:
 290          pollBytes = 2000;
 291          break;
 292       case PollByte_kB5:
 293          pollBytes = 5000;
 294          break;
 295       case PollByte_kB8:
 296          pollBytes = 8000;
 297          break;
 298       case PollByte_kB10:
 299          pollBytes = 10000;
 300          break;
 301       case PollByte_kB15:
 302          pollBytes = 15000;
 303          break;
 304       case PollByte_kB25:
 305          pollBytes = 25000;
 306          break;
 307       case PollByte_kB50:
 308          pollBytes = 50000;
 309          break;
 310       case PollByte_kB75:
 311          pollBytes = 75000;
 312          break;
 313       case PollByte_kB100:
 314          pollBytes = 100000;
 315          break;
 316       case PollByte_kB125:
 317          pollBytes = 125000;
 318          break;
 319       case PollByte_kB250:
 320          pollBytes = 250000;
 321          break;
 322       case PollByte_kB375:
 323          pollBytes = 375000;
 324          break;
 325       case PollByte_kB500:
 326          pollBytes = 500000;
 327          break;
 328       case PollByte_kB750:
 329          pollBytes = 750000;
 330          break;
 331       case PollByte_kB1000:
 332          pollBytes = 1000000;
 333          break;
 334       case PollByte_kB1250:
 335          pollBytes = 1250000;
 336          break;
 337       case PollByte_kB1500:
 338          pollBytes = 1500000;
 339          break;
 340       case PollByte_kB2000:
 341          pollBytes = 2000000;
 342          break;
 343       case PollByte_kB3000:
 344          pollBytes = 3000000;
 345          break;
 346       case PollByte_kB4000:
 347          pollBytes = 4000000;
 348          break;
 349       case PollByte_kB4500:
 350          pollBytes = 4500000;
 351          break;
 352       case PollByte_kB5000:
 353          pollBytes = 5000000;
 354          break;
 355       case PollByte_kB5500:
 356          pollBytes = 5500000;
 357          break;
 358       case PollByte_kB6000:
 359          pollBytes = 6000000;
 360          break;
 361       case PollByte_kB6500:
 362          pollBytes = 6500000;
 363          break;
 364       case PollByte_kB7000:
 365          pollBytes = 7000000;
 366          break;
 367       case PollByte_kB7500:
 368          pollBytes = 7500000;
 369          break;
 370       case PollByte_mB8:
 371          pollBytes = 8000000;
 372          break;
 373       case PollByte_mB9:
 374          pollBytes = 9000000;
 375          break;
 376       case PollByte_mB10:
 377          pollBytes = 10000000;
 378          break;
 379       case PollByte_mB11:
 380          pollBytes = 11000000;
 381          break;
 382       case PollByte_mB12:
 383          pollBytes = 12000000;
 384          break;
 385       case PollByte_mB13:
 386          pollBytes = 13000000;
 387          break;
 388       case PollByte_mB14:
 389          pollBytes = 14000000;
 390          break;
 391       case PollByte_mB15:
 392          pollBytes = 15000000;
 393          break;
 394       case PollByte_mB16:
 395          pollBytes = 16000000;
 396          break;
 397       case PollByte_mB17:
 398          pollBytes = 17000000;
 399          break;
 400       case PollByte_mB18:
 401          pollBytes = 18000000;
 402          break;
 403       case PollByte_mB20:
 404          pollBytes = 20000000;
 405          break;
 406       case PollByte_mB25:
 407          pollBytes = 25000000;
 408          break;
 409       case PollByte_mB30:
 410          pollBytes = 30000000;
 411          break;
 412       case PollByte_mB40:
 413          pollBytes = 40000000;
 414          break;
 415       case PollByte_infinity:
 416          pollBytes = -1;
 417          break;
 418       default:
 419          DU_LOG("\nERROR  -->  F1AP: Invalid value of poll bytes");
 420          pollBytes = 0;
 421    }
 422    return pollBytes;
 423 }
 424
 425 /*******************************************************************
 426  *
 427  * @brief Converts enum values into actual value of maxRetx
 428  *
 429  * @details
 430  *
 431  *    Function : getMaxRetx
 432  *
 433  *    Functionality: Converts enum values into actual value of maxRetx
 434  *
 435  * @params[in] Enum value
 436  * @return Actual value
 437  *
 438  * ****************************************************************/
 439 uint8_t getMaxRetx(uint8_t maxRetxCfg)
 440 {
 441    uint8_t maxRetx;
 442    switch(maxRetxCfg)
 443    {
 444       case UL_AM_RLC__maxRetxThreshold_t1:
 445          maxRetx = 1;
 446          break;
 447       case UL_AM_RLC__maxRetxThreshold_t2:
 448          maxRetx = 2;
 449          break;
 450       case UL_AM_RLC__maxRetxThreshold_t3:
 451          maxRetx = 3;
 452          break;
 453       case UL_AM_RLC__maxRetxThreshold_t4:
 454          maxRetx = 4;
 455          break;
 456       case UL_AM_RLC__maxRetxThreshold_t6:
 457          maxRetx = 6;
 458          break;
 459       case UL_AM_RLC__maxRetxThreshold_t8:
 460          maxRetx = 8;
 461          break;
 462       case UL_AM_RLC__maxRetxThreshold_t16:
 463          maxRetx = 16;
 464          break;
 465       case UL_AM_RLC__maxRetxThreshold_t32:
 466          maxRetx = 32;
 467          break;
 468       default:
 469          DU_LOG("\nERROR  -->  F1AP: Invalid configuration for Max retransmission threshold");
 470          maxRetx = 0;
 471    }
 472    return maxRetx;
 473 }
 474
 475 /*******************************************************************
 476  * @brief Converts enum values into actual value of reassembly timer
 477  *
 478  * @details
 479  *
 480  *    Function : getReAsmblTmr
 481  *
 482  *    Functionality: Converts enum values into actual value of reassembly
 483  *    timer
 484  *
 485  * @params[in] Enum value of reassembly timer
 486  * @return Actual value of reassembly timer
 487  *
 488  * **********************************************************************/
 489
 490 int8_t getReAsmblTmr(uint8_t reAsmblTmrCfg)
 491 {
 492    int8_t reAsmblTmr = 0;
 493
 494    if(reAsmblTmrCfg == T_Reassembly_ms0)
 495    {
 496       reAsmblTmr = 0;
 497    }
 498    else if(reAsmblTmrCfg >= T_Reassembly_ms5 || reAsmblTmrCfg <= T_Reassembly_ms100)
 499    {
 500      /* All values of re assembly timer are at interval of 5ms.
 501       * This is valid upto 100ms
 502       * Hence converting the enum value to actual value by multiplying it to 5
 503       */
 504       reAsmblTmr = reAsmblTmrCfg * 5;
 505    }
 506    else if(reAsmblTmrCfg >= T_Reassembly_ms110 || reAsmblTmrCfg <= T_Reassembly_ms200)
 507    {
 508      /* All values of re assembly timer are at interval of 10ms.
 509       * This is valid upto 200ms
 510       * since enum value starts from 20 for 100ms, subtracting 10 and
 511       * converting the enum value to actual value by multiplying it to 10
 512       */
 513       reAsmblTmr = ((reAsmblTmrCfg-10) * 10);
 514    }
 515    else
 516    {
 517       DU_LOG("\nERROR  -->  F1AP : Invalid value of Re Assembly timer %d", reAsmblTmrCfg);
 518       reAsmblTmr = -1;
 519    }
 520    return reAsmblTmr;
 521 }
 522
 523 /************************************************************************
 524  *
 525  * @brief Converts enum values into actual value of status prohibit timer
 526  *
 527  * @details
 528  *
 529  *    Function : getStatProhTmr
 530  *
 531  *    Functionality: Converts enum values into actual value of status prohibit
 532  *    timer
 533  *
 534  * @params[in] Enum value of status prohibit timer
 535  * @return Actual value of status prohibit timer
 536  *
 537  * **********************************************************************/
 538
 539 int16_t getStatProhTmr(uint8_t statProhTmrCfg)
 540 {
 541    int16_t statProhTmr =0;
 542
 543    if(statProhTmrCfg == T_StatusProhibit_ms0)
 544    {
 545       statProhTmr = 0;
 546    }
 547    else if(statProhTmrCfg >= T_StatusProhibit_ms5 || statProhTmrCfg <= T_StatusProhibit_ms250)
 548    {
 549       /* All values of re assembly timer are at interval of 5ms.
 550        * This is valid upto 250ms
 551        * Hence converting the enum value to actual value by multiplying it to 5
 552        */
 553       statProhTmr = statProhTmrCfg * 5;
 554    }
 555    else
 556    {
 557       switch(statProhTmrCfg)
 558       {
 559          case T_StatusProhibit_ms300:
 560             statProhTmr = 300;
 561             break;
 562          case T_StatusProhibit_ms350:
 563             statProhTmr = 350;
 564             break;
 565          case T_StatusProhibit_ms400:
 566             statProhTmr = 400;
 567             break;
 568          case T_StatusProhibit_ms450:
 569             statProhTmr = 450;
 570             break;
 571          case T_StatusProhibit_ms500:
 572             statProhTmr = 500;
 573             break;
 574          case T_StatusProhibit_ms800:
 575             statProhTmr = 800;
 576             break;
 577          case T_StatusProhibit_ms1000:
 578             statProhTmr = 1000;
 579             break;
 580          case T_StatusProhibit_ms1200:
 581             statProhTmr = 1200;
 582             break;
 583          case T_StatusProhibit_ms1600:
 584             statProhTmr = 1600;
 585             break;
 586          case T_StatusProhibit_ms2000:
 587             statProhTmr = 2000;
 588             break;
 589          case T_StatusProhibit_ms2400:
 590             statProhTmr = 2400;
 591             break;
 592          default:
 593             DU_LOG("\nInvalid value of Status Prohibit timer %d", statProhTmrCfg);
 594             statProhTmr = -1;
 595             break;
 596       }
 597    }
 598    return statProhTmr;
 599 }
 600
 601 /*******************************************************************
 602 *
 603 * @brief Adding F1AP pdu to reserved pdu list
 604 *
 605 * @details
 606 *
 607 *    Function : addToReservedF1apPduList
 608 *
 609 *    Functionality: Adding F1AP pdu to reserved pdu list.
 610 *     These pdu are awaiting aknowledgment from CU
 611 *
 612 * @params[in] uint8_t transId, F1AP_PDU_t *f1apMsg
 613 *
 614 * @return ROK - success
 615 *         RFAILED - failure
 616 *
 617 * ****************************************************************/
 618
 619 void addToReservedF1apPduList(uint8_t transId, F1AP_PDU_t *f1apPdu)
 620 {
 621    CmLList         *node = NULLP;
 622    ReservedF1apPduInfo *pduInfo = NULLP;
 623    DU_ALLOC(pduInfo, sizeof(ReservedF1apPduInfo));
 624    if(pduInfo)
 625    {
 626       DU_ALLOC(node, sizeof(CmLList));
 627       if(node)
 628       {
 629          pduInfo->transId = transId;
 630          pduInfo->f1apMsg = (void*) f1apPdu;
 631
 632          node->node = (PTR)pduInfo;
 633          cmLListAdd2Tail(&duCb.reservedF1apPduList, node);
 634       }
 635    }
 636 }
 637
 638 /*******************************************************************
 639 *
 640 * @brief searching for F1AP pdu from ReservedF1apPduList
 641 *
 642 * @details
 643 *
 644 *    Function : searchFromReservedF1apPduList
 645 *
 646 *    Functionality: searching for F1AP pdu information
 647 *
 648 * @params[in] uint8_t transId
 649 *
 650 * @return pointer to F1AP_PDU_t
 651 *
 652 * ****************************************************************/
 653
 654 CmLList *searchFromReservedF1apPduList(uint8_t transId)
 655 {
 656    CmLList         *node;
 657    ReservedF1apPduInfo *f1apPdu;
 658    if(duCb.reservedF1apPduList.count)
 659    {
 660       CM_LLIST_FIRST_NODE(&duCb.reservedF1apPduList, node);
 661       while(node)
 662       {
 663          f1apPdu = (ReservedF1apPduInfo*)node->node;
 664          if(f1apPdu->transId == transId)
 665          {
 666             return node;
 667          }
 668          node = node->next;
 669       }
 670    }
 671    return NULL;
 672 }
 673
 674 /*******************************************************************
 675 *
 676 * @brief deleting F1AP pdu information from ReservedF1apPduList
 677 *
 678 * @details
 679 *
 680 *    Function : deleteFromReservedF1apPduList
 681 *
 682 *    Functionality: deleting pdu information from ReservedF1apPduList
 683 *
 684 * @params[in] CmLList *node
 685 *
 686 * @return void
 687 *
 688 * ****************************************************************/
 689
 690 void deleteFromReservedF1apPduList(CmLList *node)
 691 {
 692    ReservedF1apPduInfo *f1apPdu;
 693
 694    if(node != NULL)
 695    {
 696       f1apPdu = (ReservedF1apPduInfo *)node->node;
 697       cmLListDelFrm(&duCb.reservedF1apPduList, node);
 698       DU_FREE(f1apPdu, sizeof(ReservedF1apPduInfo));
 699       DU_FREE(node, sizeof(CmLList));
 700       node = NULL;
 701    }
 702 }
 703
 704 /*******************************************************************
 705  *
 706  * @brief Builds Uplink Info for NR
 707  *
 708  * @details
 709  *
 710  *    Function : BuildULNRInfo
 711  *
 712  *    Functionality: Building NR Uplink Info
 713  *
 714  * @params[in] NRFreqInfo_t *ulnrfreq
 715  * @return ROK     - success
 716  *         RFAILED - failure
 717  *
 718  * ****************************************************************/
 719 uint8_t BuildULNRInfo(NRFreqInfo_t *ulnrfreq)
 720 {
 721    uint8_t idx=0;
 722    ulnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 723                        fdd.ulNrFreqInfo.nrArfcn;
 724    ulnrfreq->freqBandListNr.list.count = 1;
 725    ulnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 726    DU_ALLOC(ulnrfreq->freqBandListNr.list.array,ulnrfreq->freqBandListNr.list.size);
 727    if(ulnrfreq->freqBandListNr.list.array == NULLP)
 728    {
 729       return RFAILED;
 730    }
 731    for(idx=0;idx<ulnrfreq->freqBandListNr.list.count;idx++)
 732    {
 733       DU_ALLOC(ulnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 734       if(ulnrfreq->freqBandListNr.list.array[idx] == NULLP)
 735       {
 736          return RFAILED;
 737       }
 738    }
 739    ulnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 740                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
 741                                                                  freqBand[0].nrFreqBand;
 742    ulnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 743    return ROK;
 744 }
 745 /*******************************************************************
 746  *
 747  * @brief Builds Downlink NR Info
 748  *
 749  * @details
 750  *
 751  *    Function : BuildDLNRInfo
 752  *
 753  *    Functionality: Building Downlink NR Info
 754  *
 755  * @params[in] NRFreqInfo_t *dlnrfreq
 756  * @return ROK     - success
 757  *         RFAILED - failure
 758  *
 759  * ****************************************************************/
 760 uint8_t BuildDLNRInfo(NRFreqInfo_t *dlnrfreq)
 761 {
 762    uint8_t idx=0;
 763    dlnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 764                        fdd.dlNrFreqInfo.nrArfcn;
 765    dlnrfreq->freqBandListNr.list.count = 1;
 766    dlnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 767    DU_ALLOC(dlnrfreq->freqBandListNr.list.array,dlnrfreq->freqBandListNr.list.size);
 768    if(dlnrfreq->freqBandListNr.list.array == NULLP)
 769    {
 770       return RFAILED;
 771    }
 772    for(idx=0;idx< dlnrfreq->freqBandListNr.list.count;idx++)
 773    {
 774       DU_ALLOC(dlnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 775       if(dlnrfreq->freqBandListNr.list.array[idx] == NULLP)
 776       {
 777          return RFAILED;
 778       }
 779    }
 780    dlnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 781                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
 782                                                                  freqBand[0].nrFreqBand;
 783    dlnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 784
 785    return ROK;
 786 }
 787
 788 /*******************************************************************
 789  *
 790  * @brief Builds NRCell ID
 791  *
 792  * @details
 793  *
 794  *    Function : BuildNrCellId
 795  *
 796  *    Functionality: Building the NR Cell ID
 797  *
 798  * @params[in] BIT_STRING_t *nrcell
 799  * @return ROK     - success
 800  *         RFAILED - failure
 801  *
 802  * ****************************************************************/
 803
 804 S16 BuildNrCellId(BIT_STRING_t *nrcell)
 805 {
 806    memset(nrcell->buf, 0, nrcell->size);
 807    nrcell->buf[4]   = 16;
 808    nrcell->bits_unused = 4;
 809    return ROK;
 810 }
 811
 812 /*******************************************************************
 813  *
 814  * @brief Builds Nrcgi
 815  *
 816  * @details
 817  *
 818  *    Function : BuildNrcgi
 819  *
 820  *    Functionality: Building the PLMN ID and NR Cell id
 821  *
 822  * @params[in] NRCGI_t *nrcgi
 823  * @return ROK     - success
 824  *         RFAILED - failure
 825  *
 826  * ****************************************************************/
 827 uint8_t BuildNrcgi(NRCGI_t *nrcgi)
 828 {
 829    uint8_t ret;
 830    uint8_t byteSize = 5;
 831    /* Allocate Buffer Memory */
 832    nrcgi->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 833    DU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
 834    if(nrcgi->pLMN_Identity.buf == NULLP)
 835    {
 836       return RFAILED;
 837    }
 838    ret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 839          nrcgi->pLMN_Identity.buf); // Building PLMN function
 840    if(ret != ROK)
 841    {
 842       return RFAILED;
 843    }
 844    /*nrCellIdentity*/
 845    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
 846    DU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
 847    if(nrcgi->nRCellIdentity.buf == NULLP)
 848    {
 849       return RFAILED;
 850    }
 851    BuildNrCellId(&nrcgi->nRCellIdentity);
 852
 853    return ROK;
 854 }
 855 /*******************************************************************
 856  *
 857  * @brief Builds FiveGStac
 858  *
 859  * @details
 860  *
 861  *    Function : BuildFiveGSTac
 862  *
 863  *    Functionality: Building the FiveGSTac
 864  *
 865  * @params[in] OCTET_STRING_t *fivegsTac
 866  * @return ROK     - success
 867  *         RFAILED - failure
 868  *
 869  * ****************************************************************/
 870 uint8_t BuildFiveGSTac(Served_Cell_Information_t *servcell)
 871 {
 872    DU_ALLOC(servcell->fiveGS_TAC,sizeof(FiveGS_TAC_t));
 873    if(servcell->fiveGS_TAC == NULLP)
 874    {
 875       return RFAILED;
 876    }
 877    servcell->fiveGS_TAC->size = 3 * sizeof(uint8_t);
 878    DU_ALLOC(servcell->fiveGS_TAC->buf,\
 879          sizeof(servcell->fiveGS_TAC->size));
 880    if(servcell->fiveGS_TAC->buf == NULLP)
 881    {
 882       return RFAILED;
 883    }
 884    servcell->fiveGS_TAC->buf[0] = 0;
 885    servcell->fiveGS_TAC->buf[1] = 0;
 886    servcell->fiveGS_TAC->buf[2] = duCfgParam.srvdCellLst[0].duCellInfo.tac;
 887    return ROK;
 888 }
 889 /*******************************************************************
 890  *
 891  * @brief Builds NR Mode
 892  *
 893  * @details
 894  *
 895  *    Function : BuildNrMode
 896  *
 897  *    Functionality: Building the NR Mode
 898  *
 899  * @params[in] NR_Mode_Info_t *fdd
 900  * @return ROK     - success
 901  *         RFAILED - failure
 902  *
 903  * ****************************************************************/
 904 uint8_t BuildNrMode(NR_Mode_Info_t *mode)
 905 {
 906    uint8_t BuildDLNRInforet=0;
 907    uint8_t BuildULNRInforet=0;
 908    /* FDD Mode */
 909    mode->present = NR_Mode_Info_PR_fDD;
 910    if(mode->present == NR_Mode_Info_PR_fDD)
 911    {
 912       DU_ALLOC(mode->choice.fDD,sizeof(FDD_Info_t));
 913       if(mode->choice.fDD == NULLP)
 914       {
 915          return RFAILED;
 916       }
 917       BuildULNRInforet = BuildULNRInfo(&mode->choice.fDD->uL_NRFreqInfo);
 918       if(BuildULNRInforet != ROK)
 919       {
 920          return RFAILED;
 921       }
 922       BuildDLNRInforet = BuildDLNRInfo(&mode->choice.fDD->dL_NRFreqInfo);
 923       if(BuildDLNRInforet != ROK)
 924       {
 925          return RFAILED;
 926       }
 927    }
 928    mode->choice.fDD->uL_Transmission_Bandwidth.nRSCS = \
 929                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 930                                                        f1Mode.mode.fdd.ulTxBw.nrScs;
 931    mode->choice.fDD->uL_Transmission_Bandwidth.nRNRB = \
 932                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 933                                                        f1Mode.mode.fdd.ulTxBw.nrb;
 934    mode->choice.fDD->dL_Transmission_Bandwidth.nRSCS = \
 935                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 936                                                        f1Mode.mode.fdd.dlTxBw.nrScs;
 937    mode->choice.fDD->dL_Transmission_Bandwidth.nRNRB = \
 938                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 939                                                        f1Mode.mode.fdd.dlTxBw.nrb;
 940    return ROK;
 941 }
 942 /*******************************************************************
 943  *
 944  * @brief Builds IE Extensions for Served PLMNs
 945  *
 946  * @details
 947  *
 948  *    Function : BuildExtensions
 949  *
 950  *    Functionality: Building the IE Extensions
 951  *
 952  * @params[in] struct ProtocolExtensionContainer_4624P3 *buildextend
 953  * @return ROK     - success
 954  *         RFAILED - failure
 955  *
 956  * ****************************************************************/
 957 uint8_t BuildExtensions(ProtocolExtensionContainer_4624P3_t **ieExtend)
 958 {
 959    uint8_t idx;
 960    uint8_t plmnidx;
 961    uint8_t extensionCnt=1;
 962    uint8_t sliceId=0;
 963    uint8_t sdId;
 964    DU_ALLOC(*ieExtend,sizeof(ProtocolExtensionContainer_4624P3_t));
 965    if((*ieExtend) == NULLP)
 966    {
 967       return RFAILED;
 968    }
 969    (*ieExtend)->list.count = extensionCnt;
 970    (*ieExtend)->list.size = \
 971                             extensionCnt * sizeof(ServedPLMNs_ItemExtIEs_t *);
 972    DU_ALLOC((*ieExtend)->list.array,(*ieExtend)->list.size);
 973    if((*ieExtend)->list.array == NULLP)
 974    {
 975       return RFAILED;
 976    }
 977    for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
 978    {
 979       DU_ALLOC((*ieExtend)->list.array[plmnidx],\
 980             sizeof(ServedPLMNs_ItemExtIEs_t));
 981       if((*ieExtend)->list.array[plmnidx] == NULLP)
 982       {
 983          return RFAILED;
 984       }
 985    }
 986    idx = 0;
 987    (*ieExtend)->list.array[idx]->id = ProtocolIE_ID_id_TAISliceSupportList;
 988    (*ieExtend)->list.array[idx]->criticality = Criticality_ignore;
 989    (*ieExtend)->list.array[idx]->extensionValue.present = \
 990                                                           ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
 991    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 992       list.count = 1;
 993    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 994       list.size = sizeof(SliceSupportItem_t *);
 995    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 996          list.array,sizeof(SliceSupportItem_t *));
 997    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 998          list.array == NULLP)
 999    {
1000       return RFAILED;
1001    }
1002    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1003          list.array[sliceId],sizeof(SliceSupportItem_t));
1004    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1005          list.array[sliceId] == NULLP)
1006    {
1007       return RFAILED;
1008    }
1009    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1010       list.array[sliceId]->sNSSAI.sST.size = sizeof(uint8_t);
1011    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
1012          .list.array[sliceId]->sNSSAI.sST.buf,(*ieExtend)->list.array[idx]->\
1013          extensionValue.choice.SliceSupportList.\
1014          list.array[sliceId]->sNSSAI.sST.size);
1015    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
1016          .list.array[sliceId]->sNSSAI.sST.buf == NULLP)
1017    {
1018       return RFAILED;
1019    }
1020    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1021       list.array[sliceId]->sNSSAI.sST.buf[0] = 3;
1022    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1023          list.array[sliceId]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1024    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1025          list.array[sliceId]->sNSSAI.sD == NULLP)
1026    {
1027       return RFAILED;
1028    }
1029    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1030       list.array[sliceId]->sNSSAI.sD->size = 3*sizeof(uint8_t);
1031    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1032          list.array[sliceId]->sNSSAI.sD->buf,(*ieExtend)->list.array[idx]->extensionValue.choice.\
1033          SliceSupportList.list.array[sliceId]->sNSSAI.sD->size);
1034    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1035          list.array[sliceId]->sNSSAI.sD->buf == NULLP)
1036    {
1037       return RFAILED;
1038    }
1039    sdId = 0;
1040    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1041       list.array[sliceId]->sNSSAI.sD->buf[sdId] = 3;
1042    sdId++;
1043    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1044       list.array[sliceId]->sNSSAI.sD->buf[sdId] = 6;
1045    sdId++;
1046    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1047       list.array[sliceId]->sNSSAI.sD->buf[sdId] = 9;
1048    return ROK;
1049 }
1050 /*******************************************************************
1051  *
1052  * @brief Builds Served PLMN
1053  *
1054  * @details
1055  *
1056  *    Function : BuildServedPlmn
1057  *
1058  *    Functionality: Building the Served PLMN
1059  *
1060  * @params[in] GNB_DU_Served_Cells_Item_t *srvCellItem
1061  * @return ROK     - success
1062  *         RFAILED - failure
1063  *
1064  * ****************************************************************/
1065 uint8_t  BuildServedPlmn(ServedPLMNs_List_t *srvplmn)
1066 {
1067    uint8_t  plmnidx;
1068    uint8_t  servPlmnCnt=1;
1069    uint8_t buildPlmnIdret=0;
1070    uint8_t BuildExtensionsret=0;
1071    srvplmn->list.count = servPlmnCnt;
1072    srvplmn->list.size = \
1073                         servPlmnCnt*sizeof(ServedPLMNs_Item_t *);
1074    DU_ALLOC(srvplmn->list.array,srvplmn->list.size);
1075    if(srvplmn->list.array == NULLP)
1076    {
1077       return RFAILED;
1078    }
1079    for(plmnidx=0; plmnidx<servPlmnCnt; plmnidx++)
1080    {
1081       DU_ALLOC(srvplmn->list.array[plmnidx],\
1082             sizeof(ServedPLMNs_Item_t));
1083       if(srvplmn->list.array[plmnidx] == NULLP)
1084       {
1085          return RFAILED;
1086       }
1087    }
1088    srvplmn->list.array[0]->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
1089    DU_ALLOC(srvplmn->list.array[0]->pLMN_Identity.buf, srvplmn->list.array[0]->pLMN_Identity.size);
1090    buildPlmnIdret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
1091          srvplmn->list.array[0]->pLMN_Identity.buf);
1092    if(buildPlmnIdret!= ROK)
1093    {
1094       return RFAILED;
1095    }
1096    BuildExtensionsret = BuildExtensions(&srvplmn->list.array[0]->iE_Extensions);
1097    if(BuildExtensionsret!= ROK)
1098    {
1099       return RFAILED;
1100    }
1101    return ROK;
1102 }
1103 /*******************************************************************
1104  *
1105  * @brief Builds Served Cell List
1106  *
1107  * @details
1108  *
1109  *    Function : BuildServedCellList
1110  *
1111  *    Functionality: Building Served Cell List
1112  *
1113  * @params[in] PLMNID plmn
1114  * @return ROK     - success
1115  *         RFAILED - failure
1116  *
1117  * ****************************************************************/
1118
1119 uint8_t BuildServedCellList(GNB_DU_Served_Cells_List_t *duServedCell)
1120 {
1121    uint8_t  BuildNrcgiret=0;
1122    uint8_t  BuildFiveGSTacret=0;
1123    uint8_t  BuildServedPlmnret=0;
1124    uint8_t  BuildNrModeret=0;
1125    uint8_t  idx;
1126    uint8_t  plmnidx;
1127    uint8_t  plmnCnt=1;
1128    GNB_DU_Served_Cells_Item_t *srvCellItem;
1129    duServedCell->list.size = plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t *);
1130    duServedCell->list.count = plmnCnt;
1131
1132    DU_ALLOC(duServedCell->list.array, duServedCell->list.size);
1133    if(duServedCell->list.array == NULLP)
1134    {
1135       return RFAILED;
1136    }
1137    for(plmnidx=0; plmnidx<plmnCnt; plmnidx++)
1138    {
1139       DU_ALLOC(duServedCell->list.array[plmnidx],\
1140             sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1141       if(duServedCell->list.array[plmnidx] == NULLP)
1142       {
1143          return RFAILED;
1144       }
1145    }
1146    idx = 0;
1147    duServedCell->list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_Served_Cells_Item;
1148    duServedCell->list.array[idx]->criticality = Criticality_reject;
1149    duServedCell->list.array[idx]->value.present = \
1150                                                   GNB_DU_Served_Cells_ItemIEs__value_PR_GNB_DU_Served_Cells_Item;
1151    srvCellItem = \
1152                  &duServedCell->list.array[idx]->value.choice.GNB_DU_Served_Cells_Item;
1153    /*nRCGI*/
1154    BuildNrcgiret = BuildNrcgi(&srvCellItem->served_Cell_Information.nRCGI);
1155    if(BuildNrcgiret != ROK)
1156    {
1157       return RFAILED;
1158    }
1159    /*nRPCI*/
1160    srvCellItem->served_Cell_Information.nRPCI = \
1161                                                 duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
1162
1163    /*fiveGS_TAC*/
1164    BuildFiveGSTacret = BuildFiveGSTac(&srvCellItem->served_Cell_Information);
1165    if(BuildFiveGSTacret != ROK)
1166    {
1167       return RFAILED;
1168    }
1169    /*Served PLMNs*/
1170    BuildServedPlmnret = BuildServedPlmn(&srvCellItem->served_Cell_Information.servedPLMNs);
1171    if(BuildServedPlmnret !=ROK)
1172    {
1173       return RFAILED;
1174    }
1175    /*nR Mode Info with FDD*/
1176    BuildNrModeret = BuildNrMode(&srvCellItem->served_Cell_Information.nR_Mode_Info);
1177    if(BuildNrModeret != ROK)
1178    {
1179       return RFAILED;
1180    }
1181    /*Measurement timing Config*/
1182    srvCellItem->served_Cell_Information.measurementTimingConfiguration.\
1183       size = sizeof(uint8_t);
1184    DU_ALLOC(srvCellItem->served_Cell_Information.\
1185          measurementTimingConfiguration.buf,srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1186    if(srvCellItem->served_Cell_Information.\
1187          measurementTimingConfiguration.buf == NULLP)
1188    {
1189       return RFAILED;
1190    }
1191    srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf[0] = \
1192                                                                                 duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
1193
1194    /* GNB DU System Information */
1195    DU_ALLOC(srvCellItem->gNB_DU_System_Information,
1196          sizeof(GNB_DU_System_Information_t));
1197    if(!srvCellItem->gNB_DU_System_Information)
1198    {
1199       return RFAILED;
1200    }
1201    /* MIB */
1202    srvCellItem->gNB_DU_System_Information->mIB_message.size = duCfgParam.srvdCellLst[0].duSysInfo.mibLen;
1203    DU_ALLOC(srvCellItem->gNB_DU_System_Information->mIB_message.buf,
1204          srvCellItem->gNB_DU_System_Information->mIB_message.size);
1205    if(!srvCellItem->gNB_DU_System_Information->mIB_message.buf)
1206    {
1207       return RFAILED;
1208    }
1209    memcpy(srvCellItem->gNB_DU_System_Information->mIB_message.buf, duCfgParam.srvdCellLst[0].duSysInfo.mibMsg, \
1210                    srvCellItem->gNB_DU_System_Information->mIB_message.size);
1211
1212    /* SIB1 */
1213    srvCellItem->gNB_DU_System_Information->sIB1_message.size =\
1214                                                               duCfgParam.srvdCellLst[0].duSysInfo.sib1Len;
1215
1216    DU_ALLOC(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,
1217          srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1218    if(!srvCellItem->gNB_DU_System_Information->sIB1_message.buf)
1219    {
1220       return RFAILED;
1221    }
1222    for(int x=0; x<srvCellItem->gNB_DU_System_Information->sIB1_message.size; x++)
1223    {
1224       srvCellItem->gNB_DU_System_Information->sIB1_message.buf[x]=\
1225                                                                   duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg[x];
1226    }
1227    return ROK;
1228 }
1229 /*******************************************************************
1230  *
1231  * @brief Builds RRC Version
1232  *
1233  * @details
1234  *
1235  *    Function : BuildRrcVer
1236  *
1237  *    Functionality: Building RRC Version
1238  *
1239  * @params[in] int idx,int elementCnt,RRC_Version_t *rrcver
1240  * @return ROK     - success
1241  *         RFAILED - failure
1242  *
1243  * ****************************************************************/
1244 uint8_t BuildRrcVer(RRC_Version_t *rrcVer)
1245 {
1246    uint8_t rrcExt;
1247    uint8_t rrcLatest;
1248    rrcVer->latest_RRC_Version.size = sizeof(uint8_t);
1249    DU_ALLOC(rrcVer->latest_RRC_Version.buf,sizeof(uint8_t));
1250    if(rrcVer->latest_RRC_Version.buf == NULLP)
1251    {
1252       return RFAILED;
1253    }
1254    rrcVer->latest_RRC_Version.buf[0] = 0;
1255    rrcVer->latest_RRC_Version.bits_unused = 5;
1256    DU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1257    if(rrcVer->iE_Extensions == NULLP)
1258    {
1259       return RFAILED;
1260    }
1261    rrcVer->iE_Extensions->list.count = 1;
1262    rrcVer->iE_Extensions->list.size = sizeof(RRC_Version_ExtIEs_t *);
1263    DU_ALLOC(rrcVer->iE_Extensions->list.array,rrcVer->iE_Extensions->list.size);
1264    if(rrcVer->iE_Extensions->list.array == NULLP)
1265    {
1266       return RFAILED;
1267    }
1268    rrcExt = 0;
1269    DU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
1270          sizeof(RRC_Version_ExtIEs_t));
1271    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
1272    {
1273       return RFAILED;
1274    }
1275    rrcVer->iE_Extensions->list.array[rrcExt]->id = \
1276                                                    ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
1277    rrcVer->iE_Extensions->list.array[rrcExt]->criticality = Criticality_reject;
1278    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.present =\
1279                                                                       RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
1280    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1281       .Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
1282    DU_ALLOC(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1283          .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1284          array[rrcExt]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1285    if(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1286          .Latest_RRC_Version_Enhanced.buf == NULLP)
1287    {
1288       return RFAILED;
1289    }
1290    rrcLatest = 0;
1291    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1292       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 15;
1293    rrcLatest++;
1294    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1295       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 5;
1296    rrcLatest++;
1297    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1298       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 0;
1299    return ROK;
1300 }
1301 /*******************************************************************
1302  *
1303  * @brief Sends F1 msg over SCTP
1304  *
1305  * @details
1306  *
1307  *    Function : sendF1APMsg
1308  *
1309  *    Functionality: Sends F1 msg over SCTP
1310  *
1311  * @params[in] Region region
1312  *             Pool pool
1313  * @return ROK     - success
1314  *         RFAILED - failure
1315  *
1316  * ****************************************************************/
1317 uint8_t sendF1APMsg()
1318 {
1319    Buffer *mBuf = NULLP;
1320
1321    if(ODU_GET_MSG_BUF(DU_APP_MEM_REGION, DU_POOL, &mBuf) == ROK)
1322    {
1323       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
1324       {
1325             ODU_PRINT_MSG(mBuf, 0,0);
1326
1327             if(sctpSend(mBuf, F1_INTERFACE) != ROK)
1328             {
1329                DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
1330                ODU_PUT_MSG_BUF(mBuf);
1331                return RFAILED;
1332             }
1333       }
1334       else
1335       {
1336          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
1337          ODU_PUT_MSG_BUF(mBuf);
1338          return RFAILED;
1339       }
1340       ODU_PUT_MSG_BUF(mBuf);
1341    }
1342    else
1343    {
1344       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
1345       return RFAILED;
1346    }
1347    return ROK;
1348 } /* sendF1APMsg */
1349
1350 /*******************************************************************
1351  *
1352  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1353  *
1354  * @details
1355  *
1356  *    Function :  FreeRrcVer
1357  *
1358  *    Functionality: deallocating the memory of function BuildRrcVer
1359  *
1360  * @params[in] RRC_Version_t *rrcVer
1361  *
1362  * @return void
1363  *
1364  *****************************************************************/
1365 void FreeRrcVer(RRC_Version_t *rrcVer)
1366 {
1367    if(rrcVer->latest_RRC_Version.buf != NULLP)
1368    {
1369       if(rrcVer->iE_Extensions != NULLP)
1370       {
1371          if(rrcVer->iE_Extensions->list.array != NULLP)
1372          {
1373             if(rrcVer->iE_Extensions->list.array[0] != NULLP)
1374             {
1375                if(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf
1376                      != NULLP)
1377                {
1378                   DU_FREE(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice\
1379                         .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1380                         array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1381                }
1382                DU_FREE(rrcVer->iE_Extensions->list.array[0],sizeof(RRC_Version_ExtIEs_t));
1383             }
1384             DU_FREE(rrcVer->iE_Extensions->list.array,sizeof(RRC_Version_ExtIEs_t*));
1385          }
1386          DU_FREE(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1387       }
1388       DU_FREE(rrcVer->latest_RRC_Version.buf,rrcVer->latest_RRC_Version.size);
1389    }
1390 }
1391 /*******************************************************************
1392  *
1393  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1394  *
1395  * @details
1396  *
1397  *    Function :  FreeServedCellList
1398  *
1399  *    Functionality:  deallocating the memory of function BuildServedCellList
1400
1401  *
1402  * @params[in] GNB_DU_Served_Cells_List_t *duServedCell
1403  *
1404  * @return void
1405  *
1406  * ****************************************************************/
1407 void FreeServedCellList( GNB_DU_Served_Cells_List_t *duServedCell)
1408 {
1409    uint8_t   plmnCnt=1;
1410    uint8_t  servId=0;
1411    uint8_t sliceId=0;
1412    uint8_t  ieId=0;
1413    uint8_t   extensionCnt=1;
1414    uint8_t plmnidx=0;
1415    GNB_DU_Served_Cells_Item_t *srvCellItem= &duServedCell->list.array[0]->value.choice.GNB_DU_Served_Cells_Item;
1416    if(duServedCell->list.array!=NULLP)
1417    {
1418       if(duServedCell->list.array[0]!=NULLP)
1419       {
1420          if(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf!=NULLP)
1421          {
1422             if(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf !=NULLP)
1423             {
1424                if(srvCellItem->served_Cell_Information.fiveGS_TAC!=NULLP)
1425                {
1426                   if(srvCellItem->served_Cell_Information.fiveGS_TAC->buf!=NULLP)
1427                   {
1428                      if(srvCellItem->served_Cell_Information.servedPLMNs.list.array!=NULLP)
1429                      {
1430                         if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[0]!=NULLP)
1431                         {
1432                            if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->pLMN_Identity.buf!=NULLP)
1433                            {
1434                               if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions!=NULLP)
1435                               {
1436                                  if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array!=NULLP)
1437                                  {
1438                                     if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]!=NULLP)
1439                                     {
1440                                        if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1441                                              extensionValue.choice.SliceSupportList.list.array!=NULLP)
1442                                        {
1443                                           if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1444                                                 extensionValue.choice.SliceSupportList.list.array[sliceId]!= NULLP)
1445                                           {
1446                                              if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1447                                                    extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sST.buf!=NULLP)
1448                                              {
1449                                                 if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1450                                                       extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sD!=NULLP)
1451                                                 {
1452                                                    if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->\
1453                                                          list.array[0]->extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sD->buf!=NULLP)
1454                                                    {
1455                                                       if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD!=NULLP)
1456                                                       {
1457                                                          if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
1458                                                                freqBandListNr.list.array!=NULLP)
1459                                                          {
1460                                                             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
1461                                                                   freqBandListNr.list.array[0]!=NULLP)
1462                                                             {
1463                                                                if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1464                                                                      freqBandListNr.list.array)
1465                                                                {
1466                                                                   if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1467                                                                         freqBandListNr.list.array[0]!=NULLP)
1468                                                                   {
1469                                                                      if(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf!=NULLP)
1470                                                                      {
1471                                                                         if(!srvCellItem->gNB_DU_System_Information)
1472                                                                         {
1473                                                                            if(srvCellItem->gNB_DU_System_Information->mIB_message.buf!=NULLP)
1474                                                                            {
1475                                                                               if(srvCellItem->gNB_DU_System_Information->sIB1_message.buf!=NULLP)
1476                                                                               {
1477                                                                                  DU_FREE(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,\
1478                                                                                        srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1479                                                                                  DU_FREE(duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg,\
1480                                                                                        srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1481                                                                               }
1482                                                                               DU_FREE(srvCellItem->gNB_DU_System_Information->mIB_message.buf,\
1483                                                                                     srvCellItem->gNB_DU_System_Information->mIB_message.size);
1484                                                                               DU_FREE(duCfgParam.srvdCellLst[0].duSysInfo.mibMsg,\
1485                                                                                     strlen((char*)duCfgParam.srvdCellLst[0].duSysInfo.mibMsg));
1486                                                                            }
1487                                                                            DU_FREE(srvCellItem->gNB_DU_System_Information,sizeof(GNB_DU_System_Information_t));
1488                                                                         }
1489                                                                         DU_FREE(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1490                                                                               srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1491                                                                      }
1492                                                                      DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1493                                                                            freqBandListNr.list.array[0],sizeof(FreqBandNrItem_t));
1494                                                                   }
1495                                                                   DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1496                                                                         freqBandListNr.list.array,sizeof(FreqBandNrItem_t *));
1497                                                                }
1498                                                                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.\
1499                                                                      list.array[0],sizeof(FreqBandNrItem_t));
1500                                                             }
1501                                                             DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.\
1502                                                                   list.array,sizeof(FreqBandNrItem_t*));
1503                                                          }
1504                                                          DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD,sizeof(FDD_Info_t));
1505                                                       }
1506                                                       DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
1507                                                             iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.list.array[sliceId]->\
1508                                                             sNSSAI.sD->buf,srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->
1509                                                             list.array[ieId]->extensionValue.choice.SliceSupportList.list.array[sliceId]->sNSSAI.sD->size);
1510                                                    }
1511                                                    DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
1512                                                          iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.\
1513                                                          list.array[sliceId]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1514                                                 }
1515                                                 DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->\
1516                                                       iE_Extensions->list.array[ieId]->extensionValue.choice.SliceSupportList.list.array[sliceId]->\
1517                                                       sNSSAI.sST.buf,sizeof(uint8_t));
1518                                              }
1519                                              DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1520                                                    extensionValue.choice.SliceSupportList.list.array[sliceId],sizeof(SliceSupportItem_t));
1521                                           }
1522                                           DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[servId]->iE_Extensions->list.array[0]->\
1523                                                 extensionValue.choice.SliceSupportList.list.array,sizeof(SliceSupportItem_t*));
1524                                        }
1525                                        DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
1526                                              array[servId]->iE_Extensions->list.array[plmnidx],sizeof(ServedPLMNs_ItemExtIEs_t));
1527                                     }
1528                                     DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
1529                                           array[servId]->iE_Extensions->list.array,\
1530                                           extensionCnt*sizeof(ServedPLMNs_ItemExtIEs_t*));
1531                                  }
1532                                  DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
1533                                        array[servId]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1534                               }
1535                               DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.\
1536                                     array[servId]->pLMN_Identity.buf,srvCellItem->served_Cell_Information.\
1537                                     servedPLMNs.list.array[servId]->pLMN_Identity.size
1538                                     * sizeof(uint8_t));
1539                            }
1540                            DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnidx],\
1541                                  sizeof(ServedPLMNs_Item_t *));
1542                         }
1543                         DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array,\
1544                               sizeof(ServedPLMNs_Item_t *));
1545                      }
1546                      DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
1547                            sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
1548                   }
1549                   DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,sizeof(FiveGS_TAC_t));
1550                }
1551                DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1552                      srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size *
1553                      sizeof(uint8_t));
1554             }
1555             DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1556                   srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size *
1557                   sizeof(uint8_t));
1558          }
1559          DU_FREE(duServedCell->list.array[plmnidx],sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1560       }
1561       DU_FREE(duServedCell->list.array,plmnCnt*sizeof(GNB_DU_Served_Cells_ItemIEs_t*));
1562    }
1563 }
1564 /*******************************************************************
1565  *
1566  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1567  *
1568  * @details
1569  *
1570  *    Function :  FreeF1SetupReq
1571  *
1572  *    Functionality:  deallocating the memory of function BuildAndSendF1SetupReq
1573  *
1574  * @params[in] F1AP_PDU_t *f1apMsg
1575  *
1576  * @return void
1577  *
1578  * ****************************************************************/
1579 void FreeF1SetupReq(F1AP_PDU_t *f1apMsg)
1580 {
1581    uint8_t ieIdx, ieIdx2;
1582    F1SetupRequest_t *f1SetupReq=NULLP;
1583
1584    if(f1apMsg != NULLP)
1585    {
1586       if(f1apMsg->choice.initiatingMessage != NULLP)
1587       {
1588          f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1589          if(f1SetupReq->protocolIEs.list.array != NULLP)
1590          {
1591             for(ieIdx = 0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
1592             {
1593                if(f1SetupReq->protocolIEs.list.array[ieIdx] != NULLP)
1594                {
1595                   switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
1596                   {
1597                      case ProtocolIE_ID_id_TransactionID:
1598                         break;
1599                      case ProtocolIE_ID_id_gNB_DU_ID:
1600                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1601                               f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1602                         break;
1603                      case ProtocolIE_ID_id_gNB_DU_Name:
1604                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,\
1605                               strlen((char *)duCfgParam.duName));
1606                         break;
1607                      case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
1608                         FreeServedCellList(&f1SetupReq->protocolIEs.list.\
1609                               array[ieIdx]->value.choice.GNB_DU_Served_Cells_List);
1610                         break;
1611                      case ProtocolIE_ID_id_GNB_DU_RRC_Version:
1612                         FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version);
1613                         break;
1614                      default:
1615                         DU_LOG("\nERROR  -->  Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id);
1616                         break;
1617                   }
1618                }
1619                break;
1620             }
1621             for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++)
1622             {
1623                DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx2],sizeof(F1SetupRequestIEs_t));
1624             }
1625             DU_FREE(f1SetupReq->protocolIEs.list.array,\
1626                   f1SetupReq->protocolIEs.list.size);
1627          }
1628          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1629       }
1630       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1631    }
1632 }
1633 /*******************************************************************
1634  *
1635  * @brief Builds and Send the F1SetupRequest
1636  *
1637  * @details
1638  *
1639  *    Function : BuildAndSendF1SetupReq
1640  *
1641  * Functionality:Fills the F1SetupRequest
1642  *
1643  * @return ROK     - success
1644  *         RFAILED - failure
1645  *
1646  ******************************************************************/
1647 uint8_t BuildAndSendF1SetupReq()
1648 {
1649    uint8_t   ret, ieIdx, elementCnt;
1650    F1AP_PDU_t                 *f1apMsg = NULLP;
1651    F1SetupRequest_t           *f1SetupReq=NULLP;
1652    GNB_DU_Served_Cells_List_t *duServedCell=NULLP;
1653    RRC_Version_t              *rrcVer=NULLP;
1654    asn_enc_rval_t             encRetVal;        /* Encoder return value */
1655    ret= RFAILED;
1656
1657    DU_LOG("\nINFO   -->  F1AP : Building F1 Setup Request\n");
1658    do
1659    {
1660       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1661       if(f1apMsg == NULLP)
1662       {
1663          break;
1664       }
1665       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1666       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1667       if(f1apMsg->choice.initiatingMessage == NULLP)
1668       {
1669          break;
1670       }
1671       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_F1Setup;
1672       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
1673       f1apMsg->choice.initiatingMessage->value.present = \
1674                                                          InitiatingMessage__value_PR_F1SetupRequest;
1675
1676       f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1677
1678       elementCnt = (duCfgParam.duName != NULL) ? 5 : 4;
1679
1680       f1SetupReq->protocolIEs.list.count = elementCnt;
1681       f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t );
1682
1683       /* Initialize the F1Setup members */
1684       DU_ALLOC(f1SetupReq->protocolIEs.list.array,f1SetupReq->protocolIEs.list.size);
1685       if(f1SetupReq->protocolIEs.list.array == NULLP)
1686       {
1687          break;
1688       }
1689       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
1690       {
1691          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx],\
1692                sizeof(F1SetupRequestIEs_t));
1693          if(f1SetupReq->protocolIEs.list.array[ieIdx] == NULLP)
1694          {
1695             break;
1696          }
1697       }
1698
1699       ieIdx = 0;
1700       /*TransactionID*/
1701       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransactionID;
1702       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1703       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present =\
1704                                                                F1SetupRequestIEs__value_PR_TransactionID;
1705       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = \
1706                                                                              TRANS_ID;
1707
1708       /*DU ID*/
1709       ieIdx++;
1710       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
1711       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1712       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1713                                                                 F1SetupRequestIEs__value_PR_GNB_DU_ID;
1714       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size =\
1715                                                                              sizeof(uint8_t);
1716
1717       DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1718             f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1719       if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == \
1720             NULLP)
1721       {
1722          break;
1723       }
1724
1725       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] =\
1726          duCfgParam.duId;
1727
1728       /*DU Name*/
1729       if(duCfgParam.duName != NULL)
1730       {
1731          ieIdx++;
1732          f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_Name;
1733          f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
1734          f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = F1SetupRequestIEs__value_PR_GNB_DU_Name;
1735          f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.size =\
1736             strlen((char *)duCfgParam.duName);
1737          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.\
1738                GNB_DU_Name.buf, strlen((char *)duCfgParam.duName));
1739          if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.\
1740                buf == NULLP)
1741          {
1742             break;
1743          }
1744          strcpy((char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.\
1745                choice.GNB_DU_Name.buf,
1746                (char*)&duCfgParam.duName);
1747
1748       }
1749
1750       /*Served Cell list */
1751       ieIdx++;
1752       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1753                                                      ProtocolIE_ID_id_gNB_DU_Served_Cells_List;
1754       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1755       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1756                                                                 F1SetupRequestIEs__value_PR_GNB_DU_Served_Cells_List;
1757       duServedCell = &f1SetupReq->protocolIEs.list.\
1758                      array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
1759       if(BuildServedCellList(duServedCell))
1760       {
1761          break;
1762       }
1763       /*RRC Version*/
1764       ieIdx++;
1765       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1766                                                      ProtocolIE_ID_id_GNB_DU_RRC_Version ;
1767       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1768       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1769                                                                 F1SetupRequestIEs__value_PR_RRC_Version;
1770       rrcVer = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
1771       if(BuildRrcVer(rrcVer))
1772       {
1773          break;
1774       }
1775       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1776
1777       /* Encode the F1SetupRequest type as APER */
1778       memset(encBuf, 0, ENC_BUF_MAX_LEN);
1779       encBufSize = 0;
1780       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1781             encBuf);
1782
1783       /* Encode results */
1784       if(encRetVal.encoded == ENCODE_FAIL)
1785       {
1786          DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupRequest structure (at %s)\n",\
1787                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1788          break;
1789       }
1790       else
1791       {
1792          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1SetupRequest\n");
1793          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
1794          {
1795             printf("%x",encBuf[ieIdx]);
1796          }
1797       }
1798
1799       /* Sending msg */
1800       if(sendF1APMsg() != ROK)
1801       {
1802          DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup request failed");
1803          break;
1804       }
1805
1806       ret=ROK;
1807       break;
1808    }while(true);
1809
1810    FreeF1SetupReq(f1apMsg);
1811
1812    return ret;
1813 }/* End of BuildAndSendF1SetupReq */
1814
1815 /*******************************************************************
1816  *
1817  * @brief Deallocating memory allocated for Served_Cells_To_Modify_Item_t
1818  *
1819  * @details
1820  *
1821  *    Function : freeCellsToModifyItem
1822  *
1823  *    Functionality: Deallocating memory of variables allocated in
1824  *                    BuildAndSendDUConfigUpdate function
1825  *
1826  * @params[in]  Served_Cells_To_Modify_Item_t *modifyItem
1827  *
1828  * @return ROK     - void
1829  *
1830  * ****************************************************************/
1831
1832 void freeCellsToModifyItem(Served_Cells_To_Modify_Item_t *modifyItem)
1833 {
1834    uint8_t arrIdx=0,i=0;
1835    if(modifyItem->oldNRCGI.pLMN_Identity.buf != NULLP)
1836    {
1837       if(modifyItem->oldNRCGI.nRCellIdentity.buf != NULLP)
1838       {
1839          if(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf != NULLP)
1840          {
1841             if(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf
1842                   != NULLP)
1843             {
1844                if(modifyItem->served_Cell_Information.servedPLMNs.list.array\
1845                      != NULLP)
1846                {
1847                   if(!modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx])
1848                   {
1849                      if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1850                            array[arrIdx]->pLMN_Identity.buf != NULLP)
1851                      {
1852                         if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1853                               array[arrIdx]->iE_Extensions!= NULLP)
1854                         {
1855                            if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1856                                  array[arrIdx]->iE_Extensions->list.array != NULLP)
1857                            {
1858                               if(modifyItem->served_Cell_Information.servedPLMNs.list.\
1859                                     array[arrIdx]->iE_Extensions->list.array[arrIdx])
1860                               {
1861                                  if(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx]->\
1862                                        iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1863                                        list.array !=NULLP)
1864                                  {
1865                                     if(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx]->\
1866                                           iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1867                                           list.array[arrIdx]!=NULLP)
1868                                     {
1869                                        if(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx]->\
1870                                              iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1871                                              list.array[arrIdx]->sNSSAI.sST.buf!=NULLP)
1872                                        {
1873                                           if(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx]->\
1874                                                 iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1875                                                 SliceSupportList.\
1876                                                 list.array[arrIdx]->sNSSAI.sD != NULLP)
1877                                           {
1878                                              if(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx]->\
1879                                                    iE_Extensions->list.array[arrIdx]->extensionValue.\
1880                                                    choice.SliceSupportList.\
1881                                                    list.array[arrIdx]->sNSSAI.sD->buf!=NULLP)
1882                                              {
1883                                                 if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD
1884                                                       !=NULLP)
1885                                                 {
1886                                                    if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1887                                                          fDD->uL_NRFreqInfo.freqBandListNr.list.array!=NULLP)
1888                                                    {
1889                                                       if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1890                                                             fDD->uL_NRFreqInfo.freqBandListNr.list.array[arrIdx]!=NULLP)
1891                                                       {
1892                                                          if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1893                                                                fDD->dL_NRFreqInfo.freqBandListNr.list.array !=NULLP)
1894                                                          {
1895                                                             if(modifyItem->served_Cell_Information.nR_Mode_Info.\
1896                                                                   choice.fDD->dL_NRFreqInfo.freqBandListNr.list.\
1897                                                                   array[arrIdx]!= NULLP)
1898                                                             {
1899                                                                if(modifyItem->served_Cell_Information.\
1900                                                                      measurementTimingConfiguration.buf !=NULLP)
1901                                                                {
1902                                                                   DU_FREE(modifyItem->served_Cell_Information.\
1903                                                                         measurementTimingConfiguration.\
1904                                                                         buf,modifyItem->served_Cell_Information.\
1905                                                                         measurementTimingConfiguration.size);
1906                                                                }
1907                                                                DU_FREE(modifyItem->served_Cell_Information.\
1908                                                                      nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1909                                                                      freqBandListNr.\
1910                                                                      list.array[arrIdx],sizeof(FreqBandNrItem_t));
1911                                                             }
1912                                                             DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info\
1913                                                                   .choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,\
1914                                                                   modifyItem->served_Cell_Information.nR_Mode_Info.\
1915                                                                   choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1916                                                          }
1917                                                          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.\
1918                                                                choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
1919                                                                array[arrIdx],sizeof(FreqBandNrItem_t));
1920                                                       }
1921                                                       DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.\
1922                                                             choice.\
1923                                                             fDD->uL_NRFreqInfo.freqBandListNr.list.\
1924                                                             array,modifyItem->served_Cell_Information.nR_Mode_Info.\
1925                                                             choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1926                                                    }
1927                                                    DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.\
1928                                                          fDD,sizeof(FDD_Info_t));
1929                                                 }
1930                                                 DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1931                                                       array[arrIdx]->iE_Extensions->list.array[arrIdx]->extensionValue.\
1932                                                       choice.SliceSupportList.\
1933                                                       list.array[arrIdx]->sNSSAI.sD->buf,modifyItem->\
1934                                                       served_Cell_Information.\
1935                                                       servedPLMNs.list.array[arrIdx]->iE_Extensions->list.\
1936                                                       array[arrIdx]->\
1937                                                       extensionValue.choice.SliceSupportList.list.array[arrIdx]->\
1938                                                       sNSSAI.sD->size);
1939
1940                                              }
1941                                              DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1942                                                    array[arrIdx]->\
1943                                                    iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1944                                                    SliceSupportList.\
1945                                                    list.array[arrIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1946                                           }
1947                                           DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx]->\
1948                                                 iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1949                                                 SliceSupportList.\
1950                                                 list.array[arrIdx]->sNSSAI.sST.buf,modifyItem->served_Cell_Information.\
1951                                                 servedPLMNs.\
1952                                                 list.array[arrIdx]->iE_Extensions->list.array[arrIdx]->\
1953                                                 extensionValue.choice.\
1954                                                 SliceSupportList.list.array[arrIdx]->sNSSAI.sST.size);
1955                                        }
1956                                        DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx]->\
1957                                              iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1958                                              list.array[arrIdx],sizeof(SliceSupportItem_t));
1959                                     }
1960                                     DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx]->\
1961                                           iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1962                                           list.array,\
1963                                           modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx]->\
1964                                           iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1965                                           SliceSupportList.list.size);
1966                                  }
1967                               }
1968                               for(i=0;i<modifyItem->served_Cell_Information.servedPLMNs.list.\
1969                                     array[arrIdx]->iE_Extensions->list.count;i++)
1970                               {
1971                                  DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1972                                        array[arrIdx]->iE_Extensions->list.array[i],\
1973                                        sizeof(ServedPLMNs_ItemExtIEs_t ));
1974                               }
1975                               DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1976                                     array[arrIdx]->iE_Extensions->list.array,modifyItem->served_Cell_Information.\
1977                                     servedPLMNs.list.array[arrIdx]->iE_Extensions->list.size);
1978                            }
1979                            DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1980                                  array[arrIdx]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1981                         }
1982                         DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.\
1983                               array[arrIdx]->pLMN_Identity.buf,
1984                               modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx]->pLMN_Identity.size);
1985                      }
1986                   }
1987                   for(i=0;i<modifyItem->served_Cell_Information.servedPLMNs.list.count;i++)
1988                   {
1989                      if(modifyItem->served_Cell_Information.servedPLMNs.list.array[i]
1990                            != NULLP)
1991                      {
1992                         DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[i],\
1993                               sizeof(ServedPLMNs_Item_t));
1994                      }
1995                   }
1996                   DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1997                         modifyItem->served_Cell_Information.servedPLMNs.list.size);
1998                }
1999                DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
2000                      modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
2001             }
2002             DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
2003                   modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
2004          }
2005          DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2006                modifyItem->oldNRCGI.nRCellIdentity.size);
2007       }
2008       DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf,\
2009             modifyItem->oldNRCGI.pLMN_Identity.size);
2010    }
2011 }
2012 /*******************************************************************
2013  *
2014  * @brief Deallocating memory of BuildAndSendDUConfigUpdate
2015  *
2016  * @details
2017  *
2018  *    Function : FreeDUConfigUpdate
2019  *
2020  *    Functionality: Deallocating memory of variables allocated in
2021  *                    BuildAndSendDUConfigUpdate function
2022  *
2023  * @params[in]  F1AP_PDU_t *f1apDuCfg
2024  *
2025  * @return ROK     - void
2026  *
2027  * ****************************************************************/
2028 void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg)
2029 {
2030    uint8_t  ieIdx=0, cellModifyIdx=0, cellDeleteIdx=0;
2031    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
2032    Served_Cells_To_Modify_List_t  *cellsToModify=NULLP;
2033    Served_Cells_To_Delete_List_t  *cellsToDelete=NULLP;
2034    Served_Cells_To_Delete_Item_t  *deleteItem = NULLP;
2035    Served_Cells_To_Delete_ItemIEs_t *deleteItemIe = NULLP;
2036
2037    if(f1apDuCfg != NULLP)
2038    {
2039       if(f1apDuCfg->choice.initiatingMessage != NULLP)
2040       {
2041          duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->\
2042                        value.choice.GNBDUConfigurationUpdate;
2043          if(duCfgUpdate->protocolIEs.list.array != NULLP)
2044          {
2045             for(ieIdx=0; ieIdx<duCfgUpdate->protocolIEs.list.count; ieIdx++)
2046             {
2047                if(duCfgUpdate->protocolIEs.list.array[ieIdx] != NULLP)
2048                {
2049                   switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
2050                   {
2051                      case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
2052                         {
2053                            cellsToModify = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
2054                                            value.choice.Served_Cells_To_Modify_List;
2055                            if(cellsToModify->list.array != NULLP)
2056                            {
2057                               for(cellModifyIdx=0; cellModifyIdx<cellsToModify->list.count ;cellModifyIdx++)
2058                               {
2059                                  if(cellsToModify->list.array[cellModifyIdx] != NULLP)
2060                                  {
2061                                     freeCellsToModifyItem(&cellsToModify->list.array[cellModifyIdx]->value.choice.\
2062                                           Served_Cells_To_Modify_Item);
2063                                     DU_FREE(cellsToModify->list.array[cellModifyIdx],\
2064                                           sizeof(Served_Cells_To_Modify_ItemIEs_t));
2065                                  }
2066                               }
2067                               DU_FREE(cellsToModify->list.array,cellsToModify->list.size);
2068                            }
2069                            break;
2070                         }
2071                      case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
2072                         {
2073                            cellsToDelete = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
2074                                            value.choice.Served_Cells_To_Delete_List;
2075                            if(cellsToDelete->list.array != NULLP)
2076                            {
2077                               for(cellDeleteIdx=0; cellDeleteIdx<cellsToDelete->list.count ;cellDeleteIdx++)
2078                               {
2079                                  if(cellsToDelete->list.array[cellDeleteIdx] != NULLP)
2080                                  {
2081                                     deleteItemIe = ((Served_Cells_To_Delete_ItemIEs_t*)\
2082                                           cellsToDelete->list.array[cellDeleteIdx]);
2083                                     deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
2084                                     DU_FREE(deleteItem->oldNRCGI.pLMN_Identity.buf,\
2085                                           deleteItem->oldNRCGI.pLMN_Identity.size);
2086                                     DU_FREE(deleteItem->oldNRCGI.nRCellIdentity.buf,\
2087                                           deleteItem->oldNRCGI.nRCellIdentity.size);
2088                                     DU_FREE(cellsToDelete->list.array[cellDeleteIdx],\
2089                                           sizeof(Served_Cells_To_Delete_ItemIEs_t));
2090                                  }
2091                               }
2092                               DU_FREE(cellsToDelete->list.array,cellsToDelete->list.size);
2093                            }
2094
2095                            break;
2096                         }
2097                      case GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID:
2098                         {
2099                            DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2100                                  duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2101                            break;
2102                         }
2103                   }
2104                   DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx],\
2105                         sizeof(GNBDUConfigurationUpdateIEs_t));
2106                }
2107             }
2108             DU_FREE(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2109          }
2110          DU_FREE(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2111       }
2112       DU_FREE(f1apDuCfg, (Size)sizeof(F1AP_PDU_t));
2113    }
2114 }
2115
2116 /*******************************************************************
2117  *
2118  * @brief Fills Served Plmns required in ServCellInfo IE
2119  *
2120  * @details
2121  *
2122  *    Function : fillServedPlmns
2123  *
2124  *    Functionality: Fills Served Plmns required in ServCellInfo IE
2125  *
2126  * @params[in] Pointer to ServedPLMNs_List_t *
2127  *
2128  * @return ROK     - success
2129  *         RFAILED - failure
2130  *
2131  *****************************************************************/
2132
2133 uint8_t fillServedPlmns(ServedPLMNs_List_t *servedPlmn)
2134 {
2135    uint8_t ieIdx, ieListCnt;
2136
2137    servedPlmn->list.array[0]->pLMN_Identity.size = 3*sizeof(uint8_t);
2138    DU_ALLOC(servedPlmn->list.array[0]->pLMN_Identity.buf, servedPlmn->list.\
2139          array[0]->pLMN_Identity.size);
2140    if(servedPlmn->list.array[0]->pLMN_Identity.buf == NULLP)
2141    {
2142       return RFAILED;
2143    }
2144    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.plmn[0],\
2145          servedPlmn->list.array[0]->pLMN_Identity.buf);
2146    DU_ALLOC(servedPlmn->list.array[0]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
2147    if(servedPlmn->list.array[0]->iE_Extensions == NULLP)
2148    {
2149       return RFAILED;
2150    }
2151
2152    ieListCnt=1;
2153    servedPlmn->list.array[0]->iE_Extensions->list.count = ieListCnt;
2154    servedPlmn->list.array[0]->iE_Extensions->list.size = ieListCnt *sizeof(ServedPLMNs_ItemExtIEs_t *);
2155    DU_ALLOC(servedPlmn->list.array[0]->iE_Extensions->list.array,servedPlmn->list.array[0]->\
2156          iE_Extensions->list.size);
2157    if(servedPlmn->list.array[0]->iE_Extensions->list.array == NULLP)
2158    {
2159       return RFAILED;
2160    }
2161    for(ieIdx=0;ieIdx<ieListCnt;ieIdx++)
2162    {
2163       DU_ALLOC(servedPlmn->list.array[0]->iE_Extensions->list.array[ieIdx],\
2164             sizeof(ServedPLMNs_ItemExtIEs_t));
2165       if(servedPlmn->list.array[0]->iE_Extensions->list.array[ieIdx] == NULLP)
2166       {
2167          return RFAILED;
2168       }
2169    }
2170    //plmnIeExt = servedPlmn->list.array[0]->iE_Extensions;
2171    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->id =ProtocolIE_ID_id_TAISliceSupportList;
2172    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->criticality = Criticality_ignore;
2173    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->extensionValue.present = \
2174       ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
2175    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2176       list.count = 1;
2177    servedPlmn->list.array[0]->\
2178       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2179       list.size = sizeof(SliceSupportItem_t *);
2180    DU_ALLOC(servedPlmn->list.array[0]->\
2181          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2182          list.array,servedPlmn->list.array[0]->\
2183          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.list.size);
2184    if(servedPlmn->list.array[0]->\
2185          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2186          list.array == NULLP)
2187    {
2188       return RFAILED;
2189    }
2190
2191    DU_ALLOC(servedPlmn->list.array[0]->\
2192          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2193          list.array[0],sizeof( SliceSupportItem_t));
2194    if(servedPlmn->list.array[0]->\
2195          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2196          list.array[0] == NULLP)
2197    {
2198       return RFAILED;
2199    }
2200    servedPlmn->list.array[0]->\
2201       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2202       list.array[0]->sNSSAI.sST.size = sizeof(uint8_t);
2203    DU_ALLOC(servedPlmn->list.array[0]->\
2204          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2205          list.array[0]->sNSSAI.sST.buf,servedPlmn->list.array[0]->\
2206          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.list.array[0]->sNSSAI.sST.size);
2207    if(servedPlmn->list.array[0]->\
2208          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2209          list.array[0]->sNSSAI.sST.buf == NULLP)
2210    {
2211       return RFAILED;
2212    }
2213    servedPlmn->list.array[0]->\
2214       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2215       list.array[0]->sNSSAI.sST.buf[0] = 3;
2216    DU_ALLOC(servedPlmn->list.array[0]->\
2217          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2218          list.array[0]->sNSSAI.sD,sizeof(OCTET_STRING_t));
2219    if(servedPlmn->list.array[0]->\
2220          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2221          list.array[0]->sNSSAI.sD == NULLP)
2222    {
2223       return RFAILED;
2224    }
2225    servedPlmn->list.array[0]->\
2226       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2227       list.array[0]->sNSSAI.sD->size = 3*sizeof(uint8_t);
2228    DU_ALLOC(servedPlmn->list.array[0]->\
2229          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2230          list.array[0]->sNSSAI.sD->buf,servedPlmn->list.array[0]->\
2231          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2232          list.array[0]->sNSSAI.sD->size);
2233    if(servedPlmn->list.array[0]->\
2234          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2235          list.array[0]->sNSSAI.sD->buf == NULLP)
2236    {
2237       return RFAILED;
2238    }
2239    servedPlmn->list.array[0]->\
2240       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2241       list.array[0]->sNSSAI.sD->buf[0] = 3;
2242    servedPlmn->list.array[0]->\
2243       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2244       list.array[0]->sNSSAI.sD->buf[1] = 6;
2245    servedPlmn->list.array[0]->\
2246       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2247       list.array[0]->sNSSAI.sD->buf[2] = 9;
2248    return ROK;
2249 }
2250
2251 /*******************************************************************
2252  *
2253  * @brief Fills Nr Fdd Info required in ServCellInfo IE
2254  *
2255  * @details
2256  *
2257  *    Function : fillNrFddInfo
2258  *
2259  *    Functionality: Fills Nr Fdd Info required in ServCellInfo IE
2260  *
2261  * @params[in] Pointer to NR_Mode_Info_t *
2262  *
2263  * @return ROK     - success
2264  *         RFAILED - failure
2265  *
2266  *****************************************************************/
2267
2268 uint8_t fillNrFddInfo(NR_Mode_Info_t *nrFdd)
2269 {
2270    nrFdd->choice.fDD->uL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.\
2271       f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn;
2272    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.count = 1;
2273    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t*);
2274    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
2275          array, nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size);
2276    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2277    {
2278       return RFAILED;
2279    }
2280    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0], \
2281       sizeof(FreqBandNrItem_t));
2282    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2283    {
2284       return RFAILED;
2285    }
2286    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2287       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
2288       freqBand[0].nrFreqBand;
2289    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2290    nrFdd->choice.fDD->dL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.\
2291       dlNrFreqInfo.nrArfcn;
2292    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.count = 1;
2293    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
2294    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,nrFdd->\
2295          choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
2296    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2297    {
2298       return RFAILED;
2299    }
2300    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0],\
2301          sizeof(FreqBandNrItem_t));
2302    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2303    {
2304       return RFAILED;
2305    }
2306    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2307       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
2308       freqBand[0].nrFreqBand;
2309    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2310
2311    /*Transmission Bandwidth*/
2312    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2313       f1Mode.mode.fdd.ulTxBw.nrScs;
2314    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2315       f1Mode.mode.fdd.ulTxBw.nrb;
2316    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2317       f1Mode.mode.fdd.dlTxBw.nrScs;
2318    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2319       f1Mode.mode.fdd.dlTxBw.nrb;
2320
2321    return ROK;
2322 }
2323
2324 /*******************************************************************
2325  *
2326  * @brief Fills ServCellInfo IE
2327  *
2328  * @details
2329  *
2330  *    Function : fillServedCellInfo
2331  *
2332  *    Functionality: Fills ServCellInfo
2333  *
2334  * @params[in] Pointer to Served_Cell_Information_t *
2335  *
2336  * @return ROK     - success
2337  *         RFAILED - failure
2338  *
2339  *****************************************************************/
2340
2341 uint8_t fillServedCellInfo(Served_Cell_Information_t *srvCellInfo)
2342 {
2343    uint8_t tmp, ieIdx, ieListCnt;
2344
2345    /*nRCGI*/
2346    srvCellInfo->nRCGI.pLMN_Identity.size =3*sizeof(uint8_t);
2347    DU_ALLOC(srvCellInfo->nRCGI.pLMN_Identity.buf,\
2348          srvCellInfo->nRCGI.pLMN_Identity.size);
2349    if(srvCellInfo->nRCGI.pLMN_Identity.buf == NULLP)
2350    {
2351       return RFAILED;
2352    }
2353    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2354          srvCellInfo->nRCGI.pLMN_Identity.buf);
2355    srvCellInfo->nRCGI.nRCellIdentity.size =5*sizeof(uint8_t);
2356    DU_ALLOC(srvCellInfo->nRCGI.nRCellIdentity.buf,\
2357          srvCellInfo->nRCGI.nRCellIdentity.size);
2358    if(srvCellInfo->nRCGI.nRCellIdentity.buf == NULLP)
2359    {
2360       return RFAILED;
2361    }
2362    for (tmp = 0 ; tmp < srvCellInfo->\
2363          nRCGI.nRCellIdentity.size-1 ; tmp++)
2364    {
2365       srvCellInfo->nRCGI.nRCellIdentity.buf[tmp] = 0;
2366    }
2367    srvCellInfo->nRCGI.nRCellIdentity.buf[4] = 16;
2368    srvCellInfo->nRCGI.nRCellIdentity.bits_unused =4;
2369
2370    /*nRPCI*/
2371    srvCellInfo->nRPCI = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
2372
2373    /*servedPLMNs*/
2374    ieListCnt = 1;
2375    srvCellInfo->servedPLMNs.list.count = ieListCnt;
2376    srvCellInfo->servedPLMNs.list.size = ieListCnt*sizeof(ServedPLMNs_Item_t *);
2377    DU_ALLOC(srvCellInfo->servedPLMNs.list.array,\
2378          srvCellInfo->servedPLMNs.list.size);
2379    if(srvCellInfo->servedPLMNs.list.array == NULLP)
2380    {
2381       return RFAILED;
2382    }
2383    for(ieIdx=0; ieIdx < ieListCnt; ieIdx++)
2384    {
2385       DU_ALLOC(srvCellInfo->servedPLMNs.list.array[ieIdx],\
2386             sizeof(ServedPLMNs_Item_t));
2387       if(srvCellInfo->servedPLMNs.list.array[ieIdx]== NULLP)
2388       {
2389          return RFAILED;
2390       }
2391    }
2392    if(fillServedPlmns(&srvCellInfo->servedPLMNs))
2393    {
2394       return RFAILED;
2395    }
2396
2397    /*nR Mode Info with FDD*/
2398    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_fDD;
2399    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.fDD,\
2400          sizeof(FDD_Info_t));
2401    if(srvCellInfo->nR_Mode_Info.choice.fDD == NULLP)
2402    {
2403       return RFAILED;
2404    }
2405    if(fillNrFddInfo(&srvCellInfo->nR_Mode_Info))
2406       return RFAILED;
2407
2408    /*Measurement timing Config*/
2409    srvCellInfo->measurementTimingConfiguration.size = sizeof(uint8_t);
2410    DU_ALLOC(srvCellInfo->measurementTimingConfiguration.\
2411          buf,srvCellInfo->measurementTimingConfiguration.size);
2412    if(srvCellInfo->measurementTimingConfiguration.buf == NULLP)
2413    {
2414       return RFAILED;
2415    }
2416    srvCellInfo->measurementTimingConfiguration.\
2417          buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
2418
2419    return ROK;
2420 }
2421
2422 /*******************************************************************
2423  *
2424  * @brief Fills ServCellToModItem IE
2425  *
2426  * @details
2427  *
2428  *    Function : fillServCellToModItem
2429  *
2430  *    Functionality: Fills ServCellToModItem IE
2431  *
2432  * @params[in] Pointer to Served_Cells_To_Modify_Item_t *
2433  *
2434  * @return ROK     - success
2435  *         RFAILED - failure
2436  *
2437  *****************************************************************/
2438
2439 uint8_t fillServCellToModItem(Served_Cells_To_Modify_Item_t *modifyItem)
2440 {
2441    uint8_t ieIdx;
2442
2443    /*pLMN_Identity*/
2444    modifyItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2445    DU_ALLOC(modifyItem->oldNRCGI.pLMN_Identity.buf,modifyItem->oldNRCGI.pLMN_Identity.size);
2446    if(modifyItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2447    {
2448       return RFAILED;
2449    }
2450    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2451          modifyItem->oldNRCGI.pLMN_Identity.buf);
2452
2453    /*nRCellIdentity*/
2454    modifyItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2455    DU_ALLOC(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2456          modifyItem->oldNRCGI.nRCellIdentity.size);
2457    if(modifyItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2458    {
2459       return RFAILED;
2460    }
2461    for(ieIdx = 0; ieIdx < modifyItem->oldNRCGI.nRCellIdentity.size-1; ieIdx++)
2462    {
2463       modifyItem->oldNRCGI.nRCellIdentity.buf[ieIdx] = 0;
2464    }
2465    modifyItem->oldNRCGI.nRCellIdentity.buf[4] = 16;
2466    modifyItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
2467
2468    if(fillServedCellInfo(&modifyItem->served_Cell_Information))
2469       return RFAILED;
2470    else
2471       return ROK;
2472 }
2473
2474 /*******************************************************************
2475  *
2476  * @brief Builds ServCellToModList
2477  *
2478  * @details
2479  *
2480  *    Function : buildServCellToModList
2481  *
2482  *    Functionality: Builds the serv cell to Mod List
2483  *
2484  * @params[in] Pointer to Served_Cells_To_Modify_List_t *
2485  *
2486  * @return ROK     - success
2487  *         RFAILED - failure
2488  *
2489  *****************************************************************/
2490
2491 uint8_t buildServCellToModList(Served_Cells_To_Modify_List_t *cellsToModify)
2492 {
2493    uint8_t ieListCnt, ieIdx;
2494    Served_Cells_To_Modify_Item_t *modifyItem = NULLP;
2495
2496    ieListCnt = 1;
2497    cellsToModify->list.count = ieListCnt;
2498    cellsToModify->list.size = ieListCnt*sizeof(Served_Cells_To_Modify_ItemIEs_t *);
2499    DU_ALLOC(cellsToModify->list.array,cellsToModify->list.size);
2500    if(cellsToModify->list.array == NULLP)
2501    {
2502       return RFAILED;
2503    }
2504    for(ieIdx=0; ieIdx< ieListCnt; ieIdx++)
2505    {
2506       DU_ALLOC(cellsToModify->list.array[ieIdx],sizeof(Served_Cells_To_Modify_ItemIEs_t));
2507       if(cellsToModify->list.array[ieIdx] == NULLP)
2508       {
2509          return RFAILED;
2510       }
2511    }
2512    cellsToModify->list.array[0]->id = ProtocolIE_ID_id_Served_Cells_To_Modify_Item;
2513    cellsToModify->list.array[0]->criticality = Criticality_reject;
2514    cellsToModify->list.array[0]->value.present =\
2515       Served_Cells_To_Modify_ItemIEs__value_PR_Served_Cells_To_Modify_Item;
2516    modifyItem=&cellsToModify->list.array[0]->value.choice.Served_Cells_To_Modify_Item;
2517
2518    if(fillServCellToModItem(modifyItem))
2519       return RFAILED;
2520    else
2521       return ROK;
2522 }
2523 /*******************************************************************
2524  *
2525  * @brief filling the DeleteItemList
2526  *
2527  * @details
2528  *
2529  *    Function : fillCellToDeleteItem
2530  *
2531  *    Functionality: Filling the DeleteItemIe
2532  *
2533  * @params[in] Pointer to Served_Cells_To_Delete_ItemIEs_t
2534  *
2535  * @return ROK     - success
2536  *         RFAILED - failure
2537  *
2538  *****************************************************************/
2539 uint8_t fillCellToDeleteItem(struct Served_Cells_To_Delete_ItemIEs *deleteItemIe)
2540 {
2541    uint8_t arrIdx;
2542    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
2543
2544    deleteItemIe->id = ProtocolIE_ID_id_Served_Cells_To_Delete_Item;
2545    deleteItemIe->criticality = Criticality_reject;
2546    deleteItemIe->value.present =\
2547    Served_Cells_To_Delete_ItemIEs__value_PR_Served_Cells_To_Delete_Item;
2548    deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
2549
2550    /*pLMN_Identity*/
2551    deleteItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2552    DU_ALLOC(deleteItem->oldNRCGI.pLMN_Identity.buf,deleteItem->oldNRCGI.pLMN_Identity.size);
2553    if(deleteItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2554    {
2555       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2556       return RFAILED;
2557    }
2558    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2559          deleteItem->oldNRCGI.pLMN_Identity.buf);
2560
2561    /*nRCellIdentity*/
2562    deleteItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2563    DU_ALLOC(deleteItem->oldNRCGI.nRCellIdentity.buf,\
2564          deleteItem->oldNRCGI.nRCellIdentity.size);
2565    if(deleteItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2566    {
2567       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2568       return RFAILED;
2569    }
2570    for(arrIdx = 0; arrIdx < deleteItem->oldNRCGI.nRCellIdentity.size-1; arrIdx++)
2571    {
2572       deleteItem->oldNRCGI.nRCellIdentity.buf[arrIdx] = 0;
2573    }
2574    deleteItem->oldNRCGI.nRCellIdentity.buf[4] = 16;
2575    deleteItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
2576    return ROK;
2577 }
2578 /*******************************************************************
2579  *
2580  * @brief Builds ServCellToDeleteList
2581  *
2582  * @details
2583  *
2584  *    Function : buildServCellToDeleteList
2585  *
2586  *    Functionality: Builds the serv cell to delete List
2587  *
2588  * @params[in] Pointer to Served_Cells_To_Delete_List_t *
2589  *
2590  * @return ROK     - success
2591  *         RFAILED - failure
2592  *
2593  *****************************************************************/
2594
2595 uint8_t buildServCellToDeleteList(Served_Cells_To_Delete_List_t *cellsToDelete)
2596 {
2597    uint8_t ieListCnt, arrIdx;
2598
2599    ieListCnt = 1;
2600    cellsToDelete->list.count = ieListCnt;
2601    cellsToDelete->list.size = ieListCnt*sizeof(Served_Cells_To_Delete_ItemIEs_t *);
2602
2603    DU_ALLOC(cellsToDelete->list.array,cellsToDelete->list.size);
2604    if(cellsToDelete->list.array == NULLP)
2605    {
2606       DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2607       return RFAILED;
2608    }
2609
2610    for(arrIdx=0; arrIdx< ieListCnt; arrIdx++)
2611    {
2612       DU_ALLOC(cellsToDelete->list.array[arrIdx],sizeof(Served_Cells_To_Delete_ItemIEs_t));
2613       if(cellsToDelete->list.array[arrIdx] == NULLP)
2614       {
2615          DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2616          return RFAILED;
2617       }
2618    }
2619
2620    arrIdx=0;
2621    if(fillCellToDeleteItem((Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx]) !=ROK)
2622    {
2623       DU_LOG("\nERROR  -->  F1AP: buildServCellToDeleteList(): failed to fill Served_Cells_To_Delete_ItemIEs");
2624       return RFAILED;
2625    }
2626    return ROK;
2627 }
2628
2629 /*******************************************************************
2630  *
2631  * @brief Builds and sends the DUConfigUpdate
2632  *
2633  * @details
2634  *
2635  *    Function : BuildAndSendDUConfigUpdate
2636  *
2637  *    Functionality: Constructs the DU Update message and sends
2638  *                   it to the CU through SCTP.
2639  *
2640  * @params[in] void **buf,Buffer to which encoded pattern is written into
2641  * @params[in] int *size,size of buffer
2642  *
2643  * @return ROK     - success
2644  *         RFAILED - failure
2645  *
2646  * ****************************************************************/
2647 uint8_t BuildAndSendDUConfigUpdate(ServCellAction servCellAction)
2648 {
2649    uint8_t ret =0, ieIdx=0, elementCnt=0;
2650    bool memAlloctionFailure = false;
2651    F1AP_PDU_t                 *f1apDuCfg = NULLP;
2652    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
2653    asn_enc_rval_t encRetVal;     /* Encoder return value */
2654
2655    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2656    ret= RFAILED;
2657
2658    while(true)
2659    {
2660       DU_LOG("\nINFO   -->  F1AP : Building DU config update\n");
2661       /* Allocate the memory for F1DuCfg */
2662       DU_ALLOC(f1apDuCfg, sizeof(F1AP_PDU_t));
2663       if(f1apDuCfg == NULLP)
2664       {
2665          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2666          break;
2667       }
2668
2669       f1apDuCfg->present = F1AP_PDU_PR_initiatingMessage;
2670       DU_ALLOC(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2671       if(f1apDuCfg->choice.initiatingMessage == NULLP)
2672       {
2673          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2674          break;
2675       }
2676
2677       f1apDuCfg->choice.initiatingMessage->procedureCode = \
2678                                                            ProcedureCode_id_gNBDUConfigurationUpdate;
2679       f1apDuCfg->choice.initiatingMessage->criticality = Criticality_reject;
2680       f1apDuCfg->choice.initiatingMessage->value.present = \
2681                                                            InitiatingMessage__value_PR_GNBDUConfigurationUpdate;
2682       duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\
2683                     choice.GNBDUConfigurationUpdate;
2684       elementCnt = 3;
2685       duCfgUpdate->protocolIEs.list.count = elementCnt;
2686       duCfgUpdate->protocolIEs.list.size = \
2687                                            elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t*);
2688
2689       /* Initialize the F1Setup members */
2690       DU_ALLOC(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2691       if(duCfgUpdate->protocolIEs.list.array == NULLP)
2692       {
2693          DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2694          break;
2695       }
2696       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
2697       {
2698          DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx],sizeof(GNBDUConfigurationUpdateIEs_t));
2699          if(duCfgUpdate->protocolIEs.list.array[ieIdx] == NULLP)
2700          {
2701             DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2702             memAlloctionFailure = true;
2703             break;
2704          }
2705       }
2706
2707       if(memAlloctionFailure == true)
2708       {
2709          break;
2710       }
2711       /*TransactionID*/
2712       ieIdx = 0;
2713       duCfgUpdate->protocolIEs.list.array[ieIdx]->id=ProtocolIE_ID_id_TransactionID;
2714       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
2715       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2716       GNBDUConfigurationUpdateIEs__value_PR_TransactionID;
2717       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = TRANS_ID;
2718
2719       ieIdx++;
2720       if(servCellAction == SERV_CELL_TO_MODIFY)
2721       {
2722          /*Served Cell to Modify */
2723          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2724          ProtocolIE_ID_id_Served_Cells_To_Modify_List;
2725          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2726          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2727          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Modify_List;
2728          if(buildServCellToModList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2729                   Served_Cells_To_Modify_List))
2730          {
2731             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToModList");
2732             break;
2733          }
2734       }
2735       else
2736       {
2737          /*Served Cell to Delete */
2738          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2739          ProtocolIE_ID_id_Served_Cells_To_Delete_List;
2740          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2741          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2742          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Delete_List;
2743          if(buildServCellToDeleteList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2744          Served_Cells_To_Delete_List)!=ROK)
2745          {
2746             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToDeleteList");
2747             break;
2748          }
2749
2750       }
2751       // NOTE :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
2752       /*GNB DU ID */
2753       ieIdx++;
2754       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
2755       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
2756       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2757       GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID;
2758       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size = sizeof(uint8_t);
2759       DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2760             duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2761       if(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == NULLP)
2762       {
2763          DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): Memory allocation failed for GNB_DU_ID");
2764          break;
2765       }
2766       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] = duCfgParam.duId;
2767
2768       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
2769
2770       /* Encode the DU Config Update type as APER */
2771       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
2772       encBufSize = 0;
2773       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
2774
2775       /* Checking encode results */
2776       if(encRetVal.encoded == ENCODE_FAIL)
2777       {
2778          DU_LOG("ERROR  -->  F1AP : Could not encode DUConfigUpdate structure (at %s)\n",\
2779                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2780          break;
2781       }
2782       else
2783       {
2784          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DUConfigUpdate\n");
2785          for(ieIdx =0; ieIdx < encBufSize; ieIdx++)
2786          {
2787             printf("%x",encBuf[ieIdx]);
2788          }
2789       }
2790       /* Sending msg */
2791       if(sendF1APMsg() != ROK)
2792       {
2793          DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update failed");
2794          break;
2795       }
2796
2797       ret = ROK;
2798       break;
2799    }
2800
2801    addToReservedF1apPduList(TRANS_ID,f1apDuCfg);
2802    return ret;
2803 }
2804
2805
2806 /*******************************************************************
2807  *
2808  * @brief free the ULRRCMessageTransfer
2809  *
2810  * @details
2811  *
2812  *    Function : FreeULRRCMessageTransfer
2813  *
2814  *    Functionality: Deallocating the memory of variable allocated in
2815  *                      FreeULRRCMessageTransfer
2816  *
2817  * @params[in]
2818  *
2819  * @return ROK     - void
2820  *
2821  ******************************************************************/
2822 void FreeULRRCMessageTransfer( F1AP_PDU_t *f1apMsg)
2823 {
2824    uint8_t idx1;
2825    ULRRCMessageTransfer_t  *ulRRCMsg;
2826
2827    if(f1apMsg != NULLP)
2828    {
2829       if(f1apMsg->choice.initiatingMessage != NULLP)
2830       {
2831          ulRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2832          if(ulRRCMsg->protocolIEs.list.array != NULLP)
2833          {
2834             for(idx1=0;idx1<ulRRCMsg->protocolIEs.list.count;idx1++)
2835             {
2836                if(ulRRCMsg->protocolIEs.list.array[idx1] != NULLP)
2837                {
2838                   if(ulRRCMsg->protocolIEs.list.array[idx1]->value.present ==
2839                         ULRRCMessageTransferIEs__value_PR_RRCContainer)
2840                   {
2841                      DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2842                            ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2843                   }
2844                   DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1],sizeof(ULRRCMessageTransferIEs_t));
2845                }
2846             }
2847             DU_FREE(ulRRCMsg->protocolIEs.list.array,ulRRCMsg->protocolIEs.list.size );
2848          }
2849          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2850       }
2851       DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
2852    }
2853 }
2854 /*******************************************************************
2855  *
2856  * @brief Builds and sends the ULRRCMessageTransfer
2857  *
2858  * @details
2859  *
2860  *    Function : BuildAndSendULRRCMessageTransfer
2861  *
2862  *    Functionality: Constructs the UL RRC Message Transfer and sends
2863  *                   it to the CU through SCTP.
2864  *
2865  * @params[in]
2866  *
2867  * @return ROK     - success
2868  *         RFAILED - failure
2869  *
2870  * ****************************************************************/
2871 uint8_t BuildAndSendULRRCMessageTransfer(DuUeCb  ueCb, uint8_t lcId, \
2872       uint16_t msgLen, uint8_t *rrcMsg)
2873 {
2874    uint8_t   elementCnt =0;
2875    uint8_t   idx1 =0;
2876    uint8_t   idx =0;
2877    F1AP_PDU_t                   *f1apMsg = NULLP;
2878    ULRRCMessageTransfer_t       *ulRRCMsg = NULLP;
2879    asn_enc_rval_t               encRetVal;        /* Encoder return value */
2880    uint8_t ret =RFAILED;
2881
2882    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2883
2884    while(true)
2885    {
2886       DU_LOG("\n INFO   -->  F1AP : Building UL RRC Message Transfer Message\n");
2887
2888       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
2889       if(f1apMsg == NULLP)
2890       {
2891          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2892          break;
2893       }
2894       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
2895       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2896       if(f1apMsg->choice.initiatingMessage == NULLP)
2897       {
2898          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
2899          break;
2900       }
2901       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_ULRRCMessageTransfer;
2902       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
2903       f1apMsg->choice.initiatingMessage->value.present = \
2904                                                          InitiatingMessage__value_PR_ULRRCMessageTransfer;
2905       ulRRCMsg =
2906          &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2907       elementCnt = 4;
2908       ulRRCMsg->protocolIEs.list.count = elementCnt;
2909       ulRRCMsg->protocolIEs.list.size = \
2910                                         elementCnt * sizeof(ULRRCMessageTransferIEs_t *);
2911
2912       /* Initialize the F1Setup members */
2913       DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size);
2914       if(ulRRCMsg->protocolIEs.list.array == NULLP)
2915       {
2916          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
2917          break;
2918       }
2919       for(idx=0; idx<elementCnt; idx++)
2920       {
2921          DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t));
2922          if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP)
2923          {
2924             break;
2925          }
2926       }
2927
2928       idx1 = 0;
2929
2930       /*GNB CU UE F1AP ID*/
2931       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
2932       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2933       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2934                                                               ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
2935       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = ueCb.gnbCuUeF1apId;
2936
2937       /*GNB DU UE F1AP ID*/
2938       idx1++;
2939       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
2940       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2941       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2942                                                               ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
2943       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = ueCb.gnbDuUeF1apId;
2944
2945       /*SRBID*/
2946       idx1++;
2947       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
2948       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2949       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2950                                                               ULRRCMessageTransferIEs__value_PR_SRBID;
2951       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = lcId;
2952
2953       /*RRCContainer*/
2954       idx1++;
2955       ulRRCMsg->protocolIEs.list.array[idx1]->id  = ProtocolIE_ID_id_RRCContainer;
2956       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2957       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2958                                                               ULRRCMessageTransferIEs__value_PR_RRCContainer;
2959       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size = msgLen;
2960       DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2961             ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
2962       if(!ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
2963       {
2964          DU_LOG(" ERROR  -->  F1AP : Memory allocation for BuildAndSendULRRCMessageTransfer failed");
2965          break;
2966       }
2967       memset(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, 0, msgLen);
2968       memcpy(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, \
2969             rrcMsg, ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2970
2971       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2972
2973       /* Encode the F1SetupRequest type as APER */
2974       memset(encBuf, 0, ENC_BUF_MAX_LEN);
2975       encBufSize = 0;
2976       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
2977             encBuf);
2978       /* Encode results */
2979       if(encRetVal.encoded == ENCODE_FAIL)
2980       {
2981          DU_LOG( "\nERROR  -->  F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
2982                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2983          break;
2984       }
2985       else
2986       {
2987          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
2988          for(int i=0; i< encBufSize; i++)
2989          {
2990             printf("%x",encBuf[i]);
2991          }
2992       }
2993
2994       /* Sending  msg  */
2995       if(sendF1APMsg()  !=      ROK)
2996       {
2997          DU_LOG("\nERROR  -->   F1AP : Sending  UL RRC Message Transfer Failed");
2998          break;
2999       }
3000       ret = ROK;
3001       break;
3002    }
3003    FreeULRRCMessageTransfer(f1apMsg);
3004
3005    return ret;
3006 }/* End of BuildAndSendULRRCMessageTransfer*/
3007
3008 /*******************************************************************
3009  *
3010  * @brief Builds tag config
3011  *
3012  * @details
3013  *
3014  *    Function : BuildTagConfig
3015  *
3016  *    Functionality: Builds tag config in MacCellGroupConfig
3017  *
3018  * @params[in] TAG_Config *tag_Config
3019  *
3020  * @return ROK     - success
3021  *         RFAILED - failure
3022  *
3023  * ****************************************************************/
3024 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
3025 {
3026    struct TAG_Config__tag_ToAddModList *tagList;
3027    uint8_t                     idx, elementCnt;
3028
3029    tagConfig->tag_ToReleaseList = NULLP;
3030    tagConfig->tag_ToAddModList = NULLP;
3031    DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
3032    if(!tagConfig->tag_ToAddModList)
3033    {
3034       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
3035       return RFAILED;
3036    }
3037
3038    elementCnt = 1; //ODU_VALUE_ONE;
3039    tagList = tagConfig->tag_ToAddModList;
3040    tagList->list.count = elementCnt;
3041    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
3042
3043    tagList->list.array = NULLP;
3044    DU_ALLOC(tagList->list.array, tagList->list.size);
3045    if(!tagList->list.array)
3046    {
3047       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
3048       return RFAILED;
3049    }
3050
3051    for(idx=0; idx<tagList->list.count; idx++)
3052    {
3053       tagList->list.array[idx] = NULLP;
3054       DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
3055       if(!tagList->list.array[idx])
3056       {
3057          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
3058          return RFAILED;
3059       }
3060    }
3061
3062    idx = 0;
3063    tagList->list.array[idx]->tag_Id = TAG_ID;
3064    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
3065
3066    return ROK;
3067 }
3068
3069 /*******************************************************************
3070  *
3071  * @brief Builds PHR Config
3072  *
3073  * @details
3074  *
3075  *    Function : BuildPhrConfig
3076  *
3077  *    Functionality: Builds phrConfig in MacCellGroupConfig
3078  *
3079  * @params[in] PHR Config *
3080  *
3081  * @return ROK     - success
3082  *         RFAILED - failure
3083  *
3084  * ****************************************************************/
3085 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
3086 {
3087
3088    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
3089    phrConfig->choice.setup = NULLP;
3090    DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
3091    if(!phrConfig->choice.setup)
3092    {
3093       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
3094       return RFAILED;
3095    }
3096
3097    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
3098    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
3099    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
3100    phrConfig->choice.setup->multiplePHR              = false;
3101    phrConfig->choice.setup->dummy                    = false;
3102    phrConfig->choice.setup->phr_Type2OtherCell       = false;
3103    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
3104
3105    return ROK;
3106 }
3107
3108 /*******************************************************************
3109  *
3110  * @brief Builds BSR Config
3111  *
3112  * @details
3113  *
3114  *    Function : BuildBsrConfig
3115  *
3116  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
3117  *
3118  * @params[in] BSR_Config *bsrConfig
3119  *
3120  * @return ROK     - success
3121  *         RFAILED - failure
3122  *
3123  * ****************************************************************/
3124 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
3125 {
3126    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
3127    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
3128    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
3129
3130    return ROK;
3131 }
3132
3133 /*******************************************************************
3134  *
3135  * @brief Builds scheduling request config
3136  *
3137  * @details
3138  *
3139  *    Function : BuildSchedulingReqConfig
3140  *
3141  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
3142  *
3143  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
3144  *
3145  * @return ROK     - success
3146  *         RFAILED - failure
3147  *
3148  * ****************************************************************/
3149 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
3150 {
3151    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
3152    uint8_t                     idx, elementCnt;
3153
3154    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
3155    DU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
3156          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
3157    if(!schedulingRequestConfig->schedulingRequestToAddModList)
3158    {
3159       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3160       return RFAILED;
3161    }
3162
3163    elementCnt = 1; //ODU_VALUE_ONE;
3164    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
3165    schReqList->list.count = elementCnt;
3166    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
3167
3168    schReqList->list.array = NULLP;
3169    DU_ALLOC(schReqList->list.array, schReqList->list.size);
3170    if(!schReqList->list.array)
3171    {
3172       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3173       return RFAILED;
3174    }
3175
3176    for(idx=0;idx<schReqList->list.count; idx++)
3177    {
3178       schReqList->list.array[idx] = NULLP;
3179       DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
3180       if(!schReqList->list.array[idx])
3181       {
3182          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3183          return RFAILED;
3184       }
3185    }
3186
3187    idx = 0;
3188    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
3189
3190    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
3191    DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
3192    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
3193    {
3194       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3195       return RFAILED;
3196    }
3197    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
3198    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
3199    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
3200
3201    return ROK;
3202 }
3203
3204 /*******************************************************************
3205  *
3206  * @brief Builds RLC Config
3207  *
3208  * @details
3209  *
3210  *    Function : BuildRlcConfig
3211  *
3212  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
3213  *
3214  * @params[in] RLC_Config *rlcConfig
3215  *
3216  * @return ROK     - success
3217  *         RFAILED - failure
3218  *
3219  * ****************************************************************/
3220 uint8_t BuildRlcConfig(struct RLC_Config *rlcConfig)
3221 {
3222
3223    rlcConfig->present = RLC_Config_PR_am;
3224
3225    rlcConfig->choice.am = NULLP;
3226    DU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
3227    if(!rlcConfig->choice.am)
3228    {
3229       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3230       return RFAILED;
3231    }
3232
3233    /* UL */
3234    rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
3235    DU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3236    if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
3237    {
3238       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3239       return RFAILED;
3240    }
3241    *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3242    rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
3243    rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
3244    rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
3245    rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
3246
3247    /* DL */
3248    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
3249    DU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3250    if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
3251    {
3252       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3253       return RFAILED;
3254    }
3255    *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3256    rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
3257    rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
3258
3259    return ROK;
3260 }
3261
3262 /*******************************************************************
3263  *
3264  * @brief Builds MAC LC Config
3265  *
3266  * @details
3267  *
3268  *    Function : BuildMacLCConfig
3269  *
3270  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
3271  *
3272  * @params[in] struct LogicalChannelConfig macLcConfig
3273  *
3274  * @return ROK     - success
3275  *         RFAILED - failure
3276  *
3277  * ****************************************************************/
3278 uint8_t BuildMacLCConfig(struct LogicalChannelConfig *macLcConfig)
3279 {
3280
3281    macLcConfig->ul_SpecificParameters = NULLP;
3282    DU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
3283    if(!macLcConfig->ul_SpecificParameters)
3284    {
3285       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3286       return RFAILED;
3287    }
3288
3289    macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
3290    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     PRIORTISIED_BIT_RATE;
3291    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     BUCKET_SIZE_DURATION;
3292    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
3293    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
3294    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
3295    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
3296
3297    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
3298    DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
3299    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
3300    {
3301       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3302       return RFAILED;
3303    }
3304    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
3305
3306    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
3307    DU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
3308    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
3309    {
3310       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3311       return RFAILED;
3312    }
3313    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
3314
3315    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
3316    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
3317    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
3318
3319    return ROK;
3320 }
3321
3322 /*******************************************************************
3323  *
3324  * @brief Builds RLC Bearer to Add/Mod list
3325  *
3326  * @details
3327  *
3328  *    Function :BuildRlcBearerToAddModList
3329  *
3330  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
3331  *
3332  * @params[in] rlc_BearerToAddModList
3333  *
3334  * @return ROK     - success
3335  *         RFAILED - failure
3336  *
3337  * ****************************************************************/
3338 uint8_t BuildRlcBearerToAddModList(struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
3339 {
3340    uint8_t                     idx, elementCnt;
3341
3342    elementCnt = 1;
3343    rlcBearerList->list.count = elementCnt;
3344    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
3345
3346    rlcBearerList->list.array = NULLP;
3347    DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
3348    if(!rlcBearerList->list.array)
3349    {
3350       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3351       return RFAILED;
3352    }
3353
3354    for(idx=0; idx<rlcBearerList->list.count; idx++)
3355    {
3356       rlcBearerList->list.array[idx] = NULLP;
3357       DU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
3358       if(!rlcBearerList->list.array[idx])
3359       {
3360          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3361          return RFAILED;
3362       }
3363    }
3364
3365    idx = 0;
3366    rlcBearerList->list.array[idx]->logicalChannelIdentity = SRB1_LCID;
3367
3368    DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, \
3369       sizeof(struct RLC_BearerConfig__servedRadioBearer));
3370    if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3371    {
3372       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3373       return RFAILED;
3374    }
3375
3376    rlcBearerList->list.array[idx]->servedRadioBearer->present = \
3377       RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
3378    rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = \
3379       SRB1_LCID;
3380
3381    rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3382    rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3383    DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3384    if(!rlcBearerList->list.array[idx]->rlc_Config)
3385    {
3386       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3387       return RFAILED;
3388    }
3389
3390    if(BuildRlcConfig(rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3391    {
3392       DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3393       return RFAILED;
3394    }
3395
3396    rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3397    DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, \
3398       sizeof(struct LogicalChannelConfig));
3399    if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3400    {
3401       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3402       return RFAILED;
3403    }
3404
3405    if(BuildMacLCConfig(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3406    {
3407       DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3408       return RFAILED;
3409    }
3410
3411    return ROK;
3412 }
3413
3414 /*******************************************************************
3415  *
3416  * @brief Build Control resource set to add/modify list
3417  *
3418  * @details
3419  *
3420  *    Function : BuildControlRSetToAddModList
3421  *
3422  *    Functionality: Build Control resource set to add/modify list
3423  *
3424  * @params[in]
3425  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3426  *
3427  * @return ROK     - success
3428  *         RFAILED - failure
3429  *
3430  * ****************************************************************/
3431    uint8_t BuildControlRSetToAddModList
3432 (
3433  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3434  )
3435 {
3436    uint8_t idx;
3437    uint8_t elementCnt;
3438    uint8_t numBytes, bitsUnused;
3439    struct ControlResourceSet *controlRSet;
3440    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3441    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3442
3443
3444    elementCnt = 1;
3445    controlRSetList->list.count = elementCnt;
3446    controlRSetList->list.size = \
3447                                 elementCnt * sizeof(struct ControlResourceSet *);
3448
3449    controlRSetList->list.array = NULLP;
3450    DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3451    if(!controlRSetList->list.array)
3452    {
3453       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3454       return RFAILED;
3455    }
3456
3457    for(idx = 0; idx < elementCnt; idx++)
3458    {
3459       controlRSetList->list.array[idx] = NULLP;
3460       DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3461       if(!controlRSetList->list.array[idx])
3462       {
3463          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3464          return RFAILED;
3465       }
3466    }
3467
3468    idx=0;
3469    controlRSet = controlRSetList->list.array[idx];
3470
3471    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3472
3473    /* size 6 bytes
3474     * 3 LSBs unsued
3475     * Bit string stored ff0000000000
3476     */
3477    numBytes = 6;
3478    bitsUnused = 3;
3479    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3480
3481    controlRSet->frequencyDomainResources.buf = NULLP;
3482    DU_ALLOC(controlRSet->frequencyDomainResources.buf, \
3483          controlRSet->frequencyDomainResources.size);
3484    if(!controlRSet->frequencyDomainResources.buf)
3485    {
3486       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3487       return RFAILED;
3488    }
3489
3490    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3491    coreset0EndPrb = CORESET0_END_PRB;
3492    coreset1StartPrb = coreset0EndPrb + 6;
3493    coreset1NumPrb = CORESET1_NUM_PRB;
3494    /* calculate the PRBs */
3495    freqDomRscAllocType0(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3496    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3497    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3498
3499    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3500    controlRSet->cce_REG_MappingType.present = \
3501                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3502
3503    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3504    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3505    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3506    controlRSet->tci_PresentInDCI = NULLP;
3507 #if 0
3508    uint8_t tciStateIdx;
3509
3510    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3511          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3512    if(!controlRset->tci_StatesPDCCH_ToAddList)
3513    {
3514       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3515       return RFAILED;
3516    }
3517
3518    elementCnt = 1;
3519    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3520    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3521    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3522          controlRset->tci_StatesPDCCH_ToAddList->list.size)
3523       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3524       {
3525          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3526          return RFAILED;
3527       }
3528
3529    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3530    {
3531       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3532       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3533       {
3534          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3535          return RFAILED;
3536       }
3537    }
3538
3539    tciStateIdx = 0;
3540    /* TODO */
3541    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3542
3543    DU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3544    if(!controlRset->tci_PresentInDCI)
3545    {
3546       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3547       return RFAILED;
3548    }
3549    /* TODO */
3550    *(controlRset->tci_PresentInDCI);
3551 #endif
3552
3553    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3554    DU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3555    if(!controlRSet->pdcch_DMRS_ScramblingID)
3556    {
3557       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3558       return RFAILED;
3559    }
3560    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3561
3562    return ROK;
3563 } /* End BuildControlRSetToAddModList */
3564
3565 /*******************************************************************
3566  *
3567  * @brief Build search space to add/modify list
3568  *
3569  * @details
3570  *
3571  *    Function : BuildSearchSpcToAddModList
3572  *
3573  *    Functionality: Build search space to add/modify list
3574  *
3575  * @params[in]
3576  * @return ROK     - success
3577  *         RFAILED - failure
3578  *
3579  * ****************************************************************/
3580    uint8_t BuildSearchSpcToAddModList
3581 (
3582  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
3583  )
3584 {
3585    uint8_t idx;
3586    uint8_t numBytes;
3587    uint8_t byteIdx;
3588    uint8_t bitsUnused;
3589    uint8_t elementCnt;
3590    struct SearchSpace *searchSpc;
3591
3592    elementCnt = 1;
3593    searchSpcList->list.count = elementCnt;
3594    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3595
3596    searchSpcList->list.array = NULLP;
3597    DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3598    if(!searchSpcList->list.array)
3599    {
3600       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3601       return RFAILED;
3602    }
3603
3604    for(idx = 0; idx < elementCnt; idx++)
3605    {
3606       searchSpcList->list.array[idx] = NULLP;
3607       DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3608       if(!searchSpcList->list.array[idx])
3609       {
3610          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3611          return RFAILED;
3612       }
3613    }
3614
3615    idx = 0;
3616    searchSpc = searchSpcList->list.array[idx];
3617
3618    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3619
3620    searchSpc->controlResourceSetId = NULLP;
3621    DU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3622    if(!searchSpc->controlResourceSetId)
3623    {
3624       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3625       return RFAILED;
3626    }
3627    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3628
3629    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3630    DU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
3631          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3632    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3633    {
3634       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3635       return RFAILED;
3636    }
3637    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
3638                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3639
3640    searchSpc->duration = NULLP;
3641    searchSpc->monitoringSymbolsWithinSlot = NULLP;
3642    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3643    if(!searchSpc->monitoringSymbolsWithinSlot)
3644    {
3645       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3646       return RFAILED;
3647    }
3648
3649    /* Values taken from reference logs :
3650     * size 2 bytes
3651     * 2 LSBs unsued
3652     * Bit string stores 8000
3653     */
3654    numBytes = 2;
3655    bitsUnused = 2;
3656
3657    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3658    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3659    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
3660          searchSpc->monitoringSymbolsWithinSlot->size);
3661    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3662    {
3663       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3664       return RFAILED;
3665    }
3666
3667    byteIdx = 0;
3668    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
3669                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3670    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3671    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3672
3673    searchSpc->nrofCandidates = NULLP;
3674    DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3675    if(!searchSpc->nrofCandidates)
3676    {
3677       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3678       return RFAILED;
3679    }
3680
3681    searchSpc->nrofCandidates->aggregationLevel1 = \
3682                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3683    searchSpc->nrofCandidates->aggregationLevel2 = \
3684                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3685    searchSpc->nrofCandidates->aggregationLevel4 = \
3686                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3687    searchSpc->nrofCandidates->aggregationLevel8 = \
3688                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3689    searchSpc->nrofCandidates->aggregationLevel16 = \
3690                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3691
3692    searchSpc->searchSpaceType = NULLP;
3693    DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3694    if(!searchSpc->searchSpaceType)
3695    {
3696       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3697       return RFAILED;
3698    }
3699
3700    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3701
3702    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3703    DU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
3704          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3705    if(!searchSpc->searchSpaceType->choice.ue_Specific)
3706    {
3707       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3708       return RFAILED;
3709    }
3710    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
3711                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3712
3713    return ROK;
3714 }/* End BuildSearchSpcToAddModList */
3715
3716 /*******************************************************************
3717  *
3718  * @brief Builds BWP DL dedicated PDCCH config
3719  *
3720  * @details
3721  *
3722  *    Function : BuildBWPDlDedPdcchCfg
3723  *
3724  *    Functionality: Builds BWP DL dedicated PDCCH config
3725  *
3726  * @params[in] struct PDCCH_Config *pdcchCfg
3727  *
3728  * @return ROK     - success
3729  *         RFAILED - failure
3730  *
3731  * ****************************************************************/
3732 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
3733 {
3734    pdcchCfg->controlResourceSetToAddModList = NULLP;
3735    DU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
3736          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3737    if(!pdcchCfg->controlResourceSetToAddModList)
3738    {
3739       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3740       return RFAILED;
3741    }
3742
3743    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
3744    {
3745       return RFAILED;
3746    }
3747
3748    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3749
3750    pdcchCfg->searchSpacesToAddModList = NULLP;
3751    DU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3752          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3753    if(!pdcchCfg->searchSpacesToAddModList)
3754    {
3755       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3756       return RFAILED;
3757    }
3758
3759    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3760    {
3761       return RFAILED;
3762    }
3763
3764    pdcchCfg->searchSpacesToReleaseList = NULLP;
3765    pdcchCfg->downlinkPreemption = NULLP;
3766    pdcchCfg->tpc_PUSCH = NULLP;
3767    pdcchCfg->tpc_PUCCH = NULLP;
3768    pdcchCfg->tpc_SRS = NULLP;
3769
3770    return ROK;
3771 }
3772
3773 /*******************************************************************
3774  *
3775  * @brief Builds DMRS DL PDSCH Mapping type A
3776  *
3777  * @details
3778  *
3779  *    Function : BuildDMRSDLPdschMapTypeA
3780  *
3781  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3782  *
3783  * @params[in]
3784  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3785  * @return ROK     - success
3786  *         RFAILED - failure
3787  *
3788  * ****************************************************************/
3789    uint8_t BuildDMRSDLPdschMapTypeA
3790 (
3791  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3792  )
3793 {
3794    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3795    dmrsDlCfg->choice.setup = NULLP;
3796    DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3797    if(!dmrsDlCfg->choice.setup)
3798    {
3799       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3800       return RFAILED;
3801    }
3802
3803    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3804    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3805    DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3806    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3807    {
3808       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3809       return RFAILED;
3810    }
3811    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3812
3813    dmrsDlCfg->choice.setup->maxLength = NULLP;
3814    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3815    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3816    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3817
3818    return ROK;
3819 }
3820
3821 /*******************************************************************
3822  *
3823  * @brief Builds TCI states to add/modify list
3824  *
3825  * @details
3826  *
3827  *    Function : BuildTCIStatesToAddModList
3828  *
3829  *    Functionality:Builds TCI states to add/modify list
3830  *
3831  * @params[in]
3832  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3833  *
3834  * @return ROK     - success
3835  *         RFAILED - failure
3836  *
3837  * ****************************************************************/
3838 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3839 {
3840    return ROK;
3841 }
3842
3843 /*******************************************************************
3844  *
3845  * @brief Builds PDSCH time domain allocation list
3846  *
3847  * @details
3848  *
3849  *    Function : BuildPdschTimeDomAllocList
3850  *
3851  *    Functionality: Builds PDSCH time domain allocation list
3852  *
3853  * @params[in]
3854  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3855  *
3856  * @return ROK     - success
3857  *         RFAILED - failure
3858  *
3859  * ****************************************************************/
3860    uint8_t BuildPdschTimeDomAllocList
3861 (
3862  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3863  )
3864 {
3865    uint8_t idx;
3866    uint8_t elementCnt;
3867    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3868
3869    timeDomAllocList->present = \
3870                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3871
3872    timeDomAllocList->choice.setup = NULLP;
3873    DU_ALLOC(timeDomAllocList->choice.setup, \
3874          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3875    if(!timeDomAllocList->choice.setup)
3876    {
3877       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3878       return RFAILED;
3879    }
3880
3881    elementCnt = 1;
3882    timeDomAllocList->choice.setup->list.count = elementCnt;
3883    timeDomAllocList->choice.setup->list.size = \
3884                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3885
3886    timeDomAllocList->choice.setup->list.array = NULLP;
3887    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3888          timeDomAllocList->choice.setup->list.size);
3889    if(!timeDomAllocList->choice.setup->list.array)
3890    {
3891       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3892       return RFAILED;
3893    }
3894
3895    for(idx = 0; idx < elementCnt; idx++)
3896    {
3897       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3898       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3899             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3900       if(!timeDomAllocList->choice.setup->list.array[idx])
3901       {
3902          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3903          return RFAILED;
3904       }
3905    }
3906
3907    idx = 0;
3908    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3909
3910    timeDomAlloc->k0 = NULLP;
3911    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3912    timeDomAlloc->startSymbolAndLength = \
3913                                         calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
3914
3915    return ROK;
3916 }
3917
3918 /*******************************************************************
3919  *
3920  * @brief Builds PDSCH PRB Bundling type
3921  *
3922  * @details
3923  *
3924  *    Function : BuildPdschPrbBundlingType
3925  *
3926  *    Functionality: Builds PDSCH PRB Bundling type
3927  *
3928  * @params[in]
3929  * struct PDSCH_Config__prb_BundlingType *prbBndlType
3930  *
3931  * @return ROK     - success
3932  *         RFAILED - failure
3933  *
3934  * ****************************************************************/
3935    uint8_t BuildPdschPrbBundlingType
3936 (
3937  struct PDSCH_Config__prb_BundlingType *prbBndlType
3938  )
3939 {
3940    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
3941
3942    prbBndlType->choice.staticBundling = NULLP;
3943    DU_ALLOC(prbBndlType->choice.staticBundling, \
3944          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
3945    if(!prbBndlType->choice.staticBundling)
3946    {
3947       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
3948       return RFAILED;
3949    }
3950    prbBndlType->choice.staticBundling->bundleSize = NULLP;
3951
3952    return ROK;
3953 }
3954
3955 /*******************************************************************
3956  *
3957  * @brief Builds BWP DL dedicated PDSCH config
3958  *
3959  * @details
3960  *
3961  *    Function : BuildBWPDlDedPdschCfg
3962  *
3963  *    Functionality: Builds BWP DL dedicated PDSCH config
3964  *
3965  * @params[in] struct PDSCH_Config *pdschCfg
3966  *
3967  * @return ROK     - success
3968  *         RFAILED - failure
3969  *
3970  * ****************************************************************/
3971 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
3972 {
3973    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
3974
3975    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
3976    DU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
3977          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
3978    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
3979    {
3980       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3981       return RFAILED;
3982    }
3983
3984    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
3985    {
3986       return RFAILED;
3987    }
3988
3989    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
3990    pdschCfg->tci_StatesToAddModList = NULLP;
3991    pdschCfg->tci_StatesToReleaseList = NULLP;
3992    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
3993 #if 0
3994    DU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
3995    if(!pdschCfg->tci_StatesToAddModList)
3996    {
3997       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3998       return RFAILED;
3999    }
4000    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
4001    {
4002       return RFAILED;
4003    }
4004 #endif
4005
4006    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
4007
4008    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
4009    DU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
4010          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
4011    if(!pdschCfg->pdsch_TimeDomainAllocationList)
4012    {
4013       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4014       return RFAILED;
4015    }
4016
4017    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
4018    {
4019       return RFAILED;
4020    }
4021
4022    pdschCfg->pdsch_AggregationFactor = NULLP;
4023    pdschCfg->rateMatchPatternToAddModList = NULLP;
4024    pdschCfg->rateMatchPatternToReleaseList = NULLP;
4025    pdschCfg->rateMatchPatternGroup1 = NULLP;
4026    pdschCfg->rateMatchPatternGroup2 = NULLP;
4027    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
4028    pdschCfg->mcs_Table = NULLP;
4029
4030    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
4031    DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
4032    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
4033    {
4034       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
4035       return RFAILED;
4036    }
4037    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
4038
4039    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
4040    {
4041       return RFAILED;
4042    }
4043
4044    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
4045    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
4046    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4047    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4048    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
4049    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
4050    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
4051
4052    return ROK;
4053 }
4054
4055 /*******************************************************************
4056  *
4057  * @brief Builds intitial DL BWP
4058  * @details
4059  *
4060  *    Function : BuildInitialDlBWP
4061  *
4062  *    Functionality: Builds intitial DL BWP in spCellCfgDed
4063  *
4064  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4065  *
4066  * @return ROK     - success
4067  *         RFAILED - failure
4068  *
4069  * ****************************************************************/
4070 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
4071 {
4072    dlBwp->pdcch_Config = NULLP;
4073    DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
4074    if(!dlBwp->pdcch_Config)
4075    {
4076       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4077       return RFAILED;
4078    }
4079    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
4080
4081    dlBwp->pdcch_Config->choice.setup = NULLP;
4082    DU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
4083    if(!dlBwp->pdcch_Config->choice.setup)
4084    {
4085       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4086       return RFAILED;
4087    }
4088    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
4089    {
4090       return RFAILED;
4091    }
4092
4093    dlBwp->pdsch_Config = NULLP;
4094    DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
4095    if(!dlBwp->pdsch_Config)
4096    {
4097       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4098       return RFAILED;
4099    }
4100    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
4101
4102    dlBwp->pdsch_Config->choice.setup = NULLP;
4103    DU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
4104    if(!dlBwp->pdsch_Config->choice.setup)
4105    {
4106       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4107       return RFAILED;
4108    }
4109
4110    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
4111    {
4112       return RFAILED;
4113    }
4114
4115    dlBwp->sps_Config = NULLP;
4116    dlBwp->radioLinkMonitoringConfig = NULLP;
4117    return ROK;
4118 }
4119
4120 /*******************************************************************
4121  *
4122  * @brief Builds DMRS UL Pusch Mapping type A
4123  *
4124  * @details
4125  *
4126  *    Function : BuildDMRSULPuschMapTypeA
4127  *
4128  *    Functionality: Builds DMRS UL Pusch Mapping type A
4129  *
4130  * @params[in]
4131  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4132  * @return ROK     - success
4133  *         RFAILED - failure
4134  *
4135  * ****************************************************************/
4136    uint8_t BuildDMRSULPuschMapTypeA
4137 (
4138  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4139  )
4140 {
4141    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
4142    dmrsUlCfg->choice.setup= NULLP;
4143    DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
4144    if(!dmrsUlCfg->choice.setup)
4145    {
4146       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4147       return RFAILED;
4148    }
4149
4150    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
4151    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
4152    DU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
4153    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4154    {
4155       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4156       return RFAILED;
4157    }
4158    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
4159
4160    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
4161    dmrsUlCfg->choice.setup->maxLength = NULLP;
4162    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
4163    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
4164          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4165    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4166    {
4167       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4168       return RFAILED;
4169    }
4170
4171    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
4172    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4173          sizeof(long));
4174    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
4175    {
4176       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4177       return RFAILED;
4178    }
4179    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
4180
4181    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
4182    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
4183    return ROK;
4184 }
4185
4186 /*******************************************************************
4187  *
4188  * @brief Build PUSCH time domain allocation list
4189  *
4190  * @details
4191  *
4192  *    Function : BuildPuschTimeDomAllocList
4193  *
4194  *    Functionality: Build PUSCH time domain allocation list
4195  *
4196  * @params[in]
4197  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4198  *
4199  * @return ROK     - success
4200  *         RFAILED - failure
4201  *
4202  * ****************************************************************/
4203    uint8_t BuildPuschTimeDomAllocList
4204 (
4205  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4206  )
4207 {
4208    uint8_t idx;
4209    uint8_t elementCnt;
4210    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
4211
4212    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
4213    timeDomAllocList->choice.setup = NULLP;
4214    DU_ALLOC(timeDomAllocList->choice.setup, \
4215          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4216    if(!timeDomAllocList->choice.setup)
4217    {
4218       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4219       return RFAILED;
4220    }
4221
4222    elementCnt = 1;
4223    timeDomAllocList->choice.setup->list.count = elementCnt;
4224    timeDomAllocList->choice.setup->list.size = \
4225                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
4226    timeDomAllocList->choice.setup->list.array = NULLP;
4227    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
4228          timeDomAllocList->choice.setup->list.size);
4229    if(!timeDomAllocList->choice.setup->list.array)
4230    {
4231       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4232       return RFAILED;
4233    }
4234
4235    for(idx = 0; idx < elementCnt; idx++)
4236    {
4237       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4238       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
4239             sizeof(PUSCH_TimeDomainResourceAllocation_t));
4240       if(!timeDomAllocList->choice.setup->list.array[idx])
4241       {
4242          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4243          return RFAILED;
4244       }
4245    }
4246
4247    idx = 0;
4248    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4249    DU_ALLOC(timeDomAlloc->k2, sizeof(long));
4250    if(!timeDomAlloc->k2)
4251    {
4252       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4253       return RFAILED;
4254    }
4255    *(timeDomAlloc->k2) = PUSCH_K2;
4256    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4257    timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
4258    return ROK;
4259 }
4260
4261 /*******************************************************************
4262  *
4263  * @brief Builds BWP UL dedicated PUSCH Config
4264  *
4265  * @details
4266  *
4267  *    Function : BuildBWPUlDedPuschCfg
4268  *
4269  *    Functionality:
4270  *      Builds BWP UL dedicated PUSCH Config
4271  *
4272  * @params[in] : PUSCH_Config_t *puschCfg
4273  *
4274  * @return ROK     - success
4275  *         RFAILED - failure
4276  *
4277  * ****************************************************************/
4278 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
4279 {
4280    puschCfg->dataScramblingIdentityPUSCH = NULLP;
4281    DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4282    if(!puschCfg->dataScramblingIdentityPUSCH)
4283    {
4284       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4285       return RFAILED;
4286    }
4287    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
4288
4289    puschCfg->txConfig = NULLP;
4290    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4291    DU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4292          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4293    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4294    {
4295       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4296       return RFAILED;
4297    }
4298
4299    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4300    {
4301       return RFAILED;
4302    }
4303
4304    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4305    puschCfg->pusch_PowerControl = NULLP;
4306    puschCfg->frequencyHopping = NULLP;
4307    puschCfg->frequencyHoppingOffsetLists = NULLP;
4308    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4309
4310    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4311    DU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
4312          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4313    if(!puschCfg->pusch_TimeDomainAllocationList)
4314    {
4315       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4316       return RFAILED;
4317    }
4318
4319    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
4320    {
4321       return RFAILED;
4322    }
4323
4324    puschCfg->pusch_AggregationFactor = NULLP;
4325    puschCfg->mcs_Table = NULLP;
4326    puschCfg->mcs_TableTransformPrecoder = NULLP;
4327    puschCfg->transformPrecoder = NULLP;
4328    DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4329    if(!puschCfg->transformPrecoder)
4330    {
4331       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4332       return RFAILED;
4333    }
4334    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4335
4336    puschCfg->codebookSubset = NULLP;
4337    puschCfg->maxRank = NULLP;
4338    puschCfg->rbg_Size = NULLP;
4339    puschCfg->uci_OnPUSCH = NULLP;
4340    puschCfg->tp_pi2BPSK = NULLP;
4341
4342    return ROK;
4343 }
4344
4345 /*******************************************************************
4346  *
4347  * @brief Fills SRS resource to add/modify list
4348  *
4349  * @details
4350  *
4351  *    Function : BuildSrsRsrcAddModList
4352  *
4353  *    Functionality: Fills SRS resource to add/modify list
4354  *
4355  * @params[in]
4356  * @return ROK     - success
4357  *         RFAILED - failure
4358  *
4359  * ****************************************************************/
4360 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
4361 {
4362    uint8_t   elementCnt;
4363    uint8_t   rsrcIdx;
4364
4365    elementCnt = 1;
4366    resourceList->list.count = elementCnt;
4367    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
4368    resourceList->list.array = NULLP;
4369    DU_ALLOC(resourceList->list.array, resourceList->list.size);
4370    if(!resourceList->list.array)
4371    {
4372       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4373       return RFAILED;
4374    }
4375
4376    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4377    {
4378       DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4379       if(!resourceList->list.array[rsrcIdx])
4380       {
4381          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4382          return RFAILED;
4383       }
4384    }
4385
4386    rsrcIdx = 0;
4387    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
4388    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
4389    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
4390
4391    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
4392    DU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
4393          sizeof(struct SRS_Resource__transmissionComb__n2));
4394    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
4395    {
4396       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4397       return RFAILED;
4398    }
4399    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
4400       = SRS_COMB_OFFSET_N2;
4401    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
4402       = SRS_CYCLIC_SHIFT_N2;
4403
4404    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
4405                                                                       PUSCH_START_SYMBOL;
4406    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
4407                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
4408    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
4409                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
4410
4411    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
4412    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
4413    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
4414    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
4415    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
4416    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
4417                                                                SRS_Resource__groupOrSequenceHopping_neither;
4418
4419    /* Setting resource type to aperiodic for intergration purposes */
4420    resourceList->list.array[rsrcIdx]->resourceType.present = \
4421                                                              SRS_Resource__resourceType_PR_aperiodic;
4422    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
4423    DU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
4424          sizeof(struct SRS_Resource__resourceType__aperiodic));
4425    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
4426    {
4427       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4428       return RFAILED;
4429    }
4430    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
4431
4432    return ROK;
4433 }
4434
4435 /*******************************************************************
4436  *
4437  * @brief Build SRS resource set Add/mod list
4438  *
4439  * @details
4440  *
4441  *    Function : BuildSrsRsrcSetAddModList
4442  *
4443  *    Functionality: Build SRS resource set Add/mod list
4444  *
4445  * @params[in]
4446  * @return ROK     - success
4447  *         RFAILED - failure
4448  *
4449  * ****************************************************************/
4450    uint8_t BuildSrsRsrcSetAddModList
4451 (
4452  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
4453  )
4454 {
4455    uint8_t  elementCnt;
4456    uint8_t  rSetIdx;
4457    uint8_t  rsrcIdx;
4458    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
4459
4460    elementCnt = 1;
4461    rsrcSetList->list.count = elementCnt;
4462    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
4463    rsrcSetList->list.array = NULLP;
4464    DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
4465    if(!rsrcSetList->list.array)
4466    {
4467       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4468       return RFAILED;
4469    }
4470
4471    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4472    {
4473       DU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4474       if(!rsrcSetList->list.array[rSetIdx])
4475       {
4476          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4477          return RFAILED;
4478       }
4479    }
4480
4481    rSetIdx = 0;
4482    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
4483
4484    /* Fill Resource Id list in resource set */
4485    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
4486    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4487          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4488    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4489    {
4490       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4491       return RFAILED;
4492    }
4493
4494    elementCnt = 1;
4495    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4496    rsrcIdList->list.count = elementCnt;
4497    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
4498    rsrcIdList->list.array = NULLP;
4499    DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
4500    if(!rsrcIdList->list.array)
4501    {
4502       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4503       return RFAILED;
4504    }
4505
4506    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4507    {
4508       DU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4509       if(!rsrcIdList->list.array[rsrcIdx])
4510       {
4511          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4512          return RFAILED;
4513       }
4514    }
4515
4516    rsrcIdx = 0;
4517    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
4518
4519    /* Fill resource type */
4520    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
4521                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
4522
4523    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
4524    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4525          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4526    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
4527    {
4528       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4529       return RFAILED;
4530    }
4531    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
4532       = APERIODIC_SRS_RESRC_TRIGGER;
4533
4534    /* TODO : Fill values for below IEs as expected by Viavi */
4535    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
4536    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
4537
4538
4539    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
4540    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
4541    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
4542    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
4543    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
4544
4545    return ROK;
4546 }
4547
4548 /*******************************************************************
4549  *
4550  * @brief Builds BWP UL dedicated SRS Config
4551  *
4552  * @details
4553  *
4554  *    Function : BuildBWPUlDedSrsCfg
4555  *
4556  *    Functionality: Builds BWP UL dedicated SRS Config
4557  *
4558  * @params[in] SRS Config
4559  * @return ROK     - success
4560  *         RFAILED - failure
4561  *
4562  * ****************************************************************/
4563 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
4564 {
4565    srsCfg->srs_ResourceSetToReleaseList = NULLP;
4566    srsCfg->srs_ResourceSetToAddModList = NULLP;
4567    DU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
4568          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4569    if(!srsCfg->srs_ResourceSetToAddModList)
4570    {
4571       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4572       return RFAILED;
4573    }
4574    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
4575    {
4576       return RFAILED;
4577    }
4578
4579    srsCfg->srs_ResourceToReleaseList = NULLP;
4580
4581    /* Resource to Add/Modify list */
4582    srsCfg->srs_ResourceToAddModList = NULLP;
4583    DU_ALLOC(srsCfg->srs_ResourceToAddModList, \
4584          sizeof(struct SRS_Config__srs_ResourceToAddModList));
4585    if(!srsCfg->srs_ResourceToAddModList)
4586    {
4587       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4588       return RFAILED;
4589    }
4590
4591    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
4592    {
4593       return RFAILED;
4594    }
4595
4596    srsCfg->tpc_Accumulation = NULLP;
4597
4598    return ROK;
4599 }
4600
4601
4602
4603 /*******************************************************************
4604  *
4605  * @brief Builds Pusch Serving cell Config
4606  *
4607  * @details
4608  *
4609  *    Function : BuildPuschSrvCellCfg
4610  *
4611  *    Functionality: Builds Pusch Serving cell Config
4612  *
4613  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
4614  *
4615  * @return ROK     - success
4616  *         RFAILED - failure
4617  *
4618  * ****************************************************************/
4619 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
4620 {
4621    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
4622    puschCfg->choice.setup = NULLP;
4623    DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4624    if(!puschCfg->choice.setup)
4625    {
4626       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4627       return RFAILED;
4628    }
4629
4630    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4631    puschCfg->choice.setup->rateMatching = NULLP;
4632    puschCfg->choice.setup->xOverhead = NULLP;
4633    puschCfg->choice.setup->ext1 = NULLP;
4634    DU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
4635    if(!puschCfg->choice.setup->ext1)
4636    {
4637       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4638       return RFAILED;
4639    }
4640
4641    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
4642    DU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
4643    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
4644    {
4645       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4646       return RFAILED;
4647    }
4648    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
4649
4650    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
4651    DU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
4652    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
4653    {
4654       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4655       return RFAILED;
4656    }
4657    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
4658    return ROK;
4659 }
4660
4661 /*******************************************************************
4662  *
4663  * @brief Builds inital UL BWP
4664  *
4665  * @details
4666  *
4667  *    Function : BuildInitialUlBWP
4668  *
4669  *    Functionality: Builds initial UL BWP
4670  *
4671  * @params[in] BWP_UplinkDedicated_t *ulBwp
4672  * @return ROK     - success
4673  *         RFAILED - failure
4674  *
4675  * ****************************************************************/
4676 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4677 {
4678    ulBwp->pucch_Config = NULLP;
4679
4680    /* Fill BWP UL dedicated PUSCH config */
4681    ulBwp->pusch_Config = NULLP;
4682    DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4683    if(!ulBwp->pusch_Config)
4684    {
4685       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4686       return RFAILED;
4687    }
4688
4689    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
4690    ulBwp->pusch_Config->choice.setup = NULLP;
4691    DU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4692    if(!ulBwp->pusch_Config->choice.setup)
4693    {
4694       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4695       return RFAILED;
4696    }
4697
4698    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
4699    {
4700       return RFAILED;
4701    }
4702
4703    ulBwp->configuredGrantConfig = NULLP;
4704
4705    /* Fill BPW UL dedicated SRS config */
4706    ulBwp->srs_Config = NULLP;
4707    DU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4708    if(!ulBwp->srs_Config)
4709    {
4710       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4711       return RFAILED;
4712    }
4713
4714    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
4715    ulBwp->srs_Config->choice.setup = NULLP;
4716    DU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4717    if(!ulBwp->srs_Config->choice.setup)
4718    {
4719       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4720       return RFAILED;
4721    }
4722
4723    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
4724    {
4725       return RFAILED;
4726    }
4727
4728    ulBwp->beamFailureRecoveryConfig = NULLP;
4729
4730    return ROK;
4731 }
4732
4733 /*******************************************************************
4734  *
4735  * @brief Builds UL config
4736  * @details
4737  *
4738  *    Function : BuildUlCfg
4739  *
4740  *    Functionality: Builds UL config in spCellCfgDed
4741  *
4742  * @params[in] UplinkConfig_t *ulCfg
4743  *
4744  * @return ROK     - success
4745  *         RFAILED - failure
4746  *
4747  * ****************************************************************/
4748 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
4749 {
4750    ulCfg->initialUplinkBWP = NULLP;
4751    DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4752    if(!ulCfg->initialUplinkBWP)
4753    {
4754       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4755       return RFAILED;
4756    }
4757
4758    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
4759    {
4760       return RFAILED;
4761    }
4762
4763    ulCfg->uplinkBWP_ToReleaseList = NULLP;
4764    ulCfg->uplinkBWP_ToAddModList = NULLP;
4765    ulCfg->firstActiveUplinkBWP_Id = NULLP;
4766    DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4767    if(!ulCfg->firstActiveUplinkBWP_Id)
4768    {
4769       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4770       return RFAILED;
4771    }
4772    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
4773
4774    ulCfg->pusch_ServingCellConfig = NULLP;
4775    DU_ALLOC(ulCfg->pusch_ServingCellConfig, \
4776          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4777    if(!ulCfg->pusch_ServingCellConfig)
4778    {
4779       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4780       return RFAILED;
4781    }
4782
4783    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
4784    {
4785       return RFAILED;
4786    }
4787
4788    ulCfg->carrierSwitching = NULLP;
4789    ulCfg->ext1 = NULLP;
4790    return ROK;
4791 }
4792
4793 /*******************************************************************
4794  *
4795  * @brief Builds PDSCH serving cell config
4796  * @details
4797  *
4798  *    Function : BuildPdschSrvCellCfg
4799  *
4800  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
4801  *
4802  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
4803  *
4804  * @return ROK     - success
4805  *         RFAILED - failure
4806  *
4807  * ****************************************************************/
4808 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
4809 {
4810    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
4811    pdschCfg->choice.setup = NULLP;
4812    DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
4813    if(!pdschCfg->choice.setup)
4814    {
4815       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4816       return RFAILED;
4817    }
4818
4819    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4820    pdschCfg->choice.setup->xOverhead = NULLP;
4821    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
4822    DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
4823    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
4824    {
4825       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4826       return RFAILED;
4827    }
4828    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
4829    pdschCfg->choice.setup->pucch_Cell = NULLP;
4830    pdschCfg->choice.setup->ext1 = NULLP;
4831
4832    return ROK;
4833 }
4834
4835 /*******************************************************************
4836  *
4837  * @brief Builds CSI Meas config
4838  * @details
4839  *
4840  *    Function : BuildCsiMeasCfg
4841  *
4842  *    Functionality: Builds CSI Meas config in spCellCfgDed
4843  *
4844  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
4845  *
4846  * @return ROK     - success
4847  *         RFAILED - failure
4848  *
4849  * ****************************************************************/
4850 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
4851 {
4852
4853    return ROK;
4854 }
4855
4856 /*******************************************************************
4857  *
4858  * @brief Builds Spcell config dedicated
4859  * @details
4860  *
4861  *    Function : BuildSpCellCfgDed
4862  *
4863  *    Functionality: Builds sp cell config dedicated in spCellCfg
4864  *
4865  * @params[in] ServingCellConfig_t srvCellCfg
4866  *
4867  * @return ROK     - success
4868  *         RFAILED - failure
4869  *
4870  * ****************************************************************/
4871 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
4872 {
4873    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
4874    DU_ALLOC(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
4875    if(!srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
4876    {
4877       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4878       return RFAILED;
4879    }
4880
4881    srvCellCfg->initialDownlinkBWP = NULLP;
4882    DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
4883    if(!srvCellCfg->initialDownlinkBWP)
4884    {
4885       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4886       return RFAILED;
4887    }
4888
4889    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
4890    {
4891       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
4892       return RFAILED;
4893    }
4894    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
4895    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
4896
4897    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
4898    DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
4899    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
4900    {
4901       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4902       return RFAILED;
4903    }
4904    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4905
4906    srvCellCfg->bwp_InactivityTimer = NULLP;
4907
4908    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
4909    DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
4910    if(!srvCellCfg->defaultDownlinkBWP_Id)
4911    {
4912       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4913       return RFAILED;
4914    }
4915    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4916
4917    srvCellCfg->uplinkConfig = NULLP;
4918    DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
4919    if(!srvCellCfg->uplinkConfig)
4920    {
4921       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4922       return RFAILED;
4923    }
4924
4925    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
4926    {
4927       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
4928       return RFAILED;
4929    }
4930    srvCellCfg->supplementaryUplink = NULLP;
4931    srvCellCfg->pdcch_ServingCellConfig = NULLP;
4932
4933    srvCellCfg->pdsch_ServingCellConfig = NULLP;
4934    DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
4935    if(!srvCellCfg->pdsch_ServingCellConfig)
4936    {
4937       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4938       return RFAILED;
4939    }
4940
4941    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
4942    {
4943       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
4944       return RFAILED;
4945    }
4946
4947    srvCellCfg->csi_MeasConfig = NULLP;
4948 #if 0
4949    DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
4950       if(!srvCellCfg->csi_MeasConfig)
4951       {
4952          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4953          return RFAILED;
4954       }
4955
4956    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
4957    {
4958       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
4959       return RFAILED;
4960    }
4961 #endif
4962    srvCellCfg->sCellDeactivationTimer = NULLP;
4963    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
4964    srvCellCfg->tag_Id = TAG_ID;
4965    srvCellCfg->dummy = NULLP;
4966    srvCellCfg->pathlossReferenceLinking = NULLP;
4967    srvCellCfg->servingCellMO = NULLP;
4968    srvCellCfg->ext1 = NULLP;
4969
4970    return ROK;
4971 }
4972 /*******************************************************************
4973  *
4974  * @brief Builds Spcell config
4975  *
4976  * @details
4977  *
4978  *    Function : BuildSpCellCfg
4979  *
4980  *    Functionality: Builds sp cell config in DuToCuRrcContainer
4981  *
4982  * @params[in] SpCellConfig_t spCellCfg
4983  *
4984  * @return ROK     - success
4985  *         RFAILED - failure
4986  *
4987  * ****************************************************************/
4988 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
4989 {
4990
4991    spCellCfg->servCellIndex = NULLP;
4992    DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
4993    if(!spCellCfg->servCellIndex)
4994    {
4995       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4996       return RFAILED;
4997    }
4998    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
4999
5000    spCellCfg->reconfigurationWithSync = NULLP;
5001    spCellCfg->rlf_TimersAndConstants = NULLP;
5002    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
5003    DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5004    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
5005    {
5006       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5007       return RFAILED;
5008    }
5009    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
5010
5011    spCellCfg->spCellConfigDedicated = NULLP;
5012    DU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5013    if(!spCellCfg->spCellConfigDedicated)
5014    {
5015       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5016       return RFAILED;
5017    }
5018    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
5019    {
5020       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
5021       return RFAILED;
5022    }
5023    return ROK;
5024 }
5025 /*******************************************************************
5026  *
5027  * @brief Builds Phy cell group config
5028  *
5029  * @details
5030  *
5031  *    Function : BuildPhyCellGrpCfg
5032  *
5033  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
5034  *
5035  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
5036  *
5037  * @return ROK     - success
5038  *         RFAILED - failure
5039  *
5040  * ****************************************************************/
5041 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
5042 {
5043    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
5044    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
5045
5046    phyCellGrpCfg->p_NR_FR1 = NULLP;
5047    DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5048    if(!phyCellGrpCfg->p_NR_FR1)
5049    {
5050       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
5051       return RFAILED;
5052    }
5053    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
5054    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
5055    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
5056    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
5057    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
5058    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
5059    phyCellGrpCfg->cs_RNTI = NULLP;
5060    phyCellGrpCfg->ext1 = NULLP;
5061    phyCellGrpCfg->ext2 = NULLP;
5062
5063    return ROK;
5064 }
5065 /*******************************************************************
5066  *
5067  * @brief Builds Mac cell group config
5068  *
5069  * @details
5070  *
5071  *    Function : BuildMacCellGrpCfg
5072  *
5073  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
5074  *
5075  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
5076  *
5077  * @return ROK     - success
5078  *         RFAILED - failure
5079  *
5080  * ****************************************************************/
5081 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
5082 {
5083    macCellGrpCfg->drx_Config = NULLP;
5084    macCellGrpCfg->schedulingRequestConfig = NULLP;
5085    DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5086    if(!macCellGrpCfg->schedulingRequestConfig)
5087    {
5088       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5089       return RFAILED;
5090    }
5091
5092    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
5093    {
5094       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
5095       return RFAILED;
5096    }
5097
5098    macCellGrpCfg->bsr_Config = NULLP;
5099    DU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5100    if(!macCellGrpCfg->bsr_Config)
5101    {
5102       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5103       return RFAILED;
5104    }
5105
5106    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
5107    {
5108       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
5109       return RFAILED;
5110    }
5111
5112    macCellGrpCfg->tag_Config = NULLP;
5113    DU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
5114    if(!macCellGrpCfg->tag_Config)
5115    {
5116       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5117       return RFAILED;
5118    }
5119
5120    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
5121    {
5122       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
5123       return RFAILED;
5124    }
5125
5126    macCellGrpCfg->phr_Config = NULLP;
5127    DU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
5128    if(!macCellGrpCfg->phr_Config)
5129    {
5130       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5131       return RFAILED;
5132    }
5133
5134    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
5135    {
5136       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
5137       return RFAILED;
5138    }
5139
5140    macCellGrpCfg->skipUplinkTxDynamic = false;
5141    macCellGrpCfg->ext1 = NULLP;
5142
5143    return ROK;
5144 }
5145 /*******************************************************************
5146  *
5147  * @brief Frees memeory allocated for SearchSpcToAddModList
5148  *
5149  * @details
5150  *
5151  *    Function : FreeSearchSpcToAddModList
5152  *
5153  *    Functionality: Deallocating memory of SearchSpcToAddModList
5154  *
5155  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
5156  *
5157  * @return void
5158  *
5159  4221 * ****************************************************************/
5160 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
5161 {
5162    uint8_t idx1=0;
5163    uint8_t idx2=0;
5164    struct  SearchSpace *searchSpc=NULLP;
5165
5166    if(searchSpcList->list.array)
5167    {
5168       if(searchSpcList->list.array[idx2])
5169       {
5170          searchSpc = searchSpcList->list.array[idx2];
5171          if(searchSpc->controlResourceSetId)
5172          {
5173             if(searchSpc->monitoringSlotPeriodicityAndOffset)
5174             {
5175                if(searchSpc->monitoringSymbolsWithinSlot)
5176                {
5177                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
5178                   {
5179                      if(searchSpc->nrofCandidates)
5180                      {
5181                         if(searchSpc->searchSpaceType)
5182                         {
5183                            DU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
5184                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
5185                            DU_FREE(searchSpc->searchSpaceType, sizeof(struct
5186                                     SearchSpace__searchSpaceType));
5187                         }
5188                         DU_FREE(searchSpc->nrofCandidates,
5189                               sizeof(struct SearchSpace__nrofCandidates));
5190                      }
5191                      DU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
5192                            searchSpc->monitoringSymbolsWithinSlot->size);
5193                   }
5194                   DU_FREE(searchSpc->monitoringSymbolsWithinSlot,
5195                         sizeof(BIT_STRING_t));
5196                }
5197                DU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
5198                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
5199             }
5200             DU_FREE(searchSpc->controlResourceSetId,
5201                   sizeof(ControlResourceSetId_t));
5202          }
5203       }
5204       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
5205       {
5206          DU_FREE(searchSpcList->list.array[idx1],
5207                sizeof(struct SearchSpace));
5208       }
5209       DU_FREE(searchSpcList->list.array,searchSpcList->list.size);
5210    }
5211 }
5212 /*******************************************************************
5213  *
5214  * @brief Frees memory allocated for PdschTimeDomAllocList
5215  *
5216  * @details
5217  *
5218  *    Function : FreePdschTimeDomAllocList
5219  *
5220  *    Functionality: Deallocating memory of PdschTimeDomAllocList
5221  *
5222  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
5223  *
5224  * @return void
5225  *
5226  4221 * ****************************************************************/
5227 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
5228 {
5229    uint8_t idx1=0;
5230
5231    if(timeDomAllocList->choice.setup)
5232    {
5233       if(timeDomAllocList->choice.setup->list.array)
5234       {
5235          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
5236          {
5237             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
5238                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
5239          }
5240          DU_FREE(timeDomAllocList->choice.setup->list.array, \
5241                timeDomAllocList->choice.setup->list.size);
5242       }
5243       DU_FREE(timeDomAllocList->choice.setup,\
5244             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
5245    }
5246 }
5247 /*******************************************************************
5248  *
5249  * @brief Frees memory allocated for PuschTimeDomAllocList
5250  *
5251  *@details
5252  *
5253  *    Function : FreePuschTimeDomAllocList
5254  *
5255  *    Functionality: Deallocating memory of PuschTimeDomAllocList
5256  *
5257  * @params[in] PUSCH_Config_t *puschCfg
5258  *
5259  * @return void
5260  *
5261  * ****************************************************************/
5262 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
5263 {
5264    uint8_t idx1=0;
5265    uint8_t idx2=0;
5266    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
5267
5268    if(puschCfg->pusch_TimeDomainAllocationList)
5269    {
5270       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
5271       if(timeDomAllocList_t->choice.setup)
5272       {
5273          if(timeDomAllocList_t->choice.setup->list.array)
5274          {
5275             DU_FREE(timeDomAllocList_t->choice.setup->list.array[idx2]->k2, sizeof(long));
5276             for(idx1 = 0; idx1<timeDomAllocList_t->choice.setup->list.count; idx1++)
5277             {
5278                DU_FREE(timeDomAllocList_t->choice.setup->list.array[idx1],\
5279                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
5280             }
5281             DU_FREE(timeDomAllocList_t->choice.setup->list.array, \
5282                   timeDomAllocList_t->choice.setup->list.size);
5283          }
5284          DU_FREE(timeDomAllocList_t->choice.setup, \
5285                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
5286       }
5287       DU_FREE(puschCfg->transformPrecoder, sizeof(long));
5288       DU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
5289             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
5290    }
5291
5292 }
5293 /*******************************************************************
5294  *
5295  * @brief Frees memory allocated for InitialUlBWP
5296  *
5297  * @details
5298  *
5299  *    Function : FreeInitialUlBWP
5300  *
5301  *    Functionality: Deallocating memory of InitialUlBWP
5302  *
5303  * @params[in] BWP_UplinkDedicated_t *ulBwp
5304  *
5305  * @return void
5306  *
5307  * ****************************************************************/
5308 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5309 {
5310    uint8_t  rSetIdx, rsrcIdx;
5311    SRS_Config_t   *srsCfg = NULLP;
5312    PUSCH_Config_t *puschCfg = NULLP;
5313    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
5314    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
5315    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
5316    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
5317
5318    if(ulBwp->pusch_Config)
5319    {
5320       if(ulBwp->pusch_Config->choice.setup)
5321       {
5322          puschCfg=ulBwp->pusch_Config->choice.setup;
5323          if(puschCfg->dataScramblingIdentityPUSCH)
5324          {
5325             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
5326             {
5327                FreePuschTimeDomAllocList(puschCfg);
5328                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
5329                if(dmrsUlCfg->choice.setup)
5330                {
5331                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
5332                   {
5333                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
5334                      {
5335                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
5336                               sizeof(long));
5337                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
5338                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
5339                      }
5340                      DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
5341                            sizeof(long));
5342                   }
5343                   DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
5344                }
5345                DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
5346                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
5347             }
5348             DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
5349          }
5350          DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5351       }
5352       DU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5353
5354       /* Free SRS-Config */
5355       if(ulBwp->srs_Config)
5356       {
5357          if(ulBwp->srs_Config->choice.setup)
5358          {
5359             srsCfg = ulBwp->srs_Config->choice.setup;
5360
5361             /* Free Resource Set to add/mod list */
5362             if(srsCfg->srs_ResourceSetToAddModList)
5363             {
5364                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
5365                if(rsrcSetList->list.array)
5366                {
5367                   rSetIdx = 0;
5368
5369                   /* Free SRS resource Id list in this SRS resource set */
5370                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5371                   {
5372                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5373
5374                      if(rsrcIdList->list.array)
5375                      {
5376                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5377                         {
5378                            DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5379                         }
5380                         DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
5381                      }
5382                      DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5383                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5384                   }
5385
5386                   /* Free resource type info for this SRS resource set */
5387                   DU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5388                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5389
5390                   /* Free memory for each resource set */
5391                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5392                   {
5393                      DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5394                   }
5395                   DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
5396                }
5397                DU_FREE(srsCfg->srs_ResourceSetToAddModList, \
5398                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5399             }
5400
5401             /* Free resource to add/modd list */
5402             if(srsCfg->srs_ResourceToAddModList)
5403             {
5404                resourceList = srsCfg->srs_ResourceToAddModList;
5405                if(resourceList->list.array)
5406                {
5407                   rsrcIdx = 0;
5408                   DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
5409                         sizeof(struct SRS_Resource__transmissionComb__n2));
5410                   DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
5411                         sizeof(struct SRS_Resource__resourceType__aperiodic));
5412
5413                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5414                   {
5415                      DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5416                   }
5417                   DU_FREE(resourceList->list.array, resourceList->list.size);
5418                }
5419                DU_FREE(srsCfg->srs_ResourceToAddModList, \
5420                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
5421             }
5422
5423             DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5424          }
5425          DU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5426       }
5427    }
5428 }
5429 /*******************************************************************
5430  *
5431  * @brief Frees memory allocated for initialUplinkBWP
5432  *
5433  * @details
5434  *
5435  *    Function : FreeinitialUplinkBWP
5436  *
5437  *    Functionality: Deallocating memory of initialUplinkBWP
5438  *
5439  * @params[in] UplinkConfig_t *ulCfg
5440  *
5441  * @return void
5442  *
5443  *
5444  * ****************************************************************/
5445 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
5446 {
5447    BWP_UplinkDedicated_t *ulBwp=NULLP;
5448    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
5449
5450    if(ulCfg->initialUplinkBWP)
5451    {
5452       ulBwp=ulCfg->initialUplinkBWP;
5453       if(ulCfg->firstActiveUplinkBWP_Id)
5454       {
5455          if(ulCfg->pusch_ServingCellConfig)
5456          {
5457             puschCfg=ulCfg->pusch_ServingCellConfig;
5458             if(puschCfg->choice.setup)
5459             {
5460                if(puschCfg->choice.setup->ext1)
5461                {
5462                   DU_FREE(puschCfg->choice.setup->ext1->\
5463                         processingType2Enabled,sizeof(BOOLEAN_t));
5464                   DU_FREE(puschCfg->choice.setup->ext1->\
5465                         maxMIMO_Layers,sizeof(long));
5466                   DU_FREE(puschCfg->choice.setup->ext1, \
5467                         sizeof(struct PUSCH_ServingCellConfig__ext1));
5468                }
5469                DU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5470             }
5471             DU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5472          }
5473          DU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5474       }
5475       FreeInitialUlBWP(ulBwp);
5476       DU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5477    }
5478 }
5479 /*******************************************************************
5480  *
5481  * @brief Frees emmory allocated for BWPDlDedPdschCfg
5482  *
5483  * @details
5484  *
5485  *    Function : FreeBWPDlDedPdschCfg
5486  *
5487  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
5488  *
5489  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5490  *
5491  * @return void
5492  *
5493  *
5494  * ****************************************************************/
5495 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
5496 {
5497    struct PDSCH_Config *pdschCfg=NULLP;
5498    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
5499    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
5500    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
5501
5502    if(dlBwp->pdsch_Config->choice.setup)
5503    {
5504       pdschCfg=dlBwp->pdsch_Config->choice.setup;
5505       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
5506       {
5507          if(pdschCfg->pdsch_TimeDomainAllocationList)
5508          {
5509             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
5510             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
5511             {
5512                prbBndlType=&pdschCfg->prb_BundlingType;
5513                DU_FREE(prbBndlType->choice.staticBundling,\
5514                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
5515                DU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
5516             }
5517             FreePdschTimeDomAllocList(timeDomAllocList);
5518             DU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
5519                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
5520          }
5521          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
5522          if(dmrsDlCfg->choice.setup)
5523          {
5524             DU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
5525                   sizeof(long));
5526             DU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
5527          }
5528          DU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
5529                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
5530       }
5531       DU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
5532    }
5533 }
5534 /*******************************************************************
5535  *
5536  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
5537  *
5538  * @details
5539  *
5540  *    Function : FreeBWPDlDedPdcchCfg
5541  *
5542  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
5543  *
5544  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5545  *
5546  * @return void
5547  *
5548  *
5549  * ****************************************************************/
5550 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
5551 {
5552    uint8_t idx1=0;
5553    uint8_t idx2=0;
5554    struct PDCCH_Config *pdcchCfg=NULLP;
5555    struct ControlResourceSet *controlRSet=NULLP;
5556    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
5557
5558    if(dlBwp->pdcch_Config->choice.setup)
5559    {
5560       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
5561       if(pdcchCfg->controlResourceSetToAddModList)
5562       {
5563          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
5564          if(controlRSetList->list.array)
5565          {
5566             controlRSet = controlRSetList->list.array[idx2];
5567             if(controlRSet)
5568             {
5569                if(controlRSet->frequencyDomainResources.buf)
5570                {
5571                   if(controlRSet->pdcch_DMRS_ScramblingID)
5572                   {
5573                      if(pdcchCfg->searchSpacesToAddModList)
5574                      {
5575                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
5576                         DU_FREE(pdcchCfg->searchSpacesToAddModList, \
5577                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
5578                      }
5579                      DU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
5580                   }
5581                   DU_FREE(controlRSet->frequencyDomainResources.buf, \
5582                         controlRSet->frequencyDomainResources.size);
5583                }
5584             }
5585             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
5586             {
5587                DU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
5588             }
5589             DU_FREE(controlRSetList->list.array, controlRSetList->list.size);
5590          }
5591          DU_FREE(pdcchCfg->controlResourceSetToAddModList, \
5592                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
5593       }
5594       DU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
5595    }
5596 }
5597
5598 /*******************************************************************
5599  *
5600  * @brief Frees emmory allocated for DUToCURRCContainer
5601  *
5602  * @details
5603  *
5604  *    Function : FreeMemDuToCuRrcCont
5605  *
5606  *    Functionality: Deallocating memory of DuToCuRrcContainer
5607  *
5608  * @params[in] DuToCuRRCContainer, DuToCuRRCContainer
5609  *
5610  * @return ROK     - success
5611  *         RFAILED - failure
5612  *
5613  * ****************************************************************/
5614 uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg)
5615 {
5616    uint8_t idx=0;
5617    SpCellConfig_t *spCellCfg=NULLP;
5618    ServingCellConfig_t *srvCellCfg=NULLP;
5619    BWP_DownlinkDedicated_t *dlBwp=NULLP;
5620    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
5621    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
5622    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
5623    struct RLC_Config *rlcConfig=NULLP;
5624    struct LogicalChannelConfig *macLcConfig=NULLP;
5625    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
5626    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
5627    struct TAG_Config *tagConfig=NULLP;
5628    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
5629    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
5630    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
5631
5632    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
5633    if(rlcBearerList)
5634    {
5635       if(rlcBearerList->list.array)
5636       {
5637          for(idx=0; idx<rlcBearerList->list.count; idx++)
5638          {
5639             if(rlcBearerList->list.array[idx])
5640             {
5641                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
5642                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
5643                if(rlcConfig)
5644                {
5645                   if(rlcConfig->choice.am)
5646                   {
5647                      DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5648                      DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5649                      DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
5650                   }
5651                   DU_FREE(rlcConfig, sizeof(struct RLC_Config));
5652                }
5653                DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
5654                if(macLcConfig)
5655                {
5656                   if(macLcConfig->ul_SpecificParameters)
5657                   {
5658                      DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
5659                      DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
5660                      DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
5661                   }
5662                   DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
5663                }
5664                DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
5665             }
5666          }
5667          DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
5668       }
5669       DU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5670    }
5671
5672    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
5673    if(macCellGrpCfg)
5674    {
5675       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
5676       if(schedulingRequestConfig)
5677       {
5678          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
5679          if(schReqList)
5680          {
5681             if(schReqList->list.array)
5682             {
5683                for(idx=0;idx<schReqList->list.count; idx++)
5684                {
5685                   if(schReqList->list.array[idx])
5686                   {
5687                      DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
5688                      DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
5689                   }
5690                }
5691                DU_FREE(schReqList->list.array, schReqList->list.size);
5692             }
5693             DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
5694                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
5695             DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5696       }
5697       if(macCellGrpCfg->bsr_Config)
5698       {
5699          DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5700       }
5701       tagConfig = macCellGrpCfg->tag_Config;
5702       if(tagConfig)
5703       {
5704          tagList = tagConfig->tag_ToAddModList;
5705          if(tagList)
5706          {
5707             if(tagList->list.array)
5708             {
5709                for(idx=0; idx<tagList->list.count; idx++)
5710                {
5711                   DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
5712                }
5713                DU_FREE(tagList->list.array, tagList->list.size);
5714             }
5715             DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
5716          }
5717          DU_FREE(tagConfig, sizeof(struct TAG_Config));
5718       }
5719
5720       phrConfig = macCellGrpCfg->phr_Config;
5721       if(phrConfig)
5722       {
5723          DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
5724          DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
5725       }
5726
5727       DU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
5728    }
5729
5730    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
5731    if(phyCellGrpCfg)
5732    {
5733       DU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5734       DU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
5735    }
5736
5737    spCellCfg = cellGrpCfg->spCellConfig;
5738    if(spCellCfg)
5739    {
5740       if(spCellCfg->servCellIndex)
5741       {
5742          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
5743          {
5744             if(spCellCfg->spCellConfigDedicated)
5745             {
5746                srvCellCfg = spCellCfg->spCellConfigDedicated;
5747                if(srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
5748                {
5749                   if(srvCellCfg->initialDownlinkBWP)
5750                   {
5751                      dlBwp = srvCellCfg->initialDownlinkBWP;
5752                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
5753                      {
5754                         if(srvCellCfg->defaultDownlinkBWP_Id)
5755                         {
5756                            if(srvCellCfg->uplinkConfig)
5757                            {
5758                               if(srvCellCfg->pdsch_ServingCellConfig)
5759                               {
5760                                  pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
5761                                  if(pdschCfg->choice.setup)
5762                                  {
5763                                     DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
5764                                     DU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5765                                  }
5766                                  DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
5767                                        ServingCellConfig__pdsch_ServingCellConfig));
5768                               }
5769                               FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
5770                               DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
5771                            }
5772                            DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
5773                         }
5774                         DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
5775                      }
5776                      if(dlBwp->pdcch_Config)
5777                      {
5778                         if(dlBwp->pdsch_Config)
5779                         {
5780                            FreeBWPDlDedPdschCfg(dlBwp);
5781                            DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
5782                         }
5783                         FreeBWPDlDedPdcchCfg(dlBwp);
5784                         DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
5785                     }
5786                     DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
5787                   }
5788                   DU_FREE(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
5789                }
5790                DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5791             }
5792             DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5793          }
5794          DU_FREE(spCellCfg->servCellIndex, sizeof(long));
5795       }
5796       DU_FREE(spCellCfg,sizeof(SpCellConfig_t));
5797    }
5798    return ROK;
5799 }
5800 /*******************************************************************
5801  *
5802  * @brief Builds DU To CU RRC Container
5803  *
5804  * @details
5805  *
5806  *    Function : BuildDuToCuRrcContainer
5807  *
5808  *    Functionality: Builds DuToCuRrcContainer
5809  *
5810  * @params[in] idx, index in F1AP msg
5811  *             DuToCuRRCContainer, DuToCuRRCContainer
5812  *
5813  * @return ROK     - success
5814  *         RFAILED - failure
5815  *
5816  * ****************************************************************/
5817 uint8_t BuildDuToCuRrcContainer(DUtoCURRCContainer_t *duToCuRrcContainer)
5818 {
5819    uint8_t  ret = ROK;
5820    CellGroupConfigRrc_t  cellGrpCfg;
5821    asn_enc_rval_t        encRetVal;
5822    memset(&cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
5823    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
5824
5825    while(true)
5826    {
5827       cellGrpCfg.cellGroupId = CELL_GRP_ID;
5828
5829       cellGrpCfg.rlc_BearerToAddModList = NULLP;
5830       DU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5831       if(!cellGrpCfg.rlc_BearerToAddModList)
5832       {
5833          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5834          ret = RFAILED;
5835          break;
5836       }
5837       if(BuildRlcBearerToAddModList(cellGrpCfg.rlc_BearerToAddModList) != ROK)
5838       {
5839          DU_LOG("\nERROR  -->  F1AP : BuildRlcBearerToAddModList failed");
5840          ret = RFAILED;
5841          break;
5842       }
5843
5844       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
5845       cellGrpCfg.mac_CellGroupConfig = NULLP;
5846       DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
5847       if(!cellGrpCfg.mac_CellGroupConfig)
5848       {
5849          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5850          ret = RFAILED;
5851          break;
5852       }
5853       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
5854       {
5855          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
5856          ret = RFAILED;
5857          break;
5858       }
5859
5860       cellGrpCfg.physicalCellGroupConfig = NULLP;
5861       DU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
5862       if(!cellGrpCfg.physicalCellGroupConfig)
5863       {
5864          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5865          ret = RFAILED;
5866          break;
5867       }
5868       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
5869       {
5870          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
5871          ret = RFAILED;
5872          break;
5873       }
5874
5875       cellGrpCfg.spCellConfig = NULLP;
5876       DU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
5877       if(!cellGrpCfg.spCellConfig)
5878       {
5879          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5880          ret = RFAILED;
5881          break;
5882       }
5883       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
5884       {
5885          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
5886          ret = RFAILED;
5887          break;
5888       }
5889
5890       cellGrpCfg.sCellToAddModList = NULLP;
5891       cellGrpCfg.sCellToReleaseList = NULLP;
5892       cellGrpCfg.ext1 = NULLP;
5893
5894       /* encode cellGrpCfg into duToCuRrcContainer */
5895       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
5896       memset(encBuf, 0, ENC_BUF_MAX_LEN);
5897       encBufSize = 0;
5898       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
5899       /* Encode results */
5900       if(encRetVal.encoded == ENCODE_FAIL)
5901       {
5902          DU_LOG( "\nERROR  --> F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
5903                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5904          ret = RFAILED;
5905          break;
5906       }
5907       else
5908       {
5909          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
5910          for(int i=0; i< encBufSize; i++)
5911          {
5912             printf("%x",encBuf[i]);
5913          }
5914       }
5915
5916       duToCuRrcContainer->size = encBufSize;
5917       DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
5918       if(!duToCuRrcContainer->buf)
5919       {
5920          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
5921          ret = RFAILED;
5922          break;
5923       }
5924       if(ret == ROK)
5925       {
5926          memcpy(duToCuRrcContainer->buf, encBuf, duToCuRrcContainer->size);
5927       }
5928       break;
5929    }
5930    FreeMemDuToCuRrcCont(&cellGrpCfg);
5931    return ret;
5932 }
5933
5934 /*******************************************************************
5935  *
5936  * @brief Free memory allocated in InitialULRRCMessage
5937  *
5938  * @details
5939  *
5940  *    Function : freeInitUlRrcMsgTransfer
5941  *
5942  *    Functionality: Free memory allocated in InitialULRRCMessage
5943  *
5944  * @params[in]F1AP_PDU_t  *f1apMsg)
5945  *
5946  * @return ROK     - success
5947  *         RFAILED - failure
5948  *
5949  * ****************************************************************/
5950
5951 uint8_t freeInitUlRrcMsgTransfer(F1AP_PDU_t  *f1apMsg)
5952 {
5953    uint8_t ieIdx, arrIdx;
5954    InitialULRRCMessageTransfer_t *initULRRCMsg=NULLP;
5955
5956    if(f1apMsg)
5957    {
5958       if(f1apMsg->choice.initiatingMessage)
5959       {
5960          initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.\
5961             choice.InitialULRRCMessageTransfer;
5962          if(initULRRCMsg->protocolIEs.list.array)
5963          {
5964             for(ieIdx = 0; ieIdx < initULRRCMsg->protocolIEs.list.count; ieIdx++)
5965             {
5966                switch(initULRRCMsg->protocolIEs.list.array[ieIdx]->id)
5967                {
5968                   case ProtocolIE_ID_id_NRCGI:
5969                   {
5970                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf)
5971                      {
5972                         if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf)
5973                         {
5974                            DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf,\
5975                            initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.size);
5976                         }
5977                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf,\
5978                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.size);
5979                      }
5980                      break;
5981                   }
5982                   case ProtocolIE_ID_id_RRCContainer:
5983                   {
5984                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
5985                      {
5986                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,\
5987                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
5988                      }
5989                      break;
5990                   }
5991                   case ProtocolIE_ID_id_DUtoCURRCContainer:
5992                   {
5993                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf)
5994                      {
5995                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf,
5996                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.size);
5997                      }
5998                      break;
5999                   }
6000                   default:
6001                      break;
6002                }
6003              }
6004              for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
6005              {
6006                 if(initULRRCMsg->protocolIEs.list.array[arrIdx])
6007                 {
6008                    DU_FREE(initULRRCMsg->protocolIEs.list.array[arrIdx],\
6009                       sizeof(InitialULRRCMessageTransferIEs_t));
6010                 }
6011              }
6012              DU_FREE(initULRRCMsg->protocolIEs.list.array, initULRRCMsg->protocolIEs.list.size);
6013           }
6014          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
6015       }
6016       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
6017    }
6018    else
6019    {
6020       DU_LOG("\nERROR  -->  DU_APP : Recevied F1ap Pdu is null at freeInitUlRrcMsgTransfer()");
6021       return RFAILED;
6022    }
6023    return ROK;
6024 }
6025
6026 /*******************************************************************
6027  *
6028  * @brief Builds and sends the InitialULRRCMessage
6029  *
6030  * @details
6031  *
6032  *    Function : BuildAndSendInitialRrcMsgTransfer
6033  *
6034  *    Functionality: Constructs the Initial UL RRC Message Transfer and sends
6035  *                   it to the CU through SCTP.
6036  *
6037  * @params[in]
6038  *
6039  * @return ROK     - success
6040  *         RFAILED - failure
6041  *
6042  * ****************************************************************/
6043 uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti,
6044       uint16_t rrcContSize, uint8_t *rrcContainer)
6045 {
6046    uint8_t   ret;
6047    uint8_t   elementCnt;
6048    uint8_t   ieIdx;
6049    asn_enc_rval_t  encRetVal;
6050    F1AP_PDU_t  *f1apMsg = NULLP;
6051    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
6052    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
6053
6054    while(true)
6055    {
6056       DU_LOG("\n INFO   -->  F1AP : Building RRC Setup Request\n");
6057       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
6058       if(f1apMsg == NULLP)
6059       {
6060          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
6061          break;
6062       }
6063       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
6064       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
6065       if(f1apMsg->choice.initiatingMessage == NULLP)
6066       {
6067          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
6068          break;
6069       }
6070       f1apMsg->choice.initiatingMessage->procedureCode =\
6071                                                         ProcedureCode_id_InitialULRRCMessageTransfer;
6072       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
6073       f1apMsg->choice.initiatingMessage->value.present = \
6074                                                          InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
6075       initULRRCMsg =\
6076                     &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
6077       elementCnt = 5;
6078       initULRRCMsg->protocolIEs.list.count = elementCnt;
6079       initULRRCMsg->protocolIEs.list.size = \
6080                                             elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *);
6081       /* Initialize the F1Setup members */
6082       DU_ALLOC(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
6083       if(initULRRCMsg->protocolIEs.list.array == NULLP)
6084       {
6085          DU_LOG(" ERROR  -->  F1AP : Memory allocation for\
6086                RRCSetupRequestMessageTransferIEs failed");
6087          break;
6088       }
6089       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
6090       {
6091          DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx],\
6092                sizeof(InitialULRRCMessageTransferIEs_t));
6093          if(initULRRCMsg->protocolIEs.list.array[ieIdx] == NULLP)
6094          {
6095             break;
6096          }
6097       }
6098       ieIdx = 0;
6099       /*GNB DU UE F1AP ID*/
6100       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6101                                                         ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
6102       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  = Criticality_reject;
6103       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
6104                                                                   InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
6105       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
6106
6107
6108       /*NRCGI*/
6109       ieIdx++;
6110       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6111                                                         ProtocolIE_ID_id_NRCGI;
6112       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  =Criticality_reject;
6113       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
6114                                                                   InitialULRRCMessageTransferIEs__value_PR_NRCGI;
6115
6116       ret =\
6117            BuildNrcgi(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
6118       if(ret!=ROK)
6119       {
6120          break;
6121       }
6122
6123       /*CRNTI*/
6124       ieIdx++;
6125       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6126                                                         ProtocolIE_ID_id_C_RNTI;
6127       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6128       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6129                                                                  InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
6130       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.C_RNTI = crnti;
6131
6132       /*RRCContainer*/
6133       ieIdx++;
6134       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6135                                                         ProtocolIE_ID_id_RRCContainer;
6136       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6137       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6138                                                                  InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
6139
6140       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = rrcContSize;
6141       DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
6142             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size)
6143       if(!initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
6144       {
6145          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
6146          break;
6147
6148       }
6149       memcpy(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, rrcContainer,
6150             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
6151
6152
6153       /*DUtoCURRCContainer*/
6154       ieIdx++;
6155       initULRRCMsg->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCContainer;
6156       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6157       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6158                                                                  InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
6159
6160       ret = BuildDuToCuRrcContainer(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer);
6161       if(ret != ROK)
6162       {
6163          break;
6164       }
6165
6166       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
6167
6168       /* Encode the F1SetupRequest type as APER */
6169       memset(encBuf, 0, ENC_BUF_MAX_LEN);
6170       encBufSize = 0;
6171       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
6172       /* Encode results */
6173       if(encRetVal.encoded == ENCODE_FAIL)
6174       {
6175          DU_LOG( "\nERROR  --> F1AP : Could not encode Initial UL RRC Message Transfer\
6176                structure (at %s)\n",encRetVal.failed_type ? \
6177                encRetVal.failed_type->name : "unknown");
6178          ret = RFAILED;
6179          break;
6180       }
6181       else
6182       {
6183
6184          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for Initial UL RRC\
6185                Message transfer\n");
6186          for(int i=0; i< encBufSize; i++)
6187          {
6188             printf("%x",encBuf[i]);
6189          }
6190       }
6191       /* Sending  msg  */
6192       if(sendF1APMsg() != ROK)
6193       {
6194          DU_LOG("\nERROR  -->  F1AP : Sending Initial UL RRC Message Transfer Failed");
6195          ret = RFAILED;
6196          break;
6197       }
6198       break;
6199    }
6200    freeInitUlRrcMsgTransfer(f1apMsg);
6201    return ret;
6202 }/* End of BuildAndSendInitialRrcMsgTransfer*/
6203
6204 /*****  UE SETUP REQUEST *****/
6205
6206 /*******************************************************************
6207  *
6208  * @brief Free Qos And Snssai Drb Info
6209  *
6210  * @details
6211  *
6212  *    Function : freeDrbQosAndSnssaiInfo
6213  *
6214  *    Functionality: Free Qos And Snssai Drb Info
6215  *
6216  * @params[in] LcCfg *lcCfg,
6217  * @return void
6218  *
6219  * ****************************************************************/
6220 void freeDrbQosAndSnssaiInfo(LcCfg *lcCfg)
6221 {
6222    if(lcCfg->snssai)
6223    {
6224       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6225    }
6226    if(lcCfg->drbQos)
6227    {
6228       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
6229    }
6230 }
6231
6232 /******************************************************************
6233 *
6234 * @brief Function to delete the RLC Lc cfg from UE APP DB
6235 *
6236 * @details
6237 *
6238 *  Function : freeRlcLcCfg
6239 *
6240 *  Functionality: Function to delete the RLC Lc cfg from UE APP DB
6241 *
6242 *
6243  *****************************************************************/
6244
6245 void freeRlcLcCfg(RlcBearerCfg *lcCfg)
6246 {
6247    switch(lcCfg->rlcMode)
6248    {
6249       case RLC_AM :
6250       {
6251          if(lcCfg->u.amCfg)
6252          {
6253             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.amCfg, sizeof(AmBearerCfg));
6254             lcCfg->u.amCfg = NULLP;
6255          }
6256          break;
6257       }
6258       case RLC_UM_BI_DIRECTIONAL :
6259       {
6260          if(lcCfg->u.umBiDirCfg)
6261          {
6262             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
6263             lcCfg->u.umBiDirCfg = NULLP;
6264          }
6265          break;
6266       }
6267       case RLC_UM_UNI_DIRECTIONAL_UL :
6268       {
6269          if(lcCfg->u.umUniDirUlCfg)
6270          {
6271             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
6272             lcCfg->u.umUniDirUlCfg = NULLP;
6273          }
6274          break;
6275
6276       }
6277       case RLC_UM_UNI_DIRECTIONAL_DL :
6278       {
6279          if(lcCfg->u.umUniDirDlCfg)
6280          {
6281             DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
6282             lcCfg->u.umUniDirDlCfg = NULLP;
6283          }
6284          break;
6285       }
6286       default:
6287          DU_LOG("\nERROR  -->  DU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
6288          break;
6289    }
6290    memset(lcCfg, 0, sizeof(LcCfg));
6291 }
6292 /*******************************************************************
6293  *
6294  * @brief Function to free MacLcCfg
6295  *
6296  * @details
6297  *
6298  *    Function : freeMacLcCfg
6299  *
6300  *    Functionality: Function to free MacLcCfg
6301  *
6302  * @params[in] LcCfg *lcCfg,
6303  * @return void
6304  *
6305  * ****************************************************************/
6306
6307 void  freeMacLcCfg(LcCfg *lcCfg)
6308 {
6309     /* Deleting DRBQOS */
6310    if(lcCfg->drbQos)
6311    {
6312       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
6313       lcCfg->drbQos = NULLP;
6314    }
6315    /* Deleting SNSSAI */
6316    if(lcCfg->snssai)
6317    {
6318       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6319       lcCfg->snssai = NULLP;
6320    }
6321    memset(lcCfg, 0, sizeof(LcCfg));
6322 }
6323 /*******************************************************************
6324  *
6325  * @brief Free UE NR Capability received in UE Context setup request
6326  *
6327  * @details
6328  *
6329  *    Function : freeAperDecodeUeNrCapability
6330  *
6331  *    Functionality:
6332  *       Free UE NR Capability received in UE Context setup request
6333  *
6334  * @params[in]
6335  * @return ROK     - success
6336  *         RFAILED - failure
6337  *
6338  * ****************************************************************/
6339 void freeAperDecodeUeNrCapability(void *ueNrCapability)
6340 {
6341    uint8_t arrIdx =0;
6342    FeatureSets_t *featureSets =NULLP;
6343    UE_NR_Capability_t *ueNrCap = (UE_NR_Capability_t *)ueNrCapability;
6344
6345    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
6346    {
6347       for(arrIdx = 0; arrIdx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; arrIdx++)
6348       {
6349          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx])
6350             free(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx]);
6351       }
6352       free(ueNrCap->rf_Parameters.supportedBandListNR.list.array);
6353    }
6354
6355    if(ueNrCap->featureSets)
6356    {
6357       featureSets = ueNrCap->featureSets;
6358       if(featureSets->featureSetsDownlinkPerCC)
6359       {
6360          if(featureSets->featureSetsDownlinkPerCC->list.array)
6361          {
6362             for(arrIdx = 0; arrIdx < featureSets->featureSetsDownlinkPerCC->list.count; arrIdx++)
6363             {
6364                if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx])
6365                {
6366                   if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL)
6367                      free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL);
6368                   free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]);
6369                }
6370             }
6371             free(featureSets->featureSetsDownlinkPerCC->list.array);
6372          }
6373          free(featureSets->featureSetsDownlinkPerCC);
6374       }
6375       if(featureSets->featureSetsUplinkPerCC)
6376       {
6377          if(featureSets->featureSetsUplinkPerCC->list.array)
6378          {
6379             for(arrIdx = 0; arrIdx < featureSets->featureSetsUplinkPerCC->list.count; arrIdx++)
6380             {
6381                if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx])
6382                {
6383                   if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL)
6384                      free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL);
6385                   free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]);
6386                }
6387             }
6388             free(featureSets->featureSetsUplinkPerCC->list.array);
6389          }
6390          free(featureSets->featureSetsUplinkPerCC);
6391       }
6392       free(ueNrCap->featureSets);
6393    }
6394 }
6395
6396 /*******************************************************************
6397 *
6398 * @brief Function to free PdcchSearchSpcToAddModList
6399          where memory allocated by aper_decoder
6400 *
6401 * @details
6402 *
6403 *    Function : freeAperDecodePdcchSearchSpcToAddModList
6404 *
6405 *    Functionality: Function to free PdcchSearchSpcToAddModList
6406 *
6407 * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
6408 * @return void
6409 *
6410 * ****************************************************************/
6411
6412 void freeAperDecodePdcchSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
6413 {
6414    uint8_t searchSpcArrIdx=0;
6415    uint8_t searchSpcArrIdx1=0;
6416    struct  SearchSpace *searchSpc=NULLP;
6417
6418
6419    if(searchSpcList->list.array)
6420    {
6421       if(searchSpcList->list.array[searchSpcArrIdx1])
6422       {
6423          searchSpc = searchSpcList->list.array[searchSpcArrIdx1];
6424          if(searchSpc->controlResourceSetId)
6425          {
6426             if(searchSpc->monitoringSlotPeriodicityAndOffset)
6427             {
6428                if(searchSpc->monitoringSymbolsWithinSlot)
6429                {
6430                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
6431                   {
6432                      if(searchSpc->nrofCandidates)
6433                      {
6434                         if(searchSpc->searchSpaceType)
6435                         {
6436                            free(searchSpc->searchSpaceType->choice.ue_Specific);
6437                            free(searchSpc->searchSpaceType);
6438                         }
6439                         free(searchSpc->nrofCandidates);
6440                      }
6441                      free(searchSpc->monitoringSymbolsWithinSlot->buf);
6442                   }
6443                   free(searchSpc->monitoringSymbolsWithinSlot);
6444                }
6445                free(searchSpc->monitoringSlotPeriodicityAndOffset);
6446             }
6447             free(searchSpc->controlResourceSetId);
6448          }
6449       }
6450       for(searchSpcArrIdx = 0; searchSpcArrIdx < searchSpcList->list.count; searchSpcArrIdx++)
6451       {
6452          free(searchSpcList->list.array[searchSpcArrIdx]);
6453       }
6454       free(searchSpcList->list.array);
6455    }
6456 }
6457 /*******************************************************************
6458 *
6459 * @brief Function for free part for the memory allocated by aper_decoder
6460 *
6461 * @details
6462 *
6463 *    Function : freeAperDecodeBWPDlDedPdcchConfig
6464 *
6465 *    Functionality: Function to free BWPDlDedPdcchConfig
6466 *
6467 * @params[in]
6468 * @return void
6469 *
6470 * ****************************************************************/
6471
6472
6473 void freeAperDecodeBWPDlDedPdcchConfig(BWP_DownlinkDedicated_t *dlBwp)
6474 {
6475    uint8_t arrIdx1=0;
6476    uint8_t arrIdx2=0;
6477    struct PDCCH_Config *pdcchCfg=NULLP;
6478    struct ControlResourceSet *controlRSet=NULLP;
6479    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
6480
6481    if(dlBwp->pdcch_Config->choice.setup)
6482    {
6483       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
6484       if(pdcchCfg->controlResourceSetToAddModList)
6485       {
6486          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
6487          if(controlRSetList->list.array)
6488          {
6489             controlRSet = controlRSetList->list.array[arrIdx2];
6490             if(controlRSet)
6491             {
6492                if(controlRSet->frequencyDomainResources.buf)
6493                {
6494                   if(controlRSet->pdcch_DMRS_ScramblingID)
6495                   {
6496                      if(pdcchCfg->searchSpacesToAddModList)
6497                      {
6498                         freeAperDecodePdcchSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
6499                         free(pdcchCfg->searchSpacesToAddModList);
6500                      }
6501                      free(controlRSet->pdcch_DMRS_ScramblingID);
6502                   }
6503                   free(controlRSet->frequencyDomainResources.buf);
6504                }
6505             }
6506             for(arrIdx1 = 0; arrIdx1 <controlRSetList->list.count; arrIdx1++)
6507             {
6508                free(controlRSetList->list.array[arrIdx1]);
6509             }
6510             free(controlRSetList->list.array);
6511          }
6512          free(pdcchCfg->controlResourceSetToAddModList);
6513       }
6514       free(dlBwp->pdcch_Config->choice.setup);
6515    }
6516 }
6517 /*******************************************************************
6518 *
6519 * @brief Function to free PdschTimeDomAllocationList
6520 *     where the memory allocated by aper_decoder
6521 *
6522 * @details
6523 *
6524 *    Function : freeAperDecodePdschTimeDomAllocationList
6525 *
6526 *    Functionality: Function to free PdschTimeDomAllocationList
6527 *
6528 * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
6529 * @return void
6530 *
6531 * ****************************************************************/
6532
6533
6534 void freeAperDecodePdschTimeDomAllocationList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
6535 {
6536    uint8_t arrIdx=0;
6537
6538    if(timeDomAllocList->choice.setup)
6539    {
6540       if(timeDomAllocList->choice.setup->list.array)
6541       {
6542          for(arrIdx = 0; arrIdx <timeDomAllocList->choice.setup->list.count ; arrIdx++)
6543          {
6544             free(timeDomAllocList->choice.setup->list.array[arrIdx]);
6545          }
6546          free(timeDomAllocList->choice.setup->list.array);
6547       }
6548       free(timeDomAllocList->choice.setup);
6549    }
6550 }
6551
6552 /*******************************************************************
6553 *
6554 * @brief Function to free BWPDlDedPdschConfig
6555 *        where the memory allocated by aper_decoder
6556 *
6557 * @details
6558 *
6559 *    Function : freeAperDecodeBWPDlDedPdschConfig
6560 *
6561 *    Functionality: Function to free BWPDlDedPdschConfig
6562 *
6563 * @params[in] BWP_DownlinkDedicated_t *dlBwp
6564 * @return void
6565 *
6566 * ****************************************************************/
6567
6568
6569 void freeAperDecodeBWPDlDedPdschConfig(BWP_DownlinkDedicated_t *dlBwp)
6570 {
6571    struct PDSCH_Config *pdschCfg=NULLP;
6572    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
6573    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
6574    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
6575
6576    if(dlBwp->pdsch_Config->choice.setup)
6577    {
6578       pdschCfg=dlBwp->pdsch_Config->choice.setup;
6579       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
6580       {
6581          if(pdschCfg->pdsch_TimeDomainAllocationList)
6582          {
6583             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
6584             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
6585             {
6586                prbBndlType=&pdschCfg->prb_BundlingType;
6587                free(prbBndlType->choice.staticBundling);
6588                free(pdschCfg->maxNrofCodeWordsScheduledByDCI);
6589             }
6590             freeAperDecodePdschTimeDomAllocationList(timeDomAllocList);
6591             free(pdschCfg->pdsch_TimeDomainAllocationList);
6592          }
6593          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
6594          if(dmrsDlCfg->choice.setup)
6595          {
6596             free(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition);
6597             free(dmrsDlCfg->choice.setup);
6598          }
6599          free(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA);
6600       }
6601       free(dlBwp->pdsch_Config->choice.setup);
6602    }
6603 }
6604 /*******************************************************************
6605 *
6606 * @brief Function to free PuschTimeDomAllocListCfg
6607                  where the memory allocated by aper_decoder
6608 *
6609 * @details
6610 *
6611 *    Function : freeAperDecodePuschTimeDomAllocListCfg
6612 *
6613 *    Functionality: Function to free PuschTimeDomAllocListCfg
6614 *
6615 * @params[in] PUSCH_Config_t *puschCfg
6616 * @return void
6617 *
6618 * ****************************************************************/
6619
6620
6621 void freeAperDecodePuschTimeDomAllocListCfg(PUSCH_Config_t *puschCfg)
6622 {
6623    uint8_t arrIdx=0;
6624    uint8_t arrIdx1=0;
6625    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
6626
6627    if(puschCfg->pusch_TimeDomainAllocationList)
6628    {
6629       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
6630       if(timeDomAllocList_t->choice.setup)
6631       {
6632          if(timeDomAllocList_t->choice.setup->list.array)
6633          {
6634             free(timeDomAllocList_t->choice.setup->list.array[arrIdx1]->k2);
6635             for(arrIdx = 0; arrIdx<timeDomAllocList_t->choice.setup->list.count; arrIdx++)
6636             {
6637                free(timeDomAllocList_t->choice.setup->list.array[arrIdx]);
6638             }
6639             free(timeDomAllocList_t->choice.setup->list.array);
6640          }
6641          free(timeDomAllocList_t->choice.setup);
6642       }
6643       free(puschCfg->transformPrecoder);
6644       free(puschCfg->pusch_TimeDomainAllocationList);
6645    }
6646 }
6647 /*******************************************************************
6648 *
6649 * @brief Function to free InitialUlBWPConfig where memory allocated by aper_decoder
6650 *
6651 * @details
6652 *
6653 *    Function : freeAperDecodeInitialUlBWPConfig
6654 *
6655 *    Functionality: Function to free InitialUlBWPConfig
6656 *
6657 * @params[in]  BWP_UplinkDedicated_t *ulBwp
6658 * @return void
6659 *
6660 * ****************************************************************/
6661
6662
6663 void freeAperDecodeInitialUlBWPConfig(BWP_UplinkDedicated_t *ulBwp)
6664 {
6665    uint8_t  rSetIdx =0;
6666    uint8_t  rsrcIdx =0;
6667    SRS_Config_t   *srsCfg = NULLP;
6668    PUSCH_Config_t *puschCfg = NULLP;
6669    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
6670    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
6671    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
6672    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
6673
6674    if(ulBwp->pusch_Config)
6675    {
6676       if(ulBwp->pusch_Config->choice.setup)
6677       {
6678          puschCfg=ulBwp->pusch_Config->choice.setup;
6679          if(puschCfg->dataScramblingIdentityPUSCH)
6680          {
6681             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
6682             {
6683                freeAperDecodePuschTimeDomAllocListCfg(puschCfg);
6684                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
6685                if(dmrsUlCfg->choice.setup)
6686                {
6687                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
6688                   {
6689                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
6690                      {
6691                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0);
6692                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled);
6693                      }
6694                      free(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition);
6695                   }
6696                   free(dmrsUlCfg->choice.setup);
6697                }
6698                free(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA);
6699             }
6700             free(puschCfg->dataScramblingIdentityPUSCH);
6701          }
6702          free(ulBwp->pusch_Config->choice.setup);
6703       }
6704       free(ulBwp->pusch_Config);
6705
6706       /* Free SRS-Config */
6707       if(ulBwp->srs_Config)
6708       {
6709          if(ulBwp->srs_Config->choice.setup)
6710          {
6711             srsCfg = ulBwp->srs_Config->choice.setup;
6712
6713             /* Free Resource Set to add/mod list */
6714             if(srsCfg->srs_ResourceSetToAddModList)
6715             {
6716                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
6717                if(rsrcSetList->list.array)
6718                {
6719                   rSetIdx = 0;
6720
6721                   /* Free SRS resource Id list in this SRS resource set */
6722                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
6723                   {
6724                      rsrcIdList =
6725                         rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
6726
6727                      if(rsrcIdList->list.array)
6728                      {
6729                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count;
6730                               rsrcIdx++)
6731                         {
6732                            free(rsrcIdList->list.array[rsrcIdx]);
6733                         }
6734                         free(rsrcIdList->list.array);
6735                      }
6736                      free(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList);
6737                   }
6738
6739                   /* Free resource type info for this SRS resource set */
6740
6741                   free(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic);
6742
6743                   /* Free memory for each resource set */
6744                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
6745                   {
6746                      free(rsrcSetList->list.array[rSetIdx]);
6747                   }
6748                   free(rsrcSetList->list.array);
6749                }
6750                free(srsCfg->srs_ResourceSetToAddModList);
6751             }
6752
6753             /* Free resource to add/modd list */
6754             if(srsCfg->srs_ResourceToAddModList)
6755             {
6756                resourceList = srsCfg->srs_ResourceToAddModList;
6757                if(resourceList->list.array)
6758                {
6759                   rsrcIdx = 0;
6760
6761                   free(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2);
6762                   free(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic);
6763
6764                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
6765                   {
6766                      free(resourceList->list.array[rsrcIdx]);
6767                   }
6768                   free(resourceList->list.array);
6769                }
6770                free(srsCfg->srs_ResourceToAddModList);
6771             }
6772
6773             free(ulBwp->srs_Config->choice.setup);
6774          }
6775          free(ulBwp->srs_Config);
6776       }
6777    }
6778 }
6779 /*******************************************************************
6780 *
6781 * @brief Function to free initialUplinkBWPConfig where memory allocated by aper_decoder
6782 *
6783 * @details
6784 *
6785 *    Function : freeAperDecodeinitialUplinkBWPConfig
6786 *
6787 *    Functionality: Function to free initialUplinkBWPConfig
6788 *
6789 * @params[in] UplinkConfig_t *ulCfg
6790 * @return void
6791 *
6792 * ****************************************************************/
6793
6794
6795 void freeAperDecodeinitialUplinkBWPConfig(UplinkConfig_t *ulCfg)
6796 {
6797    BWP_UplinkDedicated_t *ulBwp=NULLP;
6798    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
6799
6800    if(ulCfg->initialUplinkBWP)
6801    {
6802       ulBwp=ulCfg->initialUplinkBWP;
6803       if(ulCfg->firstActiveUplinkBWP_Id)
6804       {
6805          if(ulCfg->pusch_ServingCellConfig)
6806          {
6807             puschCfg=ulCfg->pusch_ServingCellConfig;
6808             if(puschCfg->choice.setup)
6809             {
6810                if(puschCfg->choice.setup->ext1)
6811                {
6812                   free(puschCfg->choice.setup->ext1->processingType2Enabled);
6813                   free(puschCfg->choice.setup->ext1->maxMIMO_Layers);
6814                   free(puschCfg->choice.setup->ext1);
6815                }
6816                free(puschCfg->choice.setup);
6817             }
6818             free(ulCfg->pusch_ServingCellConfig);
6819          }
6820          free(ulCfg->firstActiveUplinkBWP_Id);
6821       }
6822       freeAperDecodeInitialUlBWPConfig(ulBwp);
6823       free(ulCfg->initialUplinkBWP);
6824    }
6825 }
6826
6827 /*******************************************************************
6828  *
6829  * @brief Function to free DuUeCfg
6830  *
6831  * @details
6832  *
6833  *    Function : freeDuUeCfg
6834  *
6835  *    Functionality: Function to free DuUeCfg
6836  *
6837  * @params[in] DuUeCfg *ueCfg
6838  * @return void
6839  *
6840  * ****************************************************************/
6841 void freeDuUeCfg(DuUeCfg *ueCfg)
6842 {
6843    uint8_t lcIdx = 0;
6844    uint8_t arrIdx = 0;
6845    SpCellConfig_t *spCellCfg = NULLP;
6846    ServingCellConfig_t *srvCellCfg = NULLP;
6847    BWP_DownlinkDedicated_t *dlBwp = NULLP;
6848    MAC_CellGroupConfig_t *macCellGrpCfg = NULLP;
6849    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
6850    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList = NULLP;
6851    struct RLC_Config *rlcConfig = NULLP;
6852    struct LogicalChannelConfig *macLcConfig = NULLP;
6853    struct SchedulingRequestConfig *schedulingRequestConfig = NULLP;
6854    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList = NULLP;
6855    struct TAG_Config *tagConfig = NULLP;
6856    struct TAG_Config__tag_ToAddModList *tagList = NULLP;
6857    struct MAC_CellGroupConfig__phr_Config *phrConfig = NULLP;
6858    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg = NULLP;
6859    CellGroupConfigRrc_t *cellGrpCfg = ueCfg->cellGrpCfg;
6860
6861    if(ueCfg->ueNrCapability)
6862    {
6863       freeAperDecodeUeNrCapability(ueCfg->ueNrCapability);
6864       DU_FREE(ueCfg->ueNrCapability, sizeof(UE_NR_Capability_t));
6865       ueCfg->ueNrCapability = NULLP;
6866    }
6867
6868    if(ueCfg->cellGrpCfg)
6869    {
6870
6871       rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6872       if(rlcBearerList)
6873       {
6874          if(rlcBearerList->list.array)
6875          {
6876             for(arrIdx=0; arrIdx<rlcBearerList->list.count; arrIdx++)
6877             {
6878                if(rlcBearerList->list.array[arrIdx])
6879                {
6880                   rlcConfig   = rlcBearerList->list.array[arrIdx]->rlc_Config;
6881                   macLcConfig = rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig;
6882
6883                   if(rlcBearerList->list.array[arrIdx]->servedRadioBearer)
6884                   {
6885                      free(rlcBearerList->list.array[arrIdx]->servedRadioBearer);
6886                   }
6887                   if(rlcConfig)
6888                   {
6889                      if(rlcConfig->choice.am)
6890                      {
6891                         free(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength);
6892                         free(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength);
6893                         free(rlcConfig->choice.am);
6894                      }
6895                      free(rlcBearerList->list.array[arrIdx]->rlc_Config);
6896                   }
6897                   if(macLcConfig)
6898                   {
6899                      if(macLcConfig->ul_SpecificParameters)
6900                      {
6901                         free(macLcConfig->ul_SpecificParameters->schedulingRequestID);
6902                         free(macLcConfig->ul_SpecificParameters->logicalChannelGroup);
6903                         free(macLcConfig->ul_SpecificParameters);
6904                      }
6905                      free(rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig);
6906                   }
6907                   free(rlcBearerList->list.array[arrIdx]);
6908                }
6909             }
6910             free(rlcBearerList->list.array);
6911          }
6912          free(cellGrpCfg->rlc_BearerToAddModList);
6913       }
6914
6915       macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
6916       if(macCellGrpCfg)
6917       {
6918          schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
6919          if(schedulingRequestConfig)
6920          {
6921             schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
6922             if(schReqList)
6923             {
6924                if(schReqList->list.array)
6925                {
6926                   for(arrIdx=0;arrIdx<schReqList->list.count; arrIdx++)
6927                   {
6928                      if(schReqList->list.array[arrIdx])
6929                      {
6930                         free(schReqList->list.array[arrIdx]->sr_ProhibitTimer);
6931                         free(schReqList->list.array[arrIdx]);
6932                      }
6933                   }
6934                   free(schReqList->list.array);
6935                }
6936                free(schedulingRequestConfig->schedulingRequestToAddModList);
6937             }
6938             free(macCellGrpCfg->schedulingRequestConfig);
6939          }
6940          if(macCellGrpCfg->bsr_Config)
6941          {
6942             free(macCellGrpCfg->bsr_Config);
6943          }
6944          tagConfig = macCellGrpCfg->tag_Config;
6945          if(tagConfig)
6946          {
6947             tagList = tagConfig->tag_ToAddModList;
6948             if(tagList)
6949             {
6950                if(tagList->list.array)
6951                {
6952                   for(arrIdx=0; arrIdx<tagList->list.count; arrIdx++)
6953                   {
6954                      free(tagList->list.array[arrIdx]);
6955                   }
6956                   free(tagList->list.array);
6957                }
6958                free(tagConfig->tag_ToAddModList);
6959             }
6960             free(tagConfig);
6961          }
6962
6963          phrConfig = macCellGrpCfg->phr_Config;
6964          if(phrConfig)
6965          {
6966             free(phrConfig->choice.setup);
6967             free(phrConfig);
6968          }
6969
6970          free(macCellGrpCfg);
6971       }
6972
6973       phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
6974       if(phyCellGrpCfg)
6975       {
6976          free(phyCellGrpCfg->p_NR_FR1);
6977          free(phyCellGrpCfg);
6978       }
6979
6980       spCellCfg = cellGrpCfg->spCellConfig;
6981       if(spCellCfg)
6982       {
6983          if(spCellCfg->servCellIndex)
6984          {
6985             if(spCellCfg->rlmInSyncOutOfSyncThreshold)
6986             {
6987                if(spCellCfg->spCellConfigDedicated)
6988                {
6989                   srvCellCfg = spCellCfg->spCellConfigDedicated;
6990                   if(srvCellCfg->initialDownlinkBWP)
6991                   {
6992                      dlBwp = srvCellCfg->initialDownlinkBWP;
6993                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
6994                      {
6995                         if(srvCellCfg->defaultDownlinkBWP_Id)
6996                         {
6997                            if(srvCellCfg->uplinkConfig)
6998                            {
6999
7000                               if(srvCellCfg->pdsch_ServingCellConfig)
7001                               {
7002                                  pdschCfg=
7003                                     srvCellCfg->pdsch_ServingCellConfig;
7004                                  if(pdschCfg->choice.setup)
7005                                  {
7006
7007                                     free(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH);
7008                                     free(pdschCfg->choice.setup);
7009                                  }
7010
7011                                  free(srvCellCfg->pdsch_ServingCellConfig);
7012                               }
7013
7014                               freeAperDecodeinitialUplinkBWPConfig(srvCellCfg->uplinkConfig);
7015                               free(srvCellCfg->uplinkConfig);
7016                            }
7017                            free(srvCellCfg->defaultDownlinkBWP_Id);
7018                         }
7019
7020                         free(srvCellCfg->firstActiveDownlinkBWP_Id);
7021                      }
7022                      if(dlBwp->pdcch_Config)
7023                      {
7024                         if(dlBwp->pdsch_Config)
7025                         {
7026                            freeAperDecodeBWPDlDedPdschConfig(dlBwp);
7027                            free(dlBwp->pdsch_Config);
7028                         }
7029                         freeAperDecodeBWPDlDedPdcchConfig(dlBwp);
7030                         free(dlBwp->pdcch_Config);
7031                      }
7032                      free(srvCellCfg->initialDownlinkBWP);
7033                   }
7034
7035                   free(spCellCfg->spCellConfigDedicated);
7036                }
7037                free(spCellCfg->rlmInSyncOutOfSyncThreshold);
7038             }
7039             free(spCellCfg->servCellIndex);
7040          }
7041          free(spCellCfg);
7042       }
7043       DU_FREE(ueCfg->cellGrpCfg, sizeof(CellGroupConfigRrc_t));
7044       ueCfg->cellGrpCfg = NULLP;
7045    }
7046    if(ueCfg->ambrCfg)
7047    {
7048       memset(ueCfg->ambrCfg, 0, sizeof(AmbrCfg));
7049       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->ambrCfg, sizeof(AmbrCfg));
7050    }
7051    for(lcIdx = 0; lcIdx < ueCfg->numRlcLcs; lcIdx++)
7052    {
7053       freeRlcLcCfg(&ueCfg->rlcLcCfg[lcIdx]);
7054    }
7055    for(lcIdx = 0; lcIdx < ueCfg->numMacLcs; lcIdx++)
7056    {
7057       freeMacLcCfg(&ueCfg->macLcCfg[lcIdx]);
7058    }
7059    for(lcIdx = 0; lcIdx < ueCfg->numDrb; lcIdx++)
7060    {
7061       DU_FREE(ueCfg->upTnlInfo[lcIdx].tnlCfg1, sizeof(GtpTnlCfg));
7062       memset(&ueCfg->upTnlInfo[lcIdx], 0, sizeof(UpTnlCfg));
7063    }
7064 }
7065
7066 /*******************************************************************
7067  *
7068  * @brief Function to free UecontextSetupDb
7069  *
7070  * @details
7071  *
7072  *    Function : freeF1UeDb
7073  *
7074  *    Functionality: Function to free UecontextSetupDb
7075  *
7076  * @params[in] UecontextSetupDb *
7077  * @return void
7078  *
7079  * ****************************************************************/
7080
7081 void freeF1UeDb(F1UeContextSetupDb *f1UeDb)
7082 {
7083
7084    if(f1UeDb->dlRrcMsg)
7085    {
7086       if(f1UeDb->dlRrcMsg->rrcMsgPdu)
7087       {
7088          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,\
7089             f1UeDb->dlRrcMsg->rrcMsgPdu, f1UeDb->dlRrcMsg->rrcMsgSize);
7090       }
7091       memset(f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
7092    }
7093    freeDuUeCfg(&f1UeDb->duUeCfg);
7094    memset(f1UeDb, 0, sizeof(F1UeContextSetupDb));
7095    DU_FREE(f1UeDb, sizeof(F1UeContextSetupDb));
7096 }
7097
7098 /*******************************************************************
7099  *
7100  * @brief Function to build Am cfg Info
7101  *
7102  * @details
7103  *
7104  *    Function : extractRlcAmCfg
7105  *
7106  *    Functionality: Function to build Am cfg Info
7107  *
7108  * @params[in] AmBearerCfg *
7109  *             void *
7110  *
7111  * @return ROK/RFAILED
7112  *
7113  * ****************************************************************/
7114
7115 void extractRlcAmCfg(AmBearerCfg *amCfgToSet, struct RLC_Config__am *rlcAmCfg)
7116 {
7117    if(rlcAmCfg)
7118    {
7119       /* UL AM */
7120       if(rlcAmCfg->dl_AM_RLC.sn_FieldLength)
7121       {
7122          amCfgToSet->ulAmCfg.snLenUl = *(rlcAmCfg->dl_AM_RLC.sn_FieldLength);
7123          /*TODO: Check the timer value when sent by real CU */
7124          amCfgToSet->ulAmCfg.reAssemTmr = rlcAmCfg->dl_AM_RLC.t_Reassembly;
7125          amCfgToSet->ulAmCfg.statProhTmr = rlcAmCfg->dl_AM_RLC.t_StatusProhibit;
7126       }
7127
7128       /* DL AM */
7129       if(rlcAmCfg->ul_AM_RLC.sn_FieldLength)
7130       {
7131          amCfgToSet->dlAmCfg.snLenDl = *(rlcAmCfg->ul_AM_RLC.sn_FieldLength);
7132          amCfgToSet->dlAmCfg.pollRetxTmr = rlcAmCfg->ul_AM_RLC.t_PollRetransmit;
7133          amCfgToSet->dlAmCfg.pollPdu   = rlcAmCfg->ul_AM_RLC.pollPDU;
7134          amCfgToSet->dlAmCfg.pollByte  = rlcAmCfg->ul_AM_RLC.pollByte;
7135          amCfgToSet->dlAmCfg.maxRetxTh = rlcAmCfg->ul_AM_RLC.maxRetxThreshold;
7136       }
7137    }
7138 }
7139
7140 /*******************************************************************
7141  *
7142  * @brief Function to build Um Bi Info
7143  *
7144  * @details
7145  *
7146  *    Function : extractRlcUmBiCfg
7147  *
7148  *    Functionality: Function to build Um Bi Info
7149  *
7150  * @params[in] UmBiDirBearerCfg *
7151  *             void *
7152  *
7153  * @return ROK/RFAILED
7154  *
7155  * ****************************************************************/
7156
7157 void extractRlcUmBiCfg(UmBiDirBearerCfg *umBiCfgToSet, struct RLC_Config__um_Bi_Directional *rlcBiCfg)
7158 {
7159    if(rlcBiCfg)
7160    {
7161       /* UL UM BI DIR Cfg */
7162       if(rlcBiCfg->dl_UM_RLC.sn_FieldLength)
7163       {
7164          umBiCfgToSet->ulUmCfg.snLenUlUm  = *(rlcBiCfg->dl_UM_RLC.sn_FieldLength);
7165          umBiCfgToSet->ulUmCfg.reAssemTmr = rlcBiCfg->dl_UM_RLC.t_Reassembly;
7166       }
7167
7168       /* DL UM BI DIR Cfg */
7169       if(rlcBiCfg->ul_UM_RLC.sn_FieldLength)
7170          umBiCfgToSet->dlUmCfg.snLenDlUm  = *(rlcBiCfg->ul_UM_RLC.sn_FieldLength);
7171    }
7172 }
7173
7174 /*******************************************************************
7175  *
7176  * @brief Function to build Um Ul Info
7177  *
7178  * @details
7179  *
7180  *    Function : extractRlcUmUlCfg
7181  *
7182  *    Functionality: Function to build Um Ul Info
7183  *
7184  * @params[in] UmUniDirUlBearerCfg *
7185  *             void *
7186  *
7187  * @return ROK/RFAILED
7188  *
7189  * ****************************************************************/
7190
7191 void extractRlcUmUlCfg(UmUniDirUlBearerCfg *umUlCfgToSet, struct RLC_Config__um_Uni_Directional_DL *umUlCfg)
7192 {
7193    if(umUlCfg)
7194    {
7195       if(umUlCfg->dl_UM_RLC.sn_FieldLength)
7196       {
7197          umUlCfgToSet->ulUmCfg.snLenUlUm  = *(umUlCfg->dl_UM_RLC.sn_FieldLength);
7198          umUlCfgToSet->ulUmCfg.reAssemTmr = umUlCfg->dl_UM_RLC.t_Reassembly;
7199       }
7200    }
7201 }
7202
7203 /*******************************************************************
7204  *
7205  * @brief Function to build Um Uni Dl Info
7206  *
7207  * @details
7208  *
7209  *    Function : extractRlcUmDlCfg
7210  *
7211  *    Functionality: Function to build Um Uni Dl Info
7212  *
7213  * @params[in] UmUniDirDlBearerCfg *
7214  *             void *
7215  *
7216  * @return ROK/RFAILED
7217  *
7218  * ****************************************************************/
7219 void extractRlcUmDlCfg(UmUniDirDlBearerCfg *umDlCfgToSet, struct RLC_Config__um_Uni_Directional_UL *umDlCfg)
7220 {
7221    if(umDlCfg)
7222    {
7223       if(umDlCfg->ul_UM_RLC.sn_FieldLength)
7224          umDlCfgToSet->dlUmCfg.snLenDlUm  = *(umDlCfg->ul_UM_RLC.sn_FieldLength);
7225    }
7226 }
7227
7228 /*******************************************************************
7229  *
7230  * @brief Function to extractRlcModeCfg
7231  *
7232  * @details
7233  *
7234  *    Function : extractRlcModeCfg
7235  *
7236  *    Functionality: Function to extractRlcModeCfg
7237  *
7238  * @params[in] RLC_Config_t *
7239  *             RlcBearerCfg *
7240  *             void  *
7241  * @return ROK/RFAILED
7242  *
7243  * ****************************************************************/
7244 void extractRlcModeCfg(uint8_t rlcMode, RlcBearerCfg *rlcDbCfg, RLC_Config_t *lcCfg)
7245 {
7246    if(lcCfg)
7247    {
7248       switch(rlcMode)
7249       {
7250          case RLC_AM :
7251             {
7252                if(lcCfg->choice.am)
7253                {
7254                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.amCfg, sizeof(AmBearerCfg));
7255                   if(rlcDbCfg->u.amCfg)
7256                      extractRlcAmCfg(rlcDbCfg->u.amCfg, lcCfg->choice.am);
7257                }
7258                break;
7259             }
7260          case RLC_UM_BI_DIRECTIONAL :
7261             {
7262                if(lcCfg->choice.um_Bi_Directional)
7263                {
7264                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
7265                   if(rlcDbCfg->u.umBiDirCfg)
7266                      extractRlcUmBiCfg(rlcDbCfg->u.umBiDirCfg, lcCfg->choice.um_Bi_Directional);
7267                }
7268                break;
7269             }
7270          case RLC_UM_UNI_DIRECTIONAL_UL :
7271             {
7272                if(lcCfg->choice.um_Uni_Directional_DL)
7273                {
7274                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
7275                   if(rlcDbCfg->u.umUniDirUlCfg)
7276                      extractRlcUmUlCfg(rlcDbCfg->u.umUniDirUlCfg, lcCfg->choice.um_Uni_Directional_DL);
7277                }
7278                break;
7279             }
7280          case RLC_UM_UNI_DIRECTIONAL_DL :
7281             {
7282                if(lcCfg->choice.um_Uni_Directional_UL)
7283                {
7284                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
7285                   if(rlcDbCfg->u.umUniDirDlCfg)
7286                      extractRlcUmDlCfg(rlcDbCfg->u.umUniDirDlCfg, lcCfg->choice.um_Uni_Directional_UL);
7287                }
7288                break;
7289             }
7290          default:
7291             DU_LOG("\nERROR  -->  DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
7292             break;
7293       }
7294    }
7295 }
7296
7297 /*******************************************************************
7298  *
7299  * @brief Function to extract extractUlLcCfg
7300  *
7301  * @details
7302  *
7303  *    Function : extractUlLcCfg
7304  *
7305  *    Functionality: Function to extract extractUlLcCfg
7306  *
7307  * @params[in] UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg
7308  * @return void
7309  *
7310  * ****************************************************************/
7311
7312 void extractUlLcCfg(UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg)
7313 {
7314    if(ulLcCfg)
7315    {
7316       if(ulLcCfg->ul_SpecificParameters)
7317       {
7318          f1UlLcCfg->priority = \
7319             ulLcCfg->ul_SpecificParameters->priority;
7320       if(ulLcCfg->ul_SpecificParameters->logicalChannelGroup)
7321       {
7322          f1UlLcCfg->lcGroup = \
7323            *(ulLcCfg->ul_SpecificParameters->logicalChannelGroup);
7324       }
7325       if(ulLcCfg->ul_SpecificParameters->schedulingRequestID)
7326       {
7327          f1UlLcCfg->schReqId = \
7328            *(ulLcCfg->ul_SpecificParameters->schedulingRequestID);
7329       }
7330       f1UlLcCfg->pbr = \
7331          ulLcCfg->ul_SpecificParameters->prioritisedBitRate;
7332       f1UlLcCfg->bsd = \
7333          ulLcCfg->ul_SpecificParameters->bucketSizeDuration;
7334       }
7335    }
7336 }
7337
7338 /*******************************************************************
7339  *
7340  * @brief Function to procRlcLcCfg
7341  *
7342  * @details
7343  *
7344  *    Function : procRlcLcCfg
7345  *
7346  *    Functionality: Function to procRlcLcCfg
7347  *
7348  * @params[in] rbId, lcId, rbType, rlcMod
7349  *             RLC_Config_t *, RlcBearerCfg * ,
7350  * @return void
7351  *
7352  * ****************************************************************/
7353
7354 void procRlcLcCfg(uint8_t rbId, uint8_t lcId, uint8_t rbType, uint8_t rlcMode,\
7355    uint8_t configType, RLC_Config_t *f1RlcCfg, RlcBearerCfg *lcCfg)
7356 {
7357
7358    lcCfg->rbId   = rbId;
7359    lcCfg->configType = configType;
7360
7361    if(rbType == RB_TYPE_SRB)
7362    {
7363       lcCfg->rbType = RB_TYPE_SRB;
7364       lcCfg->lcId   = rbId;
7365       lcCfg->lcType = LCH_DCCH;
7366       lcCfg->rlcMode = RLC_AM;
7367    }
7368    else if(rbType == RB_TYPE_DRB)
7369    {
7370       lcCfg->rbType = RB_TYPE_DRB;
7371       lcCfg->lcId   = lcId;
7372       lcCfg->lcType = LCH_DTCH;
7373       lcCfg->rlcMode = rlcMode;
7374    }
7375    if(f1RlcCfg) /* rlc mode config recived */
7376    {
7377       extractRlcModeCfg(lcCfg->rlcMode, lcCfg, f1RlcCfg);
7378    }
7379 }
7380
7381
7382
7383 /*******************************************************************
7384  *
7385  * @brief Fills DrbQos Info received by CU
7386  *
7387  * @details
7388  *
7389  *    Function : extractQosInfo
7390  *
7391  *    Functionality: Fills DrbQos Info received  by CU
7392  *
7393  * @params[in] DrbQosInfo *qosToAdd,
7394  *             QoSFlowLevelQoSParameters_t *qosFlowCfg
7395  * @return void
7396  *
7397  * ****************************************************************/
7398
7399 void extractQosInfo(DrbQosInfo *qosToAdd, QoSFlowLevelQoSParameters_t *qosFlowCfg)
7400 {
7401    qosToAdd->fiveQiType = qosFlowCfg->qoS_Characteristics.present;
7402    qosToAdd->u.nonDyn5Qi.fiveQi     =\
7403          qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
7404    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow)
7405    {
7406       qosToAdd->u.nonDyn5Qi.avgWindow = \
7407         *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
7408    }
7409    qosToAdd->u.nonDyn5Qi.maxDataBurstVol = \
7410       *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
7411    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel)
7412    {
7413       qosToAdd->u.nonDyn5Qi.priorLevel = \
7414          *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel);
7415    }
7416    qosToAdd->ngRanRetPri.priorityLevel = \
7417       qosFlowCfg->nGRANallocationRetentionPriority.priorityLevel;
7418    qosToAdd->ngRanRetPri.preEmptionCap = \
7419       qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionCapability;
7420    qosToAdd->ngRanRetPri.preEmptionVul = \
7421       qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionVulnerability;
7422    if(qosFlowCfg->gBR_QoS_Flow_Information)
7423    {
7424       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateDl, \
7425          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.buf, \
7426          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.size);
7427       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateUl, \
7428          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.buf, \
7429          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.size);
7430       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateDl,\
7431          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.buf, \
7432          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.size);
7433       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateUl,\
7434          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.buf, \
7435          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.size);
7436    }
7437    qosToAdd->pduSessionId = 0;
7438    qosToAdd->ulPduSessAggMaxBitRate = 0;
7439 }
7440
7441 /*******************************************************************
7442  *
7443  * @brief Function to extract GTP Tunnel Info from CU
7444  *
7445  * @details
7446  *
7447  *    Function : extractUpTnlInfo
7448  *
7449  *    Functionality: Function to extract GTP Tunnel Info from CU
7450  *
7451  * @params[in] F1AP message
7452  * @return ROK/RFAILED
7453  *
7454  * ****************************************************************/
7455
7456 uint8_t extractUpTnlInfo(uint8_t drbId, uint8_t configType,\
7457    ULUPTNLInformation_ToBeSetup_List_t *tnlInfo, UpTnlCfg *upTnlInfo)
7458 {
7459    uint8_t tnlIdx;
7460    uint32_t ipv4_du = 0;
7461    GTPTunnel_t *gtpTunnel = NULLP;
7462
7463    upTnlInfo->drbId = drbId;
7464    upTnlInfo->configType = configType;
7465 #ifdef O1_ENABLE
7466    cmInetAddr((S8*)g_cfg.DU_IPV4_Addr, &ipv4_du);
7467 #else
7468    cmInetAddr((char *)DU_IP_V4_ADDR, &ipv4_du);
7469 #endif
7470
7471    for(tnlIdx=0; tnlIdx < tnlInfo->list.count; tnlIdx++)
7472    {
7473       if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
7474       {
7475          if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel)
7476          {
7477             gtpTunnel = tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel;
7478             DU_ALLOC(upTnlInfo->tnlCfg1, sizeof(GtpTnlCfg));
7479             if(upTnlInfo->tnlCfg1 == NULLP)
7480             {
7481                DU_LOG("\nERROR  -->  F1AP : extractUpTnlInfo: Failed to allocate mmeory for tunnel cfg 1");
7482                return RFAILED;
7483             }
7484             bitStringToInt(&gtpTunnel->transportLayerAddress, &upTnlInfo->tnlCfg1->ulTnlAddress);
7485             upTnlInfo->tnlCfg1->dlTnlAddress = ipv4_du;
7486             if(gtpTunnel->gTP_TEID.size > 0)
7487             {
7488                teIdStringToInt(gtpTunnel->gTP_TEID.buf, &upTnlInfo->tnlCfg1->teId);
7489             }
7490          }
7491          break;
7492       }
7493    }
7494    return ROK;
7495 }
7496 /*******************************************************************
7497 *
7498 * @brief Function to extract Drb Qos Cfg Info from CU
7499 *
7500 * @details
7501 *
7502 *    Function : extractDrbQosCfg
7503 *
7504 *    Functionality: Function to extract Drb Qos Cfg Info from CU
7505 *
7506 * @params[in] DRB_Information_t *drbInfo, LcCfg *macLcToAdd
7507 * @return ROK/RFAILED
7508 *
7509 * ****************************************************************/
7510
7511 uint8_t extractDrbQosCfg(DRB_Information_t *drbInfo, LcCfg *macLcToAdd )
7512 {
7513    if(!macLcToAdd->drbQos)
7514    {
7515       DU_ALLOC_SHRABL_BUF(macLcToAdd->drbQos, sizeof(DrbQosInfo));
7516       if(macLcToAdd->drbQos == NULLP)
7517       {
7518          DU_LOG("\nERROR  -->  DUAPP:Memory failed at allocating DrbQos at extractDrbCfg()");
7519          return RFAILED;
7520       }
7521
7522    }
7523    if(drbInfo->dRB_QoS.qoS_Characteristics.present == QoS_Characteristics_PR_non_Dynamic_5QI)
7524    {
7525       extractQosInfo(macLcToAdd->drbQos, &drbInfo->dRB_QoS);
7526       macLcToAdd->dlLcCfg.lcp = macLcToAdd->drbQos->ngRanRetPri.priorityLevel;
7527    }
7528    if(!macLcToAdd->snssai)
7529    {
7530       DU_ALLOC_SHRABL_BUF(macLcToAdd->snssai, sizeof(Snssai));
7531       if(macLcToAdd->snssai == NULLP)
7532       {
7533          DU_LOG("\nERROR  -->  DUAPP : Memory failed at allocating SNSSAI at extractDrbCfg()");
7534          return RFAILED;
7535       }
7536    }
7537    memcpy(&macLcToAdd->snssai->sst, drbInfo->sNSSAI.sST.buf, \
7538          drbInfo->sNSSAI.sST.size);
7539    if(drbInfo->sNSSAI.sD)
7540    {
7541       memcpy(macLcToAdd->snssai->sd, drbInfo->sNSSAI.sD->buf, \
7542             drbInfo->sNSSAI.sD->size);
7543    }
7544    return ROK;
7545 }
7546 /*******************************************************************
7547  *
7548  * @brief Function to extract DRB info received from CU
7549  *
7550  * @details
7551  *
7552  *    Function : extractDrbCfg
7553  *
7554  *    Functionality: Function to extract DRB info received from CU
7555  *
7556  * @params[in] F1AP message
7557  * @return void
7558  *
7559  * ****************************************************************/
7560 uint8_t extractDrbCfg(DRBs_ToBeSetup_Item_t *drbItem,DRBs_ToBeSetupMod_Item_t *drbSetupModItem,\
7561 LcCfg *macLcToAdd, UpTnlCfg *upTnlInfo)
7562 {
7563    DRB_Information_t *drbInfo = NULLP;
7564
7565    if(drbItem != NULLP)
7566    {
7567       if(extractUpTnlInfo(drbItem->dRBID, CONFIG_ADD, &drbItem->uLUPTNLInformation_ToBeSetup_List, upTnlInfo) != ROK)
7568       {
7569          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7570          return RFAILED;
7571       }
7572       if(drbItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7573       {
7574          if(drbItem->qoSInformation.choice.choice_extension->value.present == QoSInformation_ExtIEs__value_PR_DRB_Information)
7575          {
7576             drbInfo = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7577             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7578             {
7579                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7580                return RFAILED;
7581             }
7582          }
7583       }
7584    }
7585    else if(drbSetupModItem != NULLP)
7586    {
7587       if(extractUpTnlInfo(drbSetupModItem->dRBID, CONFIG_ADD, &drbSetupModItem->uLUPTNLInformation_ToBeSetup_List,\
7588       upTnlInfo) != ROK)
7589       {
7590          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7591          return RFAILED;
7592       }
7593       if(drbSetupModItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7594       {
7595          if(drbSetupModItem->qoSInformation.choice.choice_extension->value.present ==\
7596          QoSInformation_ExtIEs__value_PR_DRB_Information)
7597          {
7598             drbInfo = &drbSetupModItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7599             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7600             {
7601                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7602                return RFAILED;
7603             }
7604
7605          }
7606       }
7607    }
7608
7609    return ROK;
7610 }
7611
7612 /*******************************************************************
7613  *
7614  * @brief Function to extract RB info received from CU
7615  *
7616  * @details
7617  *
7618  *    Function : extractMacRbCfg
7619  *
7620  *    Functionality: Function to extract RB info received from CU
7621  *
7622  * @params[in] F1AP message
7623  * @return ROK/RFAILED
7624  *
7625  * ****************************************************************/
7626
7627 uint8_t extractMacRbCfg(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbCfg,\
7628 DRBs_ToBeSetupMod_Item_t *drbSetupModCfg,  LogicalChannelConfig_t *ulLcCfg, LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7629 {
7630    if(drbCfg != NULLP)
7631    {
7632       if(extractDrbCfg(drbCfg, NULL, lcCfg, upTnlInfo) != ROK)
7633       {
7634          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7635          return RFAILED;
7636       }
7637    }
7638    else if(drbSetupModCfg != NULLP)
7639    {
7640       if(extractDrbCfg(NULL, drbSetupModCfg, lcCfg, upTnlInfo) != ROK)
7641       {
7642          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7643          return RFAILED;
7644       }
7645    }
7646    else
7647    {
7648       lcCfg->drbQos = NULLP;
7649       lcCfg->snssai = NULLP;
7650       if(lcCfg->lcId == SRB2_LCID)
7651          lcCfg->dlLcCfg.lcp = LC_PRIORITY_3;
7652       else
7653          lcCfg->dlLcCfg.lcp = LC_PRIORITY_1;
7654    }
7655    if(ulLcCfg)
7656    {
7657       lcCfg->ulLcCfgPres = true;
7658       extractUlLcCfg(&lcCfg->ulLcCfg, ulLcCfg);
7659    }
7660    else
7661       lcCfg->ulLcCfgPres = false;
7662    return ROK;
7663 }
7664
7665 /*******************************************************************
7666  *
7667  * @brief Function processing LC config info received from CU
7668  *
7669  * @details
7670  *
7671  *    Function : procMacLcCfg
7672  *
7673  *    Functionality: Function processing LC config info received from CU
7674  *
7675  * @params[in] F1AP message
7676  * @return ROK/RFAILED
7677  *
7678  * ****************************************************************/
7679
7680 uint8_t procMacLcCfg(uint8_t lcId, uint8_t rbType, uint8_t configType,\
7681 DRBs_ToBeSetup_Item_t *drbItem, DRBs_ToBeSetupMod_Item_t *drbSetupModItem, LogicalChannelConfig_t *ulLcCfg,\
7682 LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7683 {
7684    uint8_t ret = ROK;
7685
7686    lcCfg->lcId = lcId;
7687    lcCfg->configType = configType;
7688    if(rbType == RB_TYPE_SRB)
7689    {
7690       ret = extractMacRbCfg(lcId, NULL,NULL, ulLcCfg, lcCfg, NULL);
7691    }
7692    else if(rbType == RB_TYPE_DRB)
7693    {
7694       if(drbItem != NULL)
7695         ret = extractMacRbCfg(lcId, drbItem, NULL, ulLcCfg, lcCfg, upTnlInfo);
7696       else if(drbSetupModItem != NULL)
7697         ret = extractMacRbCfg(lcId, NULL, drbSetupModItem, ulLcCfg, lcCfg, upTnlInfo);
7698    }
7699    return ret;
7700 }
7701
7702 /*******************************************************************
7703  *
7704  * @brief Function to extract Rlc cfg To Add/Mod in CellGrp Info
7705  *
7706  * @details
7707  *
7708  *    Function : extractRlcCfgToAddMod
7709  *
7710  *    Functionality: Function to extract Rlc cfg To Add/Mod in CellGrp Info
7711  *
7712  * @params[in] CellGroupConfigRrc__rlc_BearerTo pointer
7713  *             DuUeCfg Pointer
7714  * @return ROK/RFAILED
7715  *
7716  * ****************************************************************/
7717
7718 uint8_t extractRlcCfgToAddMod(struct CellGroupConfigRrc__rlc_BearerToAddModList *lcCfg, DuUeCfg *ueCfgDb)
7719 {
7720   uint8_t idx, rbId, lcId, rlcMode, rbType;
7721   RLC_Config_t *f1RlcCfg = NULLP;
7722   LogicalChannelConfig_t *macUlLcCfg = NULLP;
7723
7724   for(idx = 0; idx < lcCfg->list.count; idx++)
7725   {
7726      lcId = lcCfg->list.array[idx]->logicalChannelIdentity;
7727      if(lcCfg->list.array[idx]->servedRadioBearer)
7728      {
7729         /* RadioBearer for SRB/DRB */
7730         if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7731         RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
7732         {
7733            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.srb_Identity;
7734            rbType = RB_TYPE_SRB;
7735         }
7736         else if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7737         RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
7738         {
7739            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.drb_Identity;
7740            rbType = RB_TYPE_DRB;
7741         }
7742         else
7743         {
7744            DU_LOG("\nERROR  -->  No components present in Bearer config to ADD/MOD");
7745            return RFAILED;
7746         }
7747         /* MAC UL LC Config */
7748         if(lcCfg->list.array[idx]->mac_LogicalChannelConfig)
7749         {
7750            macUlLcCfg = lcCfg->list.array[idx]->mac_LogicalChannelConfig;
7751         }
7752      }
7753      else
7754      {
7755         DU_LOG("\nERROR  -->  DUAPP: Received RadioBearer config is NULL");
7756         return RFAILED;
7757      }
7758      /* RLC Mode Config */
7759      if(lcCfg->list.array[idx]->rlc_Config)
7760      {
7761         rlcMode  = lcCfg->list.array[idx]->rlc_Config->present;
7762         f1RlcCfg = lcCfg->list.array[idx]->rlc_Config;
7763      }
7764
7765      /* Filling RLC/MAC Config*/
7766      memset(&ueCfgDb->macLcCfg[idx], 0, sizeof(LcCfg));
7767      memset(&ueCfgDb->rlcLcCfg[idx], 0, sizeof(RlcBearerCfg));
7768      procRlcLcCfg(rbId, lcId, rbType, rlcMode, CONFIG_UNKNOWN, f1RlcCfg, &(ueCfgDb->rlcLcCfg[idx]));
7769      if(procMacLcCfg(lcId, rbType, CONFIG_UNKNOWN, NULL, NULL, macUlLcCfg, &ueCfgDb->macLcCfg[idx], NULL) != ROK)
7770      {
7771         DU_LOG("\nERROR  -->  DU APP : Failed while filling MAC LC config at extractRlcCfgToAddMod()");
7772         return RFAILED;
7773      }
7774      (ueCfgDb->numRlcLcs)++;
7775      (ueCfgDb->numMacLcs)++;
7776   }
7777   //TODO: To send the failure cause in UeContextSetupRsp
7778   return ROK;
7779 }
7780
7781 /*******************************************************************
7782  *
7783  * @brief DeAlloc pdsch serv cell config info
7784  *
7785  * @details
7786  *
7787  *    Function : freeMacPdschServCellInfo
7788  *
7789  *    Functionality: DeAlloc pdsch serv cell config info
7790  *
7791  * @params[in] PdschServCellCfg pointer
7792  * @return void
7793  *
7794  * ****************************************************************/
7795
7796 void freeMacPdschServCellInfo(PdschServCellCfg *pdsch)
7797 {
7798    if(pdsch->xOverhead)
7799    {
7800       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->xOverhead, sizeof(PdschXOverhead));
7801    }
7802    if(pdsch->codeBlkGrpFlushInd)
7803    {
7804       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->codeBlkGrpFlushInd, sizeof(bool));
7805    }
7806    if(pdsch->maxCodeBlkGrpPerTb)
7807    {
7808       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
7809    }
7810    if(pdsch->maxMimoLayers)
7811    {
7812       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxMimoLayers, sizeof(uint8_t));
7813    }
7814 }
7815
7816 /*******************************************************************
7817  *
7818  * @brief Free Serving cell Info
7819  *
7820  * @details
7821  *
7822  *    Function : freeMacServingCellInfo
7823  *
7824  *    Functionality: Free Serving cell Info
7825  *
7826  * @params[in] ServCellCfgInfo *srvCellCfg
7827  * @return void
7828  *
7829  * ****************************************************************/
7830 void freeMacServingCellInfo(ServCellCfgInfo *srvCellCfg)
7831 {
7832    freeMacPdschServCellInfo(&srvCellCfg->pdschServCellCfg);
7833    if(srvCellCfg->bwpInactivityTmr)
7834    {
7835       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
7836    }
7837 }
7838
7839 /*******************************************************************
7840  *
7841  * @brief Free cell Grp Cfg Info
7842  *
7843  * @details
7844  *
7845  *    Function : freeUeReCfgCellGrpInfo
7846  *
7847  *    Functionality: Free cell Grp Cfg Info
7848  *
7849  * @params[in] MacUeCfg*  duUeCfg
7850  * @return void
7851  *
7852  * ****************************************************************/
7853
7854 void freeUeReCfgCellGrpInfo(MacUeCfg *macUeCfg)
7855 {
7856    freeMacServingCellInfo(&macUeCfg->spCellCfg.servCellCfg);
7857 }
7858
7859 /*******************************************************************
7860  *
7861  * @brief Fills Reconfig SchReqReConfig
7862  *
7863  * @details
7864  *
7865  *    Function : extractSchReqReConfig
7866  *
7867  *    Functionality: Fills Reconfig SchReqReConfig
7868  *
7869  * @params[in] SchedulingRequestConfig_t *cuSchedReq
7870  *             SchedReqCfg*  macSchedReq
7871  * @return void
7872  *
7873  * ****************************************************************/
7874 void extractSchReqReConfig(SchedulingRequestConfig_t *cuSchedReq, SchedReqCfg *macSchedReq)
7875 {
7876    uint8_t schReqIdx = 0;
7877    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqListToAdd = NULLP;
7878    struct SchedulingRequestConfig__schedulingRequestToReleaseList *schReqListToRel = NULLP;
7879
7880    if(cuSchedReq->schedulingRequestToAddModList)
7881    {
7882       schReqListToAdd = cuSchedReq->schedulingRequestToAddModList;
7883       if(schReqListToAdd->list.count)
7884       {
7885          macSchedReq->addModListCount = schReqListToAdd->list.count;
7886          for(schReqIdx = 0; schReqIdx < schReqListToAdd->list.count; schReqIdx++)
7887          {
7888             macSchedReq->addModList[schReqIdx].schedReqId = \
7889                schReqListToAdd->list.array[schReqIdx]->schedulingRequestId;
7890             macSchedReq->addModList[schReqIdx].srProhibitTmr = \
7891                *(schReqListToAdd->list.array[schReqIdx]->sr_ProhibitTimer);
7892             macSchedReq->addModList[schReqIdx].srTransMax    =\
7893                schReqListToAdd->list.array[schReqIdx]->sr_TransMax;
7894          }
7895       }
7896    }
7897    /* Scheduling Req To release */
7898    if(cuSchedReq->schedulingRequestToReleaseList)
7899    {
7900       schReqListToRel = cuSchedReq->schedulingRequestToReleaseList;
7901       if(schReqListToRel->list.count)
7902       {
7903          macSchedReq->relListCount = schReqListToRel->list.count;
7904          for(schReqIdx = 0; schReqIdx < schReqListToRel->list.count; schReqIdx++)
7905          {
7906             macSchedReq->relList[schReqIdx] = \
7907                *schReqListToRel->list.array[schReqIdx];
7908          }
7909       }
7910    }
7911 }
7912
7913 /*******************************************************************
7914  *
7915  * @brief Fills TagReconfig
7916  *
7917  * @details
7918  *
7919  *    Function : extractTagReconfig
7920  *
7921  *    Functionality: Fills extractTagReconfig
7922  *
7923  * @params[in] TAG_Config_t *cuTagCfg
7924  *             TagCfg *macTagCfg
7925  * @return void
7926  *
7927  * ****************************************************************/
7928
7929 void extractTagReconfig(TAG_Config_t *cuTagCfg, TagCfg *macTagCfg)
7930 {
7931   uint8_t tagIdx = 0;
7932   struct TAG_Config__tag_ToAddModList  *tagListToAddMod = NULLP;
7933   struct TAG_Config__tag_ToReleaseList *tagListToRel = NULLP;
7934
7935   /* Tag config to AddMod */
7936   if(cuTagCfg->tag_ToAddModList)
7937   {
7938      tagListToAddMod = cuTagCfg->tag_ToAddModList;
7939      if(tagListToAddMod->list.count)
7940      {
7941         macTagCfg->addModListCount = tagListToAddMod->list.count;
7942         for(tagIdx = 0; tagIdx < tagListToAddMod->list.count; tagIdx++)
7943         {
7944            macTagCfg->addModList[tagIdx].tagId =\
7945               tagListToAddMod->list.array[tagIdx]->tag_Id;
7946            macTagCfg->addModList[tagIdx].timeAlignTimer = \
7947
7948               tagListToAddMod->list.array[tagIdx]->timeAlignmentTimer;
7949         }
7950      }
7951   }
7952   /* Tag config to release */
7953   if(cuTagCfg->tag_ToReleaseList)
7954   {
7955      tagListToRel = cuTagCfg->tag_ToReleaseList;
7956      if(tagListToRel->list.count)
7957      {
7958         macTagCfg->relListCount = tagListToRel->list.count;
7959         for(tagIdx = 0; tagIdx < tagListToRel->list.count; tagIdx++)
7960         {
7961            macTagCfg->relList[tagIdx] = *tagListToRel->list.array[tagIdx];
7962         }
7963      }
7964   }
7965 }
7966
7967 /*******************************************************************
7968  *
7969  * @brief Fills PdcchCfg received by CU
7970  *
7971  * @details
7972  *
7973  *    Function : extractPdcchCfg
7974  *
7975  *    Functionality: Fills PdcchCfg received  by CU
7976  *
7977  * @params[in] PDCCH_Config_t *cuPdcchCfg,
7978  *             PdcchConfig *duPdcchCfg
7979  * @return void
7980  *
7981  * ****************************************************************/
7982
7983 void extractPdcchCfg(PDCCH_Config_t *cuPdcchCfg, PdcchConfig *macPdcchCfg)
7984 {
7985    uint8_t cRsetIdx = 0;
7986    uint8_t srchSpcIdx = 0;
7987
7988    struct PDCCH_Config__controlResourceSetToAddModList *cRsetToAddModList = NULLP;
7989    struct PDCCH_Config__controlResourceSetToReleaseList *cRsetToRelList = NULLP;
7990    struct PDCCH_Config__searchSpacesToAddModList *srchSpcToAddModList = NULLP;
7991    struct PDCCH_Config__searchSpacesToReleaseList *srchSpcToRelList = NULLP;
7992
7993
7994    /* Control Resource Set To Add/Mod List */
7995    if(cuPdcchCfg->controlResourceSetToAddModList)
7996    {
7997       cRsetToAddModList = cuPdcchCfg->controlResourceSetToAddModList;
7998       if(cRsetToAddModList->list.count)
7999       {
8000          macPdcchCfg->numCRsetToAddMod = cRsetToAddModList->list.count;
8001          for(cRsetIdx = 0; cRsetIdx < cRsetToAddModList->list.count; cRsetIdx++)
8002          {
8003             macPdcchCfg->cRSetToAddModList[cRsetIdx].cRSetId = \
8004               cRsetToAddModList->list.array[cRsetIdx]->controlResourceSetId;
8005             bitStringToInt(&cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources,\
8006                macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc);
8007             macPdcchCfg->cRSetToAddModList[cRsetIdx].duration = \
8008               cRsetToAddModList->list.array[cRsetIdx]->duration;
8009
8010             macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType = \
8011               cRsetToAddModList->list.array[cRsetIdx]->cce_REG_MappingType.present;
8012             if(macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType == CCE_REG_MAPPINGTYPE_PR_INTERLEAVED)
8013             {
8014                //TODO: handle the case for Interleaved
8015             }
8016             macPdcchCfg->cRSetToAddModList[cRsetIdx].precoderGranularity = \
8017               cRsetToAddModList->list.array[cRsetIdx]->precoderGranularity;
8018             if(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID)
8019             {
8020                macPdcchCfg->cRSetToAddModList[cRsetIdx].dmrsScramblingId= \
8021                   *(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID);
8022             }
8023          }
8024       }
8025
8026    }
8027    /* Control Resource Set To Release List */
8028    if(cuPdcchCfg->controlResourceSetToReleaseList)
8029    {
8030       cRsetToRelList = cuPdcchCfg->controlResourceSetToReleaseList;
8031       if(cRsetToRelList->list.count)
8032       {
8033          macPdcchCfg->numCRsetToRel = cRsetToRelList->list.count;
8034          for(cRsetIdx = 0; cRsetIdx < cRsetToRelList->list.count; cRsetIdx++)
8035          {
8036             macPdcchCfg->cRSetToRelList[cRsetIdx] = *(cRsetToRelList->list.array[cRsetIdx]);
8037          }
8038       }
8039    }
8040
8041    /* Search space To Add/Mod List */
8042    if(cuPdcchCfg->searchSpacesToAddModList)
8043    {
8044       srchSpcToAddModList = cuPdcchCfg->searchSpacesToAddModList;
8045       if(srchSpcToAddModList->list.count)
8046       {
8047          macPdcchCfg->numSearchSpcToAddMod = srchSpcToAddModList->list.count;
8048          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToAddModList->list.count; srchSpcIdx++)
8049          {
8050             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceId =\
8051                srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceId;
8052             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].cRSetId =\
8053                *(srchSpcToAddModList->list.array[srchSpcIdx]->controlResourceSetId);
8054             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset)
8055             {
8056                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset =\
8057                   srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset->present;
8058             }
8059             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot)
8060             {
8061                bitStringToInt(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot,\
8062                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSymbolsWithinSlot);
8063             }
8064             if(srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates)
8065             {
8066               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel1 = \
8067                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel1;
8068               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel2 = \
8069                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel2;
8070               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel4 = \
8071                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel4;
8072
8073               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel8 = \
8074                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel8;
8075
8076               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel16 = \
8077                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel16;
8078             }
8079             if(srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType)
8080             {
8081                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType =\
8082                   srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->present;
8083                if(macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType == SEARCHSPACETYPE_PR_UE_SPECIFIC)
8084                {
8085                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].ueSpecificDciFormat =\
8086                      srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->choice.ue_Specific->dci_Formats;
8087                }
8088
8089             }
8090          }
8091       }
8092    }
8093    /* Search space To Rel List */
8094    if(cuPdcchCfg->searchSpacesToReleaseList)
8095    {
8096       srchSpcToRelList = cuPdcchCfg->searchSpacesToReleaseList;
8097       if(srchSpcToRelList->list.count)
8098       {
8099          macPdcchCfg->numSearchSpcToRel = srchSpcToRelList->list.count;
8100          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToRelList->list.count; srchSpcIdx++)
8101          {
8102             macPdcchCfg->searchSpcToRelList[srchSpcIdx] =\
8103                *(srchSpcToRelList->list.array[srchSpcIdx]);
8104          }
8105       }
8106    }
8107 }
8108
8109 /*******************************************************************
8110  *
8111  * @brief Fills PdschCfg received by CU
8112  *
8113  * @details
8114  *
8115  *    Function : extractPdschCfg
8116  *
8117  *    Functionality: Fills PdschCfg received  by CU
8118  *
8119  * @params[in] PDSCH_Config_t *cuPdschCfg,
8120  *             PdschConfig *macPdschCfg
8121  * @return void
8122  *
8123  * ****************************************************************/
8124
8125 void extractPdschCfg(PDSCH_Config_t *cuPdschCfg, PdschConfig *macPdschCfg)
8126 {
8127    uint8_t timeDomIdx;
8128    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAlloc = NULLP;
8129
8130    if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
8131    {
8132       if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->present == \
8133          PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup)
8134       {
8135          if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup)
8136          {
8137             macPdschCfg->dmrsDlCfgForPdschMapTypeA.addPos = \
8138                *(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_AdditionalPosition);
8139          }
8140       }
8141    }
8142    macPdschCfg->resourceAllocType = cuPdschCfg->resourceAllocation;
8143    if(cuPdschCfg->pdsch_TimeDomainAllocationList)
8144    {
8145       timeDomAlloc = cuPdschCfg->pdsch_TimeDomainAllocationList;
8146       if(timeDomAlloc->present ==\
8147          PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup)
8148       {
8149          if(timeDomAlloc->choice.setup)
8150          {
8151             macPdschCfg->numTimeDomRsrcAlloc  = timeDomAlloc->choice.setup->list.count;
8152             for(timeDomIdx = 0; timeDomIdx < timeDomAlloc->choice.setup->list.count; timeDomIdx++)
8153             {
8154                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
8155                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
8156                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
8157                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8158             }
8159          }
8160       }
8161    }
8162    macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
8163    if(cuPdschCfg->maxNrofCodeWordsScheduledByDCI)
8164       macPdschCfg->numCodeWordsSchByDci = *(cuPdschCfg->maxNrofCodeWordsScheduledByDCI);
8165    if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_staticBundling)
8166    {
8167       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
8168       if(cuPdschCfg->prb_BundlingType.choice.staticBundling)
8169       {
8170          if(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize)
8171          {
8172             macPdschCfg->bundlingInfo.StaticBundling.size = \
8173                *(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize);
8174          }
8175       }
8176    }
8177    else if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_dynamicBundling)
8178    {
8179       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
8180    }
8181
8182 }
8183
8184 /*******************************************************************
8185  *
8186  * @brief Fills PdschServingCellCfg received by CU
8187  *
8188  * @details
8189  *
8190  *    Function : extractPdschServingCellCfg
8191  *
8192  *    Functionality: Fills PdschCfg received  by CU
8193  *
8194  * @params[in] PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg,
8195  *             PdschServCellCfg *macUePdschSrvCellCfg
8196  * @return ROK/RFAILED
8197  *
8198  * ****************************************************************/
8199
8200 uint8_t extractPdschServingCellCfg(PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg, PdschServCellCfg *macUePdschSrvCellCfg)
8201 {
8202    if(cuPdschSrvCellCfg->codeBlockGroupTransmission)
8203    {
8204       if(cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup)
8205       {
8206          if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
8207          {
8208             *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
8209                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
8210          }
8211          else
8212          {
8213             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
8214             if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
8215             {
8216                *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
8217                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
8218             }
8219             else
8220             {
8221                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
8222                return RFAILED;
8223             }
8224          }
8225          if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
8226          {
8227             *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
8228                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
8229          }
8230          else
8231          {
8232             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->codeBlkGrpFlushInd , sizeof(bool));
8233             if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
8234             {
8235                *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
8236                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
8237             }
8238             else
8239             {
8240                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
8241                return RFAILED;
8242             }
8243          }
8244       }
8245    }
8246    if(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH)
8247    {
8248       macUePdschSrvCellCfg->numHarqProcForPdsch = *(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH);
8249    }
8250    if(cuPdschSrvCellCfg->ext1)
8251    {
8252       if(cuPdschSrvCellCfg->ext1->maxMIMO_Layers)
8253       {
8254         if(macUePdschSrvCellCfg->maxMimoLayers)
8255         {
8256            *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
8257         }
8258         else
8259         {
8260            DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxMimoLayers, sizeof(uint8_t));
8261            if(macUePdschSrvCellCfg->maxMimoLayers)
8262            {
8263               *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
8264            }
8265            else
8266            {
8267               DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
8268               return RFAILED;
8269            }
8270         }
8271       }
8272    }
8273    if(cuPdschSrvCellCfg->xOverhead)
8274    {
8275       if(macUePdschSrvCellCfg->xOverhead)
8276       {
8277          *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
8278       }
8279       else
8280       {
8281          DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->xOverhead, sizeof(PdschXOverhead));
8282          if(macUePdschSrvCellCfg->xOverhead)
8283          {
8284             *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
8285          }
8286          else
8287          {
8288             DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
8289             return RFAILED;
8290          }
8291       }
8292    }
8293    return ROK;
8294 }
8295
8296 /*******************************************************************
8297  *
8298  * @brief Fills PuschCfg received by CU
8299  *
8300  * @details
8301  *
8302  *    Function : extractPuschCfg
8303  *
8304  *    Functionality: Fills PuschCfg received  by CU
8305  *
8306  * @params[in] BWP_UplinkDedicated__pusch_Config *cuPuschCfg,
8307  *             PuschCfg *macPuschCfg
8308  * @return void
8309  *
8310  * ****************************************************************/
8311
8312 void extractPuschCfg(struct BWP_UplinkDedicated__pusch_Config *cuPuschCfg, PuschCfg *macPuschCfg)
8313 {
8314    uint8_t timeDomIdx = 0;
8315    DMRS_UplinkConfig_t *dmrsUlCfg = NULLP;
8316    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList = NULLP;
8317
8318    if(cuPuschCfg->present == BWP_UplinkDedicated__pusch_Config_PR_setup)
8319    {
8320       if(cuPuschCfg->choice.setup)
8321       {
8322          if(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH)
8323          {
8324              macPuschCfg->dataScramblingId = \
8325                 *(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH);
8326          }
8327          if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA)
8328          {
8329             if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->present == PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup)
8330             {
8331                if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup)
8332                {
8333                   dmrsUlCfg = (cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup);
8334                   if(dmrsUlCfg->dmrs_AdditionalPosition)
8335                   {
8336                      macPuschCfg->dmrsUlCfgForPuschMapTypeA.addPos =\
8337                         *(dmrsUlCfg->dmrs_AdditionalPosition);
8338                   }
8339                   if(dmrsUlCfg->transformPrecodingDisabled)
8340                   {
8341                      if(dmrsUlCfg->transformPrecodingDisabled->scramblingID0)
8342                      {
8343                         macPuschCfg->dmrsUlCfgForPuschMapTypeA.transPrecodDisabled.scramblingId0 = \
8344                            *(dmrsUlCfg->transformPrecodingDisabled->scramblingID0);
8345                      }
8346                   }
8347                }
8348             }
8349          }
8350          /*Res Alloc Type for UL */
8351          if(cuPuschCfg->choice.setup->resourceAllocation)
8352          {
8353             macPuschCfg->resourceAllocType = \
8354                cuPuschCfg->choice.setup->resourceAllocation;
8355          }
8356          if(cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList)
8357          {
8358             timeDomAllocList = cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList;
8359             if(timeDomAllocList->present == PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup)
8360             {
8361                if(timeDomAllocList->choice.setup)
8362                {
8363                   macPuschCfg->numTimeDomRsrcAlloc = timeDomAllocList->choice.setup->list.count;
8364                   for(timeDomIdx = 0; timeDomIdx <timeDomAllocList->choice.setup->list.count; timeDomIdx++)
8365                   {
8366                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].k2 = \
8367                         *(timeDomAllocList->choice.setup->list.array[timeDomIdx]->k2);
8368                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].mappingType = \
8369                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->mappingType;
8370                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbolAndLength = \
8371                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8372                   }
8373                }
8374             }
8375          }
8376          if(cuPuschCfg->choice.setup->transformPrecoder)
8377             macPuschCfg->transformPrecoder = *(cuPuschCfg->choice.setup->transformPrecoder);
8378       }
8379    }
8380 }
8381
8382 /*******************************************************************
8383  *
8384  * @brief Function to fill pucch Power Control
8385  *
8386  * @details
8387  *
8388  *    Function : extractPucchPowerControl
8389  *
8390  *    Functionality: Function to fill pucch Power Control
8391  *
8392  * @params[in] PucchPowerControl *pwrCtrl,
8393  *             struct PUCCH_PowerControl *cuPwrCtrlCfg
8394  * @return void
8395  *
8396  * ****************************************************************/
8397
8398 void extractPucchPowerControl(PucchPowerControl *pwrCtrl, struct PUCCH_PowerControl *cuPwrCtrlCfg)
8399 {
8400    uint8_t arrIdx;
8401
8402    if(cuPwrCtrlCfg->deltaF_PUCCH_f0)
8403       pwrCtrl->deltaF_Format0 = *cuPwrCtrlCfg->deltaF_PUCCH_f0;
8404    if(cuPwrCtrlCfg->deltaF_PUCCH_f1)
8405       pwrCtrl->deltaF_Format1 = *cuPwrCtrlCfg->deltaF_PUCCH_f1;
8406    if(cuPwrCtrlCfg->deltaF_PUCCH_f2)
8407       pwrCtrl->deltaF_Format2 = *cuPwrCtrlCfg->deltaF_PUCCH_f2;
8408    if(cuPwrCtrlCfg->deltaF_PUCCH_f3)
8409       pwrCtrl->deltaF_Format3 = *cuPwrCtrlCfg->deltaF_PUCCH_f3;
8410    if(cuPwrCtrlCfg->deltaF_PUCCH_f4)
8411       pwrCtrl->deltaF_Format4 = *cuPwrCtrlCfg->deltaF_PUCCH_f4;
8412    if(cuPwrCtrlCfg->p0_Set)
8413    {
8414       pwrCtrl->p0SetCount = cuPwrCtrlCfg->p0_Set->list.count;
8415       for(arrIdx=0; arrIdx < pwrCtrl->p0SetCount; arrIdx++)
8416       {
8417          pwrCtrl->p0Set[arrIdx].p0PucchId =\
8418             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Id;
8419          pwrCtrl->p0Set[arrIdx].p0PucchVal =\
8420             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Value;
8421       }
8422    }
8423    if(cuPwrCtrlCfg->pathlossReferenceRSs)
8424    {
8425       pwrCtrl->pathLossRefRSListCount = cuPwrCtrlCfg->pathlossReferenceRSs->list.count;
8426       for(arrIdx = 0; arrIdx < pwrCtrl->pathLossRefRSListCount; arrIdx++)
8427       {
8428          pwrCtrl->pathLossRefRSList[arrIdx].pathLossRefRSId =\
8429             cuPwrCtrlCfg->pathlossReferenceRSs->list.array[arrIdx]->pucch_PathlossReferenceRS_Id;
8430       }
8431    }
8432 }
8433
8434  /*******************************************************************
8435  *
8436  * @brief Function to extractResrcSetToAddModList sent by CU
8437  *
8438  * @details
8439  *
8440  *    Function : extractResrcSetToAddModList
8441  *
8442  *    Functionality: Fucntion to extractResrcSetToAddModList
8443  *
8444  * @params[in] PucchResrcSetCfg pointer,
8445  *             struct PUCCH_Config__resourceSetToAddModList pointer
8446  * @return void
8447  *
8448  * ****************************************************************/
8449
8450 void extractResrcSetToAddModList(PucchResrcSetCfg *macRsrcSetList, struct PUCCH_Config__resourceSetToAddModList *cuRsrcSetList)
8451 {
8452    uint8_t arrIdx, rsrcListIdx;
8453
8454    macRsrcSetList->resrcSetToAddModListCount = cuRsrcSetList->list.count;
8455    for(arrIdx = 0; arrIdx < macRsrcSetList->resrcSetToAddModListCount; arrIdx++)
8456    {
8457       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcSetId     =\
8458          cuRsrcSetList->list.array[arrIdx]->pucch_ResourceSetId;
8459       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount =\
8460          cuRsrcSetList->list.array[arrIdx]->resourceList.list.count;
8461       for(rsrcListIdx = 0; rsrcListIdx < macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount; rsrcListIdx++)
8462       {
8463          macRsrcSetList->resrcSetToAddModList[arrIdx].resrcList[rsrcListIdx] =\
8464             *cuRsrcSetList->list.array[arrIdx]->resourceList.list.array[rsrcListIdx];
8465       }
8466       macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize =\
8467          *cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1;
8468    }
8469 }/* End of extractResrcSetToAddModList */
8470
8471 /*******************************************************************
8472  *
8473  * @brief Fills extractResrcToAddModList sent by CU
8474  *
8475  * @details
8476  *
8477  *    Function : extractResrcToAddModList
8478  *
8479  *    Functionality: Fills extractResrcToAddModList
8480  *
8481  * @params[in] PucchResrcCfg pointer,
8482  *             struct PUCCH_Config__resourceToAddModList pointer
8483  * @return ROk/RFAILED
8484  *
8485  * ****************************************************************/
8486
8487 uint8_t extractResrcToAddModList(PucchResrcCfg *macResrcList, struct PUCCH_Config__resourceToAddModList *cuResrcList)
8488 {
8489    uint8_t arrIdx;
8490
8491    macResrcList->resrcToAddModListCount = cuResrcList->list.count;
8492    for(arrIdx = 0; arrIdx < macResrcList->resrcToAddModListCount; arrIdx++)
8493    {
8494       macResrcList->resrcToAddModList[arrIdx].resrcId      =\
8495         cuResrcList->list.array[arrIdx]->pucch_ResourceId;
8496       macResrcList->resrcToAddModList[arrIdx].startPrb     =\
8497         cuResrcList->list.array[arrIdx]->startingPRB;
8498       if(cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping)
8499       {
8500          macResrcList->resrcToAddModList[arrIdx].intraFreqHop =\
8501            *cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping;
8502       }
8503       if(cuResrcList->list.array[arrIdx]->secondHopPRB)
8504       {
8505          macResrcList->resrcToAddModList[arrIdx].secondPrbHop =\
8506            *cuResrcList->list.array[arrIdx]->secondHopPRB;
8507       }
8508       /* PUCCH RSRC FORMAT */
8509       if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format0)
8510       {
8511          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_0;
8512          if(cuResrcList->list.array[arrIdx]->format.choice.format0)
8513          {
8514             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0, sizeof(PucchFormat0));
8515             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0 == NULLP)
8516             {
8517                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
8518                return RFAILED;
8519             }
8520             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->initialCyclicShift =\
8521                cuResrcList->list.array[arrIdx]->format.choice.format0->initialCyclicShift;
8522             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->numSymbols =\
8523                cuResrcList->list.array[arrIdx]->format.choice.format0->nrofSymbols;
8524             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->startSymbolIdx =\
8525                cuResrcList->list.array[arrIdx]->format.choice.format0->startingSymbolIndex;
8526          }
8527       }
8528       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format1)
8529       {
8530          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_1;
8531          if(cuResrcList->list.array[arrIdx]->format.choice.format1)
8532          {
8533             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1, sizeof(PucchFormat1));
8534             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1 == NULLP)
8535             {
8536                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
8537                return RFAILED;
8538             }
8539             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->initialCyclicShift =\
8540                 cuResrcList->list.array[arrIdx]->format.choice.format1->initialCyclicShift;
8541             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->numSymbols =\
8542                 cuResrcList->list.array[arrIdx]->format.choice.format1->nrofSymbols;
8543             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->startSymbolIdx =\
8544                 cuResrcList->list.array[arrIdx]->format.choice.format1->startingSymbolIndex;
8545             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->timeDomOCC =\
8546                 cuResrcList->list.array[arrIdx]->format.choice.format1->timeDomainOCC;
8547          }
8548       }
8549       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format2)
8550       {
8551          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_2;
8552          if(cuResrcList->list.array[arrIdx]->format.choice.format2)
8553          {
8554             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
8555             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2 == NULLP)
8556             {
8557                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
8558                return RFAILED;
8559             }
8560             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numPrbs =\
8561                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofPRBs;
8562             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numSymbols =\
8563                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofSymbols;
8564             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->startSymbolIdx =\
8565                 cuResrcList->list.array[arrIdx]->format.choice.format2->startingSymbolIndex;
8566          }
8567       }
8568       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format3)
8569       {
8570          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_3;
8571          if(cuResrcList->list.array[arrIdx]->format.choice.format3)
8572          {
8573             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
8574             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3 == NULLP)
8575             {
8576                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
8577                return RFAILED;
8578             }
8579             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numPrbs =\
8580                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofPRBs;
8581             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numSymbols =\
8582                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofSymbols;
8583             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->startSymbolIdx =\
8584                 cuResrcList->list.array[arrIdx]->format.choice.format3->startingSymbolIndex;
8585          }
8586       }
8587       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format4)
8588       {
8589          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_4;
8590          if(cuResrcList->list.array[arrIdx]->format.choice.format4)
8591          {
8592             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4, sizeof(PucchFormat4));
8593             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4 == NULLP)
8594             {
8595                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
8596                return RFAILED;
8597             }
8598             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->numSymbols =\
8599                 cuResrcList->list.array[arrIdx]->format.choice.format4->nrofSymbols;
8600             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occLen =\
8601                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Length;
8602             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occIdx =\
8603                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Index;
8604             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->startSymbolIdx =\
8605                 cuResrcList->list.array[arrIdx]->format.choice.format4->startingSymbolIndex;
8606          }
8607       }
8608    }
8609    return ROK;
8610
8611 }/* End of extractResrcToAddModList */
8612
8613 /*******************************************************************
8614  *
8615  * @brief Fills fillPucchSchedReqPeriodAndOffset sent by CU
8616  *
8617  * @details
8618  *
8619  *    Function : fillPucchSchedReqPeriodAndOffset
8620  *
8621  *    Functionality: To fillPucchSchedReqPeriodAndOffset
8622  *
8623  * @params[in] macPeriodicty,
8624  *     SchedulingRequestResourceConfig__periodicityAndOffset pointer
8625  * @return void
8626  *
8627  * ****************************************************************/
8628
8629 void fillPucchSchedReqPeriodAndOffset(uint8_t macPeriodicty, uint16_t  macOffset,\
8630    struct SchedulingRequestResourceConfig__periodicityAndOffset *cuPeriodicty)
8631 {
8632    macPeriodicty = cuPeriodicty->present;
8633    switch(macPeriodicty)
8634    {
8635       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
8636          {
8637             macOffset     = cuPeriodicty->choice.sym2;
8638             break;
8639          }
8640       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
8641          {
8642             macOffset     = cuPeriodicty->choice.sym6or7;
8643             break;
8644          }
8645       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
8646          {
8647             macOffset     = cuPeriodicty->choice.sl1;
8648             break;
8649          }
8650       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
8651          {
8652             macOffset = cuPeriodicty->choice.sl2;
8653             break;
8654          }
8655       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
8656          {
8657             macOffset = cuPeriodicty->choice.sl4;
8658             break;
8659          }
8660       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
8661          {
8662             macOffset = cuPeriodicty->choice.sl5;
8663             break;
8664          }
8665       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
8666          {
8667             macOffset = cuPeriodicty->choice.sl8;
8668             break;
8669          }
8670       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
8671          {
8672             macOffset = cuPeriodicty->choice.sl10;
8673             break;
8674          }
8675       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
8676          {
8677             macOffset = cuPeriodicty->choice.sl16;
8678             break;
8679          }
8680       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
8681          {
8682             macOffset = cuPeriodicty->choice.sl20;
8683             break;
8684          }
8685       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
8686          {
8687             macOffset = cuPeriodicty->choice.sl40;
8688             break;
8689          }
8690       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
8691          {
8692             macOffset = cuPeriodicty->choice.sl80;
8693             break;
8694          }
8695       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
8696          {
8697             macOffset = cuPeriodicty->choice.sl160;
8698             break;
8699          }
8700       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
8701          {
8702             macOffset = cuPeriodicty->choice.sl320;
8703             break;
8704          }
8705       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
8706          {
8707             macOffset = cuPeriodicty->choice.sl640;
8708             break;
8709          }
8710       default :
8711          DU_LOG("\nERROR  -->  F1AP : Invalid periodicity %d", macPeriodicty);
8712    }
8713 }
8714
8715 /*******************************************************************
8716  *
8717  * @brief Function to extractPucchFormatCfg sent by CU
8718  *
8719  * @details
8720  *
8721  *    Function : extractPucchFormatCfg
8722  *
8723  *    Functionality: Function to extractPucchFormatCfg
8724  *
8725  * @params[in] PucchFormatCfg pointer,
8726  *             PUCCH_FormatConfig_t pointer
8727  * @return void
8728  *
8729  * ****************************************************************/
8730
8731 void extractPucchFormatCfg(PucchFormatCfg *macFormatCfg, PUCCH_FormatConfig_t *cuFormatCfg)
8732  {
8733     if(cuFormatCfg->interslotFrequencyHopping)
8734        macFormatCfg->interSlotFreqHop = *cuFormatCfg->interslotFrequencyHopping;
8735     if(cuFormatCfg->additionalDMRS)
8736        macFormatCfg->addDmrs = *cuFormatCfg->additionalDMRS;
8737     if(cuFormatCfg->maxCodeRate)
8738        macFormatCfg->maxCodeRate = *cuFormatCfg->maxCodeRate;
8739     if(cuFormatCfg->nrofSlots)
8740        macFormatCfg->numSlots = *cuFormatCfg->nrofSlots;
8741     if(cuFormatCfg->pi2BPSK)
8742        macFormatCfg->pi2BPSK = *cuFormatCfg->pi2BPSK;
8743     if(cuFormatCfg->simultaneousHARQ_ACK_CSI)
8744        macFormatCfg->harqAckCSI = *cuFormatCfg->simultaneousHARQ_ACK_CSI;
8745  }/* End of extractPucchFormatCfg */
8746
8747 /*******************************************************************
8748  *
8749  * @brief Function to extractSchedReqCfgToAddMod sent by CU
8750  *
8751  * @details
8752  *
8753  *    Function : extractSchedReqCfgToAddMod
8754  *
8755  *    Functionality: Function to extractSchedReqCfgToAddMod
8756  *
8757  * @params[in] PucchSchedReqCfg pointer,
8758  *      PUCCH_Config__schedulingRequestResourceToAddModList pointer
8759  * @return void
8760  *
8761  * ****************************************************************/
8762
8763 void extractSchedReqCfgToAddMod(PucchSchedReqCfg *macSchedReqCfg, struct PUCCH_Config__schedulingRequestResourceToAddModList *cuSchedReqList)
8764 {
8765    uint8_t arrIdx;
8766
8767    macSchedReqCfg->schedAddModListCount = cuSchedReqList->list.count;
8768    for(arrIdx = 0; arrIdx <  macSchedReqCfg->schedAddModListCount; arrIdx++)
8769    {
8770       macSchedReqCfg->schedAddModList[arrIdx].resrcId =\
8771          cuSchedReqList->list.array[arrIdx]->schedulingRequestResourceId;
8772       macSchedReqCfg->schedAddModList[arrIdx].requestId =\
8773          cuSchedReqList->list.array[arrIdx]->schedulingRequestID;
8774       if(cuSchedReqList->list.array[arrIdx]->periodicityAndOffset)
8775       {
8776          fillPucchSchedReqPeriodAndOffset(macSchedReqCfg->schedAddModList[arrIdx].periodicity,\
8777             macSchedReqCfg->schedAddModList[arrIdx].offset, cuSchedReqList->list.array[arrIdx]->periodicityAndOffset);
8778       }
8779       if(cuSchedReqList->list.array[arrIdx]->resource)
8780       {
8781          macSchedReqCfg->schedAddModList[arrIdx].resrc =\
8782             *cuSchedReqList->list.array[arrIdx]->resource;
8783       }
8784    }
8785
8786 }/* End of extractSchedReqCfgToAddMod */
8787
8788  /*******************************************************************
8789  *
8790  * @brief Fills PucchCfg received by CU
8791  *
8792  * @details
8793  *
8794  *    Function : extractPucchCfg
8795  *
8796  *    Functionality: Fills PucchCfg received  by CU
8797  *
8798  * @params[in] BWP_UplinkDedicated__pucch_Config *cuPucchCfg,
8799  *             PucchCfg *macPucchCfg
8800  * @return ROK/RFAILED
8801  *
8802  * ****************************************************************/
8803
8804 uint8_t extractPucchCfg(struct BWP_UplinkDedicated__pucch_Config *cuPucchCfg, PucchCfg *macPucchCfg)
8805 {
8806    uint8_t arrIdx;
8807
8808    if(cuPucchCfg->present == BWP_UplinkDedicated__pucch_Config_PR_setup)
8809    {
8810       if(cuPucchCfg->choice.setup)
8811       {
8812          /* Resource Set Cfg */
8813          if(cuPucchCfg->choice.setup->resourceSetToAddModList)
8814          {
8815             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrcSet, sizeof(PucchResrcSetCfg));
8816             if(macPucchCfg->resrcSet == NULLP)
8817             {
8818                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
8819                return RFAILED;
8820             }
8821             memset(macPucchCfg->resrcSet, 0, sizeof(PucchResrcSetCfg));
8822             extractResrcSetToAddModList(macPucchCfg->resrcSet, cuPucchCfg->choice.setup->resourceSetToAddModList);
8823          }
8824
8825          /* Resource Cfg */
8826          if(cuPucchCfg->choice.setup->resourceToAddModList)
8827          {
8828             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrc, sizeof(PucchResrcCfg));
8829             if(macPucchCfg->resrc == NULLP)
8830             {
8831                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
8832                return RFAILED;
8833             }
8834             memset(macPucchCfg->resrc, 0, sizeof(PucchResrcCfg));
8835             extractResrcToAddModList(macPucchCfg->resrc, cuPucchCfg->choice.setup->resourceToAddModList);
8836          }
8837
8838          /* Format 1 Cfg */
8839          if(cuPucchCfg->choice.setup->format1)
8840          {
8841             DU_ALLOC_SHRABL_BUF(macPucchCfg->format1, sizeof(PucchFormatCfg));
8842             if(macPucchCfg->format1 == NULLP)
8843             {
8844                DU_LOG("\nERROR --> F1AP : Failed to extract format 1 Cfg in  extractPucchCfg()");
8845                return RFAILED;
8846             }
8847             memset(macPucchCfg->format1, 0, sizeof(PucchFormatCfg));
8848             extractPucchFormatCfg(macPucchCfg->format1,\
8849                cuPucchCfg->choice.setup->format1->choice.setup);
8850          }
8851
8852          /* Format 2 Cfg */
8853          if(cuPucchCfg->choice.setup->format2)
8854          {
8855             DU_ALLOC_SHRABL_BUF(macPucchCfg->format2, sizeof(PucchFormatCfg));
8856             if(macPucchCfg->format2 == NULLP)
8857             {
8858                DU_LOG("\nERROR --> F1AP : Failed to extract format 2 Cfg in  extractPucchCfg()");
8859                return RFAILED;
8860             }
8861             memset(macPucchCfg->format2, 0, sizeof(PucchFormatCfg));
8862             extractPucchFormatCfg(macPucchCfg->format2,\
8863                cuPucchCfg->choice.setup->format2->choice.setup);
8864          }
8865
8866          /* Format 3 Cfg */
8867          if(cuPucchCfg->choice.setup->format3)
8868          {
8869             DU_ALLOC_SHRABL_BUF(macPucchCfg->format3, sizeof(PucchFormatCfg));
8870             if(macPucchCfg->format3 == NULLP)
8871             {
8872                DU_LOG("\nERROR --> F1AP : Failed to extract format 3 Cfg in  extractPucchCfg()");
8873                return RFAILED;
8874             }
8875             memset(macPucchCfg->format3, 0, sizeof(PucchFormatCfg));
8876             extractPucchFormatCfg(macPucchCfg->format3,\
8877                cuPucchCfg->choice.setup->format3->choice.setup);
8878          }
8879
8880          /* Format 4 Cfg */
8881          if(cuPucchCfg->choice.setup->format4)
8882          {
8883             DU_ALLOC_SHRABL_BUF(macPucchCfg->format4, sizeof(PucchFormatCfg));
8884             if(macPucchCfg->format4 == NULLP)
8885             {
8886                DU_LOG("\nERROR --> F1AP : Failed to extract format 4 Cfg in  extractPucchCfg()");
8887                return RFAILED;
8888             }
8889             memset(macPucchCfg->format4, 0, sizeof(PucchFormatCfg));
8890             extractPucchFormatCfg(macPucchCfg->format4,\
8891                cuPucchCfg->choice.setup->format4->choice.setup);
8892          }
8893
8894          /* Sched Req List */
8895          if(cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList)
8896          {
8897             DU_ALLOC_SHRABL_BUF(macPucchCfg->schedReq, sizeof(PucchSchedReqCfg));
8898             if(macPucchCfg->schedReq == NULLP)
8899             {
8900                DU_LOG("\nERROR --> F1AP : Failed to extract schedReqCfg in  extractPucchCfg()");
8901                return RFAILED;
8902             }
8903             memset(macPucchCfg->schedReq, 0, sizeof(PucchSchedReqCfg));
8904             extractSchedReqCfgToAddMod(macPucchCfg->schedReq,\
8905             cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList);
8906          }
8907
8908          /*TODO: Add support for  Spatial Info */
8909
8910          /* MultiCsiCfg */
8911          if(cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList)
8912          {
8913             DU_ALLOC_SHRABL_BUF(macPucchCfg->multiCsiCfg, sizeof(PucchMultiCsiCfg));
8914             if(macPucchCfg->multiCsiCfg == NULLP)
8915             {
8916                DU_LOG("\nERROR --> F1AP : Failed to extract multiCsiCfg in  extractPucchCfg()");
8917                return RFAILED;
8918             }
8919             memset(macPucchCfg->multiCsiCfg, 0, sizeof(PucchMultiCsiCfg));
8920             macPucchCfg->multiCsiCfg->multiCsiResrcListCount = cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.count;
8921             for(arrIdx =0; arrIdx < macPucchCfg->multiCsiCfg->multiCsiResrcListCount; arrIdx++)
8922             {
8923                macPucchCfg->multiCsiCfg->multiCsiResrcList[arrIdx] =\
8924                  *cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.array[arrIdx];
8925             }
8926          }
8927
8928          /* Dl_DataToUL_ACK */
8929          if(cuPucchCfg->choice.setup->dl_DataToUL_ACK)
8930          {
8931             DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
8932             if(macPucchCfg->dlDataToUlAck == NULLP)
8933             {
8934                DU_LOG("\nERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
8935                return RFAILED;
8936             }
8937             memset(macPucchCfg->dlDataToUlAck, 0, sizeof(PucchDlDataToUlAck));
8938             macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount = cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.count;
8939             for(arrIdx = 0; arrIdx < macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount; arrIdx++)
8940             {
8941                macPucchCfg->dlDataToUlAck->dlDataToUlAckList[arrIdx] =\
8942                   *cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.array[arrIdx];
8943             }
8944          }
8945
8946          /* Power Control */
8947          if(cuPucchCfg->choice.setup->pucch_PowerControl)
8948          {
8949             DU_ALLOC_SHRABL_BUF(macPucchCfg->powerControl, sizeof(PucchPowerControl));
8950             if(macPucchCfg->powerControl == NULLP)
8951             {
8952                DU_LOG("\nERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
8953                return RFAILED;
8954             }
8955             extractPucchPowerControl(macPucchCfg->powerControl,\
8956                cuPucchCfg->choice.setup->pucch_PowerControl);
8957          }
8958       }
8959    }
8960    return ROK;
8961 }
8962
8963 /*******************************************************************
8964  *
8965  * @brief Fills ServingCellReconfig received by CU
8966  *
8967  * @details
8968  *
8969  *    Function : extractSpCellDedicatedCfg
8970  *
8971  *    Functionality: Fills ServingCellReconfig received  by CU
8972  *
8973  * @params[in] ServingCellConfig_t *cuSrvCellCfg
8974  *             ServCellCfgInfo *macSrvCellCfg
8975  * @return ROK/RFAILD
8976  *
8977  * ****************************************************************/
8978 uint8_t extractSpCellDedicatedCfg(ServingCellConfig_t *cuSrvCellCfg, ServCellCfgInfo *macSrvCellCfg)
8979 {
8980    uint8_t ret = ROK;
8981    BWP_DownlinkDedicated_t *dlBwp = NULLP;
8982    BWP_UplinkDedicated_t   *ulBwp = NULLP;
8983
8984    if(cuSrvCellCfg->initialDownlinkBWP)
8985    {
8986       dlBwp = ((BWP_DownlinkDedicated_t *)(cuSrvCellCfg->initialDownlinkBWP));
8987       if(dlBwp->pdcch_Config)
8988       {
8989          if(dlBwp->pdcch_Config->choice.setup)
8990          {
8991             macSrvCellCfg->initDlBwp.pdcchPresent = true;
8992             extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
8993          }
8994       }
8995       if(dlBwp->pdsch_Config)
8996       {
8997          if(dlBwp->pdsch_Config->choice.setup)
8998          {
8999             macSrvCellCfg->initDlBwp.pdschPresent = true;
9000             extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg);
9001          }
9002       }
9003    }
9004    if(cuSrvCellCfg->firstActiveDownlinkBWP_Id)
9005       macSrvCellCfg->firstActvDlBwpId = *(cuSrvCellCfg->firstActiveDownlinkBWP_Id);
9006    if(cuSrvCellCfg->defaultDownlinkBWP_Id)
9007       macSrvCellCfg->defaultDlBwpId = *(cuSrvCellCfg->defaultDownlinkBWP_Id);
9008    if(cuSrvCellCfg->bwp_InactivityTimer)
9009    {
9010       if(macSrvCellCfg->bwpInactivityTmr)
9011       {
9012          memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
9013       }
9014       else
9015       {
9016          macSrvCellCfg->bwpInactivityTmr = NULLP;
9017          DU_ALLOC_SHRABL_BUF(macSrvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
9018          if(macSrvCellCfg->bwpInactivityTmr)
9019          {
9020             memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
9021          }
9022          else
9023          {
9024             DU_LOG("\nERROR  --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
9025             return RFAILED;
9026          }
9027       }
9028    }
9029    if(cuSrvCellCfg->pdsch_ServingCellConfig)
9030    {
9031       if(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup)
9032       {
9033          ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
9034          if(ret == RFAILED)
9035          {
9036             DU_LOG("\nERROR --> F1AP : Failed at extractPdschServingCellCfg()");
9037             return RFAILED;
9038          }
9039       }
9040    }
9041    if(cuSrvCellCfg->uplinkConfig)
9042    {
9043      if(cuSrvCellCfg->uplinkConfig->initialUplinkBWP)
9044      {
9045         ulBwp = ((BWP_UplinkDedicated_t *)(cuSrvCellCfg->uplinkConfig->initialUplinkBWP));
9046         if(ulBwp->pusch_Config)
9047         {
9048            macSrvCellCfg->initUlBwp.puschPresent = true;
9049            extractPuschCfg(ulBwp->pusch_Config, &macSrvCellCfg->initUlBwp.puschCfg);
9050         }
9051         if(ulBwp->pucch_Config)
9052         {
9053            macSrvCellCfg->initUlBwp.pucchPresent = true;
9054            memset(&macSrvCellCfg->initUlBwp.pucchCfg, 0, sizeof(PucchCfg));
9055            extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg);
9056         }
9057      }
9058      if(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id)
9059         macSrvCellCfg->firstActvUlBwpId = *(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id);
9060    }
9061    return ret;
9062 }
9063 /*******************************************************************
9064  *
9065  * @brief Fills Reconfig Cell group Info received by CU
9066  *
9067  * @details
9068  *
9069  *    Function : extractUeReCfgCellInfo
9070  *
9071  *    Functionality: Fills Reconfig Cell group Info received by CU
9072  *
9073  * @params[in] CellGroupConfigRrc_t *macCellGrpCfg
9074  *             MacUeCfg*  macUeCfg
9075  * @return ROK/RFAILED
9076  *
9077  * ****************************************************************/
9078 uint8_t extractUeReCfgCellInfo(CellGroupConfigRrc_t *cellGrp, MacUeCfg *macUeCfg)
9079 {
9080    uint8_t ret = ROK;
9081    MAC_CellGroupConfig_t     *macCellGroup = NULLP;
9082    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
9083    SpCellConfig_t            *spcellCfg = NULLP;
9084    ServingCellConfig_t       *servCellCfg = NULLP;
9085
9086    if(cellGrp)
9087    {
9088       /* Fill MacCell Group Reconfig  */
9089       if(cellGrp->mac_CellGroupConfig)
9090       {
9091          macUeCfg->macCellGrpCfgPres = true;
9092          macCellGroup = ((MAC_CellGroupConfig_t *)(cellGrp->mac_CellGroupConfig));
9093          if(macCellGroup->schedulingRequestConfig)
9094          {
9095             extractSchReqReConfig(macCellGroup->schedulingRequestConfig, &macUeCfg->macCellGrpCfg.schReqCfg);
9096          }
9097          if(macCellGroup->tag_Config)
9098          {
9099             extractTagReconfig(macCellGroup->tag_Config, &macUeCfg->macCellGrpCfg.tagCfg);
9100          }
9101          if(macCellGroup->bsr_Config)
9102          {
9103             macUeCfg->macCellGrpCfg.bsrTmrCfg.periodicTimer = macCellGroup->bsr_Config->periodicBSR_Timer;
9104             macUeCfg->macCellGrpCfg.bsrTmrCfg.retxTimer     = macCellGroup->bsr_Config->retxBSR_Timer;
9105             if(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer)
9106             {
9107                macUeCfg->macCellGrpCfg.bsrTmrCfg.srDelayTimer  =\
9108                *(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer);
9109             }
9110          }
9111          if(macCellGroup->phr_Config)
9112          {
9113             if(macCellGroup->phr_Config->present == MAC_CellGroupConfig__phr_Config_PR_setup)
9114             {
9115                macUeCfg->macCellGrpCfg.phrCfgSetupPres = true;
9116                if(macCellGroup->phr_Config->choice.setup)
9117                {
9118                   macUeCfg->macCellGrpCfg.phrCfg.periodicTimer     = \
9119                   macCellGroup->phr_Config->choice.setup->phr_PeriodicTimer;
9120                   macUeCfg->macCellGrpCfg.phrCfg.prohibitTimer     = \
9121                   macCellGroup->phr_Config->choice.setup->phr_ProhibitTimer;
9122                   macUeCfg->macCellGrpCfg.phrCfg.txPowerFactor     = \
9123                   macCellGroup->phr_Config->choice.setup->phr_Tx_PowerFactorChange;
9124                   macUeCfg->macCellGrpCfg.phrCfg.multiplePHR       = \
9125                   macCellGroup->phr_Config->choice.setup->multiplePHR;
9126                   macUeCfg->macCellGrpCfg.phrCfg.dummy             = \
9127                   macCellGroup->phr_Config->choice.setup->dummy;
9128                   macUeCfg->macCellGrpCfg.phrCfg.phrType2OtherCell = \
9129                   macCellGroup->phr_Config->choice.setup->phr_Type2OtherCell;
9130                   macUeCfg->macCellGrpCfg.phrCfg.phrOtherCG        = \
9131                   macCellGroup->phr_Config->choice.setup->phr_ModeOtherCG;
9132                }
9133             }
9134          }
9135       }
9136       /* Fill Physical Cell Group Reconfig */
9137       if(cellGrp->physicalCellGroupConfig)
9138       {
9139          macUeCfg->phyCellGrpCfgPres = true;
9140          phyCellGrpCfg = ((PhysicalCellGroupConfig_t *)(cellGrp->physicalCellGroupConfig));
9141          if(phyCellGrpCfg->p_NR_FR1)
9142          {
9143             if(*(phyCellGrpCfg->p_NR_FR1) != macUeCfg->phyCellGrpCfg.pNrFr1)
9144                macUeCfg->phyCellGrpCfg.pNrFr1 = *(phyCellGrpCfg->p_NR_FR1);
9145          }
9146          macUeCfg->phyCellGrpCfg.pdschHarqAckCodebook = phyCellGrpCfg->pdsch_HARQ_ACK_Codebook;
9147       }
9148       /* Fill SpCell Reconfig */
9149       if(cellGrp->spCellConfig)
9150       {
9151          macUeCfg->spCellCfgPres = true;
9152          spcellCfg = ((SpCellConfig_t *)(cellGrp->spCellConfig));
9153          if(spcellCfg->servCellIndex)
9154          {
9155             macUeCfg->spCellCfg.servCellIdx = *(spcellCfg->servCellIndex);
9156          }
9157          /* Fill Serving cell Reconfig info */
9158          if(cellGrp->spCellConfig->spCellConfigDedicated)
9159          {
9160             servCellCfg = ((ServingCellConfig_t *)(cellGrp->spCellConfig->spCellConfigDedicated));
9161             ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg);
9162             if(ret == RFAILED)
9163             {
9164                DU_LOG("\nERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
9165             }
9166          }
9167       }
9168    }
9169    return ret;
9170 }
9171 /*******************************************************************
9172 *
9173 * @brief free the memory allocated by decoder
9174 *
9175 * @details
9176 *
9177 *    Function : freeAperDecodeNrcgi
9178 *
9179 *    Functionality: Free Nrcgi values
9180 *
9181 * @params[in] NRCGI_t *nrcgi
9182 * @return void
9183 *
9184 * ****************************************************************/
9185
9186
9187 void freeAperDecodeNrcgi(NRCGI_t *nrcgi)
9188 {
9189     if(nrcgi->pLMN_Identity.buf != NULLP)
9190     {
9191        free(nrcgi->pLMN_Identity.buf);
9192     }
9193     if(nrcgi->nRCellIdentity.buf != NULLP)
9194     {
9195        free(nrcgi->nRCellIdentity.buf);
9196     }
9197 }
9198 /*******************************************************************
9199 *
9200 * @brief free the memory allocated by decoder
9201 *
9202 * @details
9203 *
9204 *    Function : freeAperDecodeCuToDuInfo
9205 *
9206 *    Functionality:  Free Cu To Du Information
9207 *
9208 * @params[in] CUtoDURRCInformation_t *rrcMsg
9209 * @return void
9210 *
9211 * ****************************************************************/
9212
9213
9214 void freeAperDecodeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
9215 {
9216    uint8_t ieIdx =0;
9217    uint8_t arrIdx =0;
9218
9219    if(rrcMsg->uE_CapabilityRAT_ContainerList)
9220    {
9221       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
9222          free(rrcMsg->uE_CapabilityRAT_ContainerList->buf);
9223       free(rrcMsg->uE_CapabilityRAT_ContainerList);
9224    }
9225
9226    if(rrcMsg->iE_Extensions)
9227    {
9228       if(rrcMsg->iE_Extensions->list.array)
9229       {
9230          for(ieIdx= 0; ieIdx < rrcMsg->iE_Extensions->list.count; ieIdx++)
9231          {
9232             if(rrcMsg->iE_Extensions->list.array[ieIdx])
9233             {
9234                switch(rrcMsg->iE_Extensions->list.array[ieIdx]->id)
9235                {
9236                   case ProtocolIE_ID_id_CellGroupConfig:
9237                      if(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
9238                      {
9239                         free(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf);
9240                      }
9241                      break;
9242                   default:
9243                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
9244                            rrcMsg->iE_Extensions->list.array[ieIdx]->id);
9245                      break;
9246                }
9247             }
9248          }
9249          for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
9250          {
9251             free(rrcMsg->iE_Extensions->list.array[arrIdx]);
9252          }
9253          free(rrcMsg->iE_Extensions->list.array);
9254
9255       }
9256
9257       free(rrcMsg->iE_Extensions);
9258    }
9259 }
9260 /*******************************************************************
9261 *
9262 * @brief free the memory allocated by decoder
9263 *
9264 * @details
9265 *
9266 *    Function : freeAperDecodeSplCellList
9267 *
9268 *    Functionality: Free Spl Cell List
9269                     where memory allocated by aper_decoder
9270 *
9271 * @params[in]  SCell_ToBeSetup_List_t *spCellLst
9272 * @return void
9273 *
9274 * ****************************************************************/
9275
9276
9277 void freeAperDecodeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
9278 {
9279     uint8_t  cellIdx =0;
9280
9281     if(spCellLst->list.array != NULLP)
9282     {
9283        for(cellIdx=0; cellIdx<spCellLst->list.count; cellIdx++)
9284        {
9285           if(cellIdx==0&&spCellLst->list.array[cellIdx]!=NULLP)
9286           {
9287              freeAperDecodeNrcgi(&spCellLst->list.array[cellIdx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
9288           }
9289           if(spCellLst->list.array[cellIdx]!=NULLP)
9290           {
9291              free(spCellLst->list.array[cellIdx]);
9292           }
9293        }
9294        free(spCellLst->list.array);
9295     }
9296 }
9297 /*******************************************************************
9298 *
9299 * @brief free the memory allocated by decoder
9300 *
9301 * @details
9302 *
9303 *    Function : freeAperDecodeSRBSetup
9304 *
9305 *    Functionality: added free part for the memory allocated by aper_decoder
9306 *
9307 * @params[in] SRBs_ToBeSetup_List_t *srbSet
9308 * @return void
9309 *
9310 ****************************************************************/
9311
9312
9313 void freeAperDecodeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
9314 {
9315     uint8_t srbIdx =0;
9316     if(srbSet->list.array != NULLP)
9317     {
9318        for(srbIdx=0; srbIdx<srbSet->list.count; srbIdx++)
9319        {
9320           if(srbSet->list.array[srbIdx]!=NULLP)
9321           {
9322              free(srbSet->list.array[srbIdx]);
9323           }
9324        }
9325        free(srbSet->list.array);
9326     }
9327 }
9328
9329 /*******************************************************************
9330 *
9331 * @brief free the memory allocated by decoder
9332 *
9333 * @details
9334 *
9335 *    Function : freeAperDecodeULTnlInfo
9336 *
9337 *    Functionality: added free part for the memory allocated by aper_decoder
9338 *
9339 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
9340 * @return void
9341 *
9342 * ****************************************************************/
9343
9344
9345 void freeAperDecodeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
9346 {
9347    uint8_t ulIdx=0;
9348    if(ulInfo->list.array != NULLP)
9349    {
9350       for(ulIdx=0; ulIdx<ulInfo->list.count; ulIdx++)
9351       {
9352          if(ulIdx==0&&ulInfo->list.array[ulIdx]!=NULLP)
9353          {
9354             if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
9355             {
9356                if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9357                      transportLayerAddress.buf != NULLP)
9358                {
9359                   if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
9360                         !=NULLP)
9361                   {
9362                      free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf);
9363                   }
9364                   free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9365                         transportLayerAddress.buf);
9366                }
9367                free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel);
9368             }
9369          }
9370          if(ulInfo->list.array[ulIdx]!=NULLP)
9371          {
9372             free(ulInfo->list.array[ulIdx]);
9373          }
9374       }
9375       free(ulInfo->list.array);
9376    }
9377 }
9378 /*******************************************************************
9379 *
9380 * @brief free the memory allocated by decoder
9381 *
9382 * @details
9383 *
9384 *    Function : freeAperDecodeDRBSetup
9385 *
9386 *    Functionality: free DRBSetup which is allocated by decoder
9387 *
9388 * @params[in]  DRBs_ToBeSetup_List_t *drbSet
9389 * @return void
9390 *
9391 * ****************************************************************/
9392
9393 void freeAperDecodeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
9394 {
9395    DRBs_ToBeSetup_Item_t *drbSetItem = NULLP;
9396    uint8_t  flowIdx =0;
9397    uint8_t  drbIdx =0;
9398
9399    if(drbSet->list.array != NULLP)
9400    {
9401       for(drbIdx=0; drbIdx<drbSet->list.count; drbIdx++)
9402       {
9403          if(drbIdx==0&&drbSet->list.array[drbIdx] != NULLP)
9404          {
9405             drbSetItem =&drbSet->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
9406             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
9407             {
9408                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9409                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
9410                {
9411                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9412                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9413                   {
9414                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9415                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9416                      {
9417
9418                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
9419                         {
9420
9421                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
9422                            {
9423
9424                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->\
9425                                     buf!=NULLP)
9426                               {
9427
9428                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
9429                                        flows_Mapped_To_DRB_List.list.array != NULLP)
9430                                  {
9431
9432                                     for(flowIdx=0;flowIdx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9433                                           DRB_Information.flows_Mapped_To_DRB_List.list.count; flowIdx++)
9434                                     {
9435
9436                                        if(flowIdx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9437                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9438                                        {
9439                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9440                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9441                                                 qoSFlowLevelQoSParameters.\
9442                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
9443                                           {
9444                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9445                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9446                                                    qoSFlowLevelQoSParameters.\
9447                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9448                                              {
9449
9450                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9451                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9452                                                       qoSFlowLevelQoSParameters.\
9453                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9454                                                 {
9455
9456
9457                                                    free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9458                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9459                                                          qoSFlowLevelQoSParameters.\
9460                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9461                                                 }
9462
9463                                                 free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9464                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9465                                                       qoSFlowLevelQoSParameters.\
9466                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9467                                              }
9468
9469                                              free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9470
9471                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9472                                                    qoSFlowLevelQoSParameters.\
9473                                                    qoS_Characteristics.choice.non_Dynamic_5QI);
9474                                           }
9475                                        }
9476                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9477                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9478                                        {
9479
9480                                           free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9481                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]);
9482                                        }
9483                                     }
9484
9485                                     free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9486                                           DRB_Information.flows_Mapped_To_DRB_List.list.array);
9487                                  }
9488
9489                                  free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9490                                        DRB_Information.sNSSAI.sD->buf);
9491                               }
9492
9493                               free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD);
9494                            }
9495
9496                            free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf);
9497
9498                         }
9499
9500                         free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9501
9502                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9503                      }
9504
9505                      free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9506                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9507                   }
9508
9509                   free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9510                         qoS_Characteristics.choice.non_Dynamic_5QI);
9511                }
9512                free(drbSetItem->qoSInformation.choice.choice_extension);
9513             }
9514             freeAperDecodeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
9515             if(drbSetItem->uLConfiguration)
9516             {
9517                free(drbSetItem->uLConfiguration);
9518             }
9519          }
9520          if(drbSet->list.array[drbIdx]!=NULLP)
9521          {
9522             free(drbSet->list.array[drbIdx]);
9523          }
9524       }
9525       free(drbSet->list.array);
9526    }
9527 }
9528
9529
9530 /*******************************************************************
9531  *
9532  * @brief builds Mac Cell Cfg
9533  *
9534  * @details
9535  *
9536  *    Function : procUeReCfgCellInfo
9537  *
9538  *    Functionality: builds Mac Cell Cfg
9539  *
9540  * @params[in] MacUeCfg pointer
9541  *             void pointer
9542  *
9543  * @return void
9544  *
9545  * ****************************************************************/
9546 uint8_t procUeReCfgCellInfo(MacUeCfg *macUeCfg, void *cellInfo)
9547 {
9548    uint8_t ret = ROK;
9549    CellGroupConfigRrc_t *cellGrp = NULLP;
9550
9551    if(cellInfo)
9552    {
9553       cellGrp = (CellGroupConfigRrc_t *)cellInfo;
9554       ret = extractUeReCfgCellInfo(cellGrp, macUeCfg);
9555       if(ret == RFAILED)
9556          DU_LOG("\nERROR  -->  F1AP : Failed at procUeReCfgCellInfo()");
9557    }
9558    if(ret == RFAILED)
9559    {
9560       freeUeReCfgCellGrpInfo(macUeCfg);
9561    }
9562    return ret;
9563 }
9564
9565 /*******************************************************************
9566  *
9567  * @brief Filling modulation info in mac ue cfg
9568  *
9569  * @details
9570  *
9571  *    Function : duFillModulationDetails
9572  *
9573  *    Functionality: Filling modulation info in mac ue cfg
9574  *
9575  * @params[in] MAC UE Config to be updated
9576  *             Current UE configuration
9577  *             UE NR capability from CU
9578  * @return ROK     - success
9579  *         RFAILED - failure
9580  *
9581  * ****************************************************************/
9582 void duFillModulationDetails(MacUeCfg *ueCfg, MacUeCfg *oldUeCfg, void *ueCap)
9583 {
9584    UE_NR_Capability_t *ueNrCap=NULLP;
9585
9586    if(!ueCap)
9587    {
9588       memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9589       memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9590    }
9591    else
9592    {
9593       ueNrCap = (UE_NR_Capability_t *)ueCap;
9594
9595       /* Filling DL modulation info */
9596       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsDownlinkPerCC && \
9597          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0] && \
9598          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL)
9599       {
9600          switch(*(ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL))
9601          {
9602             case ModulationOrder_qpsk:
9603                {
9604                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
9605                   break;
9606                }
9607             case ModulationOrder_qam16:
9608                {
9609                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM16;
9610                   break;
9611                }
9612             case ModulationOrder_qam64:
9613                {
9614                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM64;
9615                   ueCfg->dlModInfo.mcsIndex = PDSCH_MCS_INDEX;
9616                   ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64;
9617                   break;
9618                }
9619             case ModulationOrder_qam256:
9620                {
9621                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM256;
9622                   break;
9623                }
9624             default:
9625                {
9626                   DU_LOG("\nERROR  -->  DU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
9627                   memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9628                   break;
9629                }
9630          }
9631       }
9632       else
9633       {
9634          memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9635       }
9636
9637       /* Filling UL modulation info */
9638       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsUplinkPerCC && \
9639          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0] && \
9640          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL)
9641       {
9642          switch(*(ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL))
9643          {
9644             case ModulationOrder_qpsk:
9645                {
9646                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
9647                   break;
9648                }
9649             case ModulationOrder_qam16:
9650                {
9651                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM16;
9652                   ueCfg->ulModInfo.mcsIndex = PUSCH_MCS_INDEX;
9653                   ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64;
9654                   break;
9655                }
9656             case ModulationOrder_qam64:
9657                {
9658                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM64;
9659                   break;
9660                }
9661             case ModulationOrder_qam256:
9662                {
9663                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM256;
9664                   break;
9665                }
9666             default:
9667                {
9668                   DU_LOG("\nERROR  -->  DU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
9669                   memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9670                   break;
9671                }
9672          }
9673       }
9674       else
9675       {
9676          memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9677       }
9678    }
9679 }
9680
9681 /*******************************************************************
9682  *
9683  * @brief Function to extract cellGrp Info present in cutoDu cont
9684  *
9685  * @details
9686  *
9687  *    Function : extractCellGrpInfo
9688  *
9689  *    Functionality: Function to extract cellGrp Info present
9690  *                   in cutoDu cont
9691  *
9692  * @params[in] ProtocolExtensionContainer_4624P16_t pointer
9693  *
9694  * @return CellGroupConfigRrc_t *
9695  *
9696  * ****************************************************************/
9697
9698 CellGroupConfigRrc_t *extractCellGrpInfo(ProtocolExtensionContainer_4624P16_t *protocolIeExtn,\
9699       DuUeCfg *ueCfgDb)
9700 {
9701    uint8_t idx2 =0;
9702    uint16_t id =0;
9703    uint16_t recvBufLen =0;
9704    CellGroupConfigRrc_t *cellGrpCfg = NULLP;
9705    CUtoDURRCInformation_ExtIEs_t *extIeInfo = NULLP;
9706    asn_dec_rval_t rval; /* Decoder return value */
9707    memset(&rval, 0, sizeof(asn_dec_rval_t));
9708
9709    if(protocolIeExtn)
9710    {
9711       for(idx2 = 0; idx2 < protocolIeExtn->list.count; idx2++)
9712       {
9713          extIeInfo = ((CUtoDURRCInformation_ExtIEs_t *)(protocolIeExtn->list.array[idx2]));
9714          id = extIeInfo->id;
9715          switch(id)
9716          {
9717             case ProtocolIE_ID_id_CellGroupConfig:
9718             {
9719                recvBufLen = extIeInfo->extensionValue.choice.CellGroupConfig.size;
9720                /* decoding the CellGroup Buf received */
9721                DU_ALLOC(cellGrpCfg, sizeof(CellGroupConfigRrc_t));
9722                if(cellGrpCfg)
9723                {
9724                   memset(cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
9725                   rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfg,
9726                      extIeInfo->extensionValue.choice.CellGroupConfig.buf, recvBufLen, 0, 0);
9727                   if(rval.code == RC_FAIL || rval.code == RC_WMORE)
9728                   {
9729                      DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
9730                      return NULLP;
9731                   }
9732                   xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfg);
9733                   if(extractRlcCfgToAddMod(cellGrpCfg->rlc_BearerToAddModList, ueCfgDb))
9734                      return NULLP;
9735                }
9736                break;
9737             }
9738             default:
9739                DU_LOG("\nERROR  -->  F1AP : Invalid IE received CUtoDURRCInformation:%d at decodeCellGrpCfg()", id);
9740                break;
9741          }
9742       }
9743    }
9744    return cellGrpCfg;
9745 }
9746
9747 /*******************************************************************
9748  *
9749  * @brief Fills Srb List received by CU
9750  *
9751  * @details
9752  *
9753  *    Function : procSrbListToSetup
9754  *
9755  *    Functionality: Fills Srb List received  by CU
9756  *
9757  * @params[in] SRBs_ToBeSetup_Item_t *cuSrbItem
9758  *             LcCfg pointer
9759  *             RlcBearerCfg pointer
9760  * @return void
9761  *
9762  * ****************************************************************/
9763 uint8_t procSrbListToSetup(SRBs_ToBeSetup_Item_t * srbItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd)
9764 {
9765    uint8_t ret = ROK;
9766
9767    /* Filling RLC INFO */
9768    procRlcLcCfg(srbItem->sRBID, srbItem->sRBID, RB_TYPE_SRB, RLC_AM, CONFIG_ADD, NULL, rlcLcToAdd);
9769
9770    /* Filling MAC INFO */
9771    ret = procMacLcCfg(srbItem->sRBID, RB_TYPE_SRB, CONFIG_ADD, NULL,NULL, NULL, macLcToAdd, NULL);
9772    if(ret == RFAILED)
9773    {
9774       DU_LOG("\nERROR  -->  F1AP : Failed at MAC LC Cfg in procSrbListToSetup()");
9775       return ret;
9776    }
9777    return ret;
9778 }
9779
9780
9781
9782 /*******************************************************************
9783  *
9784  * @brief extract Srb List received by CU
9785  *
9786  * @details
9787  *
9788  *    Function : extractSrbListToSetup
9789  *
9790  *    Functionality: extract Srb List received by CU
9791  *                   for both MAC and RLC
9792  *
9793  * @params[in] SRBs_ToBeSetup_Item_t pointer
9794  *             DuUeCfg pointer
9795  * @return ROK/RFAIED
9796  *
9797  * ****************************************************************/
9798
9799 uint8_t extractSrbListToSetup(SRBs_ToBeSetup_List_t *srbCfg, DuUeCfg *ueCfgDb)
9800 {
9801    uint8_t ret, srbIdx;
9802    SRBs_ToBeSetup_Item_t *srbItem = NULLP;
9803
9804    if(srbCfg)
9805    {
9806       for(srbIdx = 0; srbIdx < srbCfg->list.count; srbIdx++)
9807       {
9808          srbItem = &srbCfg->list.array[srbIdx]->value.choice.SRBs_ToBeSetup_Item;
9809          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
9810          {
9811             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in MAC");
9812             ret = RFAILED;
9813             break;
9814          }
9815          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
9816          {
9817             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in RLC");
9818             ret = RFAILED;
9819             break;
9820          }
9821          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
9822          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
9823          ret = procSrbListToSetup(srbItem, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
9824             &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs]);
9825          ueCfgDb->numRlcLcs++;
9826          ueCfgDb->numMacLcs++;
9827          if(ret == RFAILED)
9828          {
9829             DU_LOG("\nERROR  -->  F1AP:  Failed at extractSrbListToSetup()");
9830             break;
9831          }
9832       }
9833    }
9834    else
9835       ret = RFAILED;
9836
9837    return ret;
9838 }
9839
9840 /*******************************************************************
9841  *
9842  * @brief Fills Drb List received by CU
9843  *
9844  * @details
9845  *
9846  *    Function : procDrbListToSetup
9847  *
9848  *    Functionality: Fills Drb List received by CU
9849  *                   for both MAC and RLC
9850  *
9851  * @params[in] SRBs_ToBeSetup_Item_t pointer
9852  *             LcCfg pointer,
9853  *             RlcBearerCfg pointer
9854  * @return void
9855  *
9856  * ****************************************************************/
9857
9858 uint8_t procDrbListToSetup(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbItem,\
9859 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd, UpTnlCfg *upTnlInfo)
9860 {
9861
9862    if(drbItem != NULLP)
9863    {
9864       /* Filling RLC INFO */
9865       procRlcLcCfg(drbItem->dRBID, lcId, RB_TYPE_DRB, drbItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd);
9866
9867       /* Filling MAC INFO */
9868       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, drbItem, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
9869       {
9870          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetup()");
9871          return RFAILED;
9872       }
9873    }
9874    else if(drbSetupModItem != NULLP)
9875    {
9876       procRlcLcCfg(drbSetupModItem->dRBID, lcId, RB_TYPE_DRB, drbSetupModItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd);
9877
9878       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, NULL, drbSetupModItem, NULL, macLcToAdd, upTnlInfo) != ROK)
9879       {
9880          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetup()");
9881          return RFAILED;
9882       }
9883    }
9884    return ROK;
9885 }
9886
9887 /*******************************************************************
9888  *
9889  * @brief extract Drb List received by CU
9890  *
9891  * @details
9892  *
9893  *    Function : extractDrbListToSetup
9894  *
9895  *    Functionality: extract Drb List received by CU
9896  *                   for both MAC and RLC
9897  *
9898  * @params[in] DRBs_ToBeSetup_Item_t pointer
9899  *             DuUeCfg pointer
9900  * @return ROK/RFAIED
9901  *
9902  * ****************************************************************/
9903
9904 uint8_t extractDrbListToSetup(uint8_t lcId, DRBs_ToBeSetup_List_t *drbCfg,DRBs_ToBeSetupMod_List_t *drbSetupModCfg,\
9905 uint8_t drbCount, DuUeCfg *ueCfgDb)
9906 {
9907    uint8_t ret, drbIdx;
9908    DRBs_ToBeSetup_Item_t *drbItem = NULLP;
9909    DRBs_ToBeSetupMod_ItemIEs_t *drbSetupModItem = NULLP;
9910
9911    ret = ROK;
9912    if(drbCount > 0)
9913    {
9914       for(drbIdx = 0; drbIdx < drbCount; drbIdx++)
9915       {
9916          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
9917          {
9918             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in MAC at extractDrbListToSetup()");
9919             ret = RFAILED;
9920             break;
9921          }
9922          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
9923          {
9924             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in RLC at extractDrbListToSetup()");
9925             ret = RFAILED;
9926             break;
9927          }
9928          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
9929          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
9930
9931          if(drbCfg != NULL)
9932          {
9933             drbItem = &drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
9934             ret = procDrbListToSetup(lcId, drbItem, NULL, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
9935                &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], &ueCfgDb->upTnlInfo[ueCfgDb->numDrb]);
9936             if(ret == RFAILED)
9937             {
9938                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetup()");
9939                break;
9940             }
9941          }
9942          else if(drbSetupModCfg != NULL)
9943          {
9944             drbSetupModItem = (DRBs_ToBeSetupMod_ItemIEs_t *) drbSetupModCfg->list.array[drbIdx];
9945             ret = procDrbListToSetup(lcId, NULL, &(drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item) ,\
9946             &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs],\
9947             &ueCfgDb->upTnlInfo[ueCfgDb->numDrb]);
9948             if(ret == RFAILED)
9949             {
9950                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetup()");
9951                break;
9952             }
9953          }
9954          ueCfgDb->numRlcLcs++;
9955          ueCfgDb->numMacLcs++;
9956          ueCfgDb->numDrb++;
9957          if(ret == RFAILED)
9958          {
9959             DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetup()");
9960             break;
9961          }
9962       }
9963    }
9964    else
9965       ret = RFAILED;
9966
9967    return ret;
9968 }
9969
9970 /*******************************************************************
9971  *
9972  * @brief Function to extract Dl RRC Msg received from CU
9973  *
9974  * @details
9975  *
9976  *    Function : extractDlRrcMsg
9977  *
9978  *    Functionality: Function to extract Dl RRC Msg received from CU
9979  *
9980  * @params[in] F1AP message
9981  * @return ROK     - success
9982  *         RFAILED - failure
9983  *
9984  * ****************************************************************/
9985
9986 uint8_t extractDlRrcMsg(uint32_t gnbDuUeF1apId, uint32_t gnbCuUeF1apId, \
9987    F1DlRrcMsg *dlRrcMsg, RRCContainer_t *rrcContainer)
9988 {
9989    uint8_t ret = ROK;
9990    dlRrcMsg->rrcMsgSize = rrcContainer->size;
9991    if(dlRrcMsg->rrcMsgSize > 0)
9992    {
9993       DU_ALLOC_SHRABL_BUF(dlRrcMsg->rrcMsgPdu, dlRrcMsg->rrcMsgSize);
9994       if(!dlRrcMsg->rrcMsgPdu)
9995       {
9996          DU_LOG("\nERROR  --> DU APP : Memory allocation failed for RRC Msg in extractDlRrcMsg()");
9997          ret = RFAILED;
9998       }
9999       else
10000       {
10001          dlRrcMsg->gnbDuUeF1apId = gnbDuUeF1apId;
10002          dlRrcMsg->gnbCuUeF1apId = gnbCuUeF1apId;
10003          dlRrcMsg->srbId = SRB1_LCID;
10004          memcpy(dlRrcMsg->rrcMsgPdu, rrcContainer->buf, dlRrcMsg->rrcMsgSize);
10005       }
10006    }
10007    return ret;
10008 }
10009
10010 /*******************************************************************
10011  *
10012  * @brief Extract UE capability info
10013  *
10014  * @details
10015  *
10016  *    Function : extractUeCapability
10017  *
10018  *    Functionality: Extract UE capability info and stores in ue Cb
10019  *
10020  * @params[in] Octet string of UE capability RAT container list
10021  * @return ROK     - success
10022  *         RFAILED - failure
10023  *
10024  * ****************************************************************/
10025 UE_NR_Capability_t *extractUeCapability(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf, DuUeCb *ueCb)
10026 {
10027    uint8_t  idx;
10028    uint16_t recvBufLen;
10029    asn_dec_rval_t rval;
10030    UE_NR_Capability_t  *ueNrCap = NULLP;
10031    UE_CapabilityRAT_ContainerListRRC_t  *ueCapRatContList = NULLP;
10032
10033    /* Decoding UE Capability RAT Container List */
10034    recvBufLen = ueCapablityListBuf->size;
10035    DU_ALLOC(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10036    if(!ueCapRatContList)
10037    {
10038       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
10039       return NULLP;
10040    }
10041    memset(ueCapRatContList, 0, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10042    memset(&rval, 0, sizeof(asn_dec_rval_t));
10043    rval = aper_decode(0, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, (void **)&ueCapRatContList,
10044           ueCapablityListBuf->buf, recvBufLen, 0, 0);
10045    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10046    {
10047       DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
10048       return NULLP;
10049    }
10050    xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, ueCapRatContList);
10051
10052    /* Free encoded buffer after decoding */
10053
10054    for(idx = 0; idx < ueCapRatContList->list.count; idx++)
10055    {
10056       if(ueCapRatContList->list.array[idx]->rat_Type == RAT_Type_nr)
10057       {
10058          /* Decoding UE NR Capability */
10059           recvBufLen = ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.size;
10060           DU_ALLOC(ueNrCap, sizeof(UE_NR_Capability_t));
10061           if(!ueNrCap)
10062           {
10063              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
10064              DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10065              return NULLP;
10066           }
10067           memset(ueNrCap, 0, sizeof(UE_NR_Capability_t));
10068           memset(&rval, 0, sizeof(asn_dec_rval_t));
10069           rval = aper_decode(0, &asn_DEF_UE_NR_Capability, (void **)&ueNrCap,
10070                  ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf, recvBufLen, 0, 0);
10071           if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10072           {
10073              DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
10074              return NULLP;
10075           }
10076           xer_fprint(stdout, &asn_DEF_UE_NR_Capability, ueNrCap);
10077
10078           /* Free encoded buffer after decoding */
10079           free(ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf);
10080       }
10081       free(ueCapRatContList->list.array[idx]);
10082    }
10083
10084    /* Free Memory*/
10085    free(ueCapRatContList->list.array);
10086    DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10087    return ueNrCap;
10088 }
10089
10090 /*******************************************************************
10091 *
10092 * @brief free UE context setup request from CU
10093 *
10094 * @details
10095 *
10096 *    Function : freeAperDecodeF1UeContextSetupReq
10097 *
10098 *    Functionality: freeing part for the memory allocated by aper_decoder
10099 *
10100 * @params[in] F1AP message
10101 * @return ROK     - success
10102 *         RFAILED - failure
10103 *
10104 * ****************************************************************/
10105 void freeAperDecodeF1UeContextSetupReq(UEContextSetupRequest_t   *ueSetReq)
10106 {
10107    uint8_t ieIdx = 0;
10108
10109    if(ueSetReq->protocolIEs.list.array != NULLP)
10110    {
10111       for(ieIdx = 0; ieIdx < ueSetReq->protocolIEs.list.count; ieIdx++)
10112       {
10113          if(ueSetReq->protocolIEs.list.array[ieIdx])
10114          {
10115             switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
10116             {
10117                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10118                   break;
10119                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10120                   break;
10121                case ProtocolIE_ID_id_SpCell_ID:
10122                   freeAperDecodeNrcgi(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
10123                   break;
10124                case ProtocolIE_ID_id_ServCellIndex:
10125                   break;
10126                case ProtocolIE_ID_id_SpCellULConfigured:
10127                   break;
10128                case ProtocolIE_ID_id_CUtoDURRCInformation:
10129
10130                   freeAperDecodeCuToDuInfo(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation);
10131                   break;
10132                case ProtocolIE_ID_id_SCell_ToBeSetup_List:
10133
10134                   freeAperDecodeSplCellList(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SCell_ToBeSetup_List);
10135                   break;
10136                case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
10137
10138                   freeAperDecodeSRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List);
10139                   break;
10140                case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
10141
10142                   freeAperDecodeDRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List);
10143                   break;
10144                case ProtocolIE_ID_id_RRCContainer:
10145                   {
10146
10147                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf != NULLP)
10148                      {
10149
10150                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
10151                      }
10152                      break;
10153                   }
10154                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10155                   break;
10156                case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
10157                   {
10158                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf)
10159                      {
10160                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf);
10161                      }
10162                      break;
10163                   }
10164                default:
10165                   DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld " ,ueSetReq->protocolIEs.list.array[ieIdx]->id);
10166             }
10167             free(ueSetReq->protocolIEs.list.array[ieIdx]);
10168          }
10169       }
10170       free(ueSetReq->protocolIEs.list.array);
10171    }
10172 }
10173 /*******************************************************************
10174  *
10175  * @brief Process UE context setup request from CU
10176  *
10177  * @details
10178  *
10179  *    Function : procF1UeContextSetupReq
10180  *
10181  *    Functionality: Process UE context setup request from CU
10182  *
10183  * @params[in] F1AP message
10184  * @return ROK     - success
10185  *         RFAILED - failure
10186  *
10187  * ****************************************************************/
10188 uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
10189 {
10190    uint8_t  ret=0, ieIdx=0, ueIdx=0, lcId=0, cellIdx=0;
10191    bool ueCbFound = false;
10192    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0, bitRateSize=0;
10193    DuUeCb   *duUeCb = NULL;
10194    UEContextSetupRequest_t   *ueSetReq = NULL;
10195    DRBs_ToBeSetup_List_t *drbCfg = NULL;
10196
10197    ret = ROK;
10198
10199    ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
10200    for(ieIdx=0; (ieIdx < ueSetReq->protocolIEs.list.count && ret == ROK); ieIdx++)
10201    {
10202       switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
10203       {
10204          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10205             {
10206                gnbCuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
10207                break;
10208             }
10209          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10210             {
10211                gnbDuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
10212                break;
10213             }
10214          case ProtocolIE_ID_id_ServCellIndex:
10215             {
10216                cellIdx = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.ServCellIndex;
10217                for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
10218                {
10219                   if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
10220                         (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
10221                   {
10222                      ueCbFound = true;
10223                      duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
10224                      DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
10225                      if(duUeCb->f1UeDb)
10226                      {
10227                         memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
10228                         duUeCb->f1UeDb->actionType = UE_CTXT_SETUP;
10229                         duUeCb->f1UeDb->cellIdx = cellIdx;
10230                      }
10231                      else
10232                      {
10233                         DU_LOG("\nERROR  -->  F1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
10234                         ret = RFAILED;
10235                      }
10236                   }
10237                   else
10238                      ueCbFound = false;
10239
10240                }
10241                if(!ueCbFound)
10242                {
10243                   DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
10244                   ret = RFAILED;
10245                }
10246                break;
10247             }
10248          case ProtocolIE_ID_id_SpCellULConfigured:
10249             /* Indicates whether the gNB-CU requests the gNB-DU to configure the uplink as no UL,
10250                UL, SUL or UL+SUL for the indicated cell for the UE */
10251             break;
10252          case ProtocolIE_ID_id_CUtoDURRCInformation:
10253             {
10254                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.uE_CapabilityRAT_ContainerList)
10255                {
10256                   duUeCb->f1UeDb->duUeCfg.ueNrCapability = \
10257                   extractUeCapability(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.\
10258                   uE_CapabilityRAT_ContainerList, duUeCb);
10259                }
10260                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.iE_Extensions)
10261                {
10262                   duUeCb->f1UeDb->duUeCfg.cellGrpCfg = extractCellGrpInfo(ueSetReq->protocolIEs.list.array[ieIdx]->\
10263                         value.choice.CUtoDURRCInformation.iE_Extensions, &duUeCb->f1UeDb->duUeCfg);
10264                   if(!duUeCb->f1UeDb->duUeCfg.cellGrpCfg)
10265                   {
10266                      DU_LOG("\nERROR  -->  F1AP: Failed to extract cell Grp Info");
10267                      //TODO: Update the failure cause in ue context Setup Response
10268                      ret = RFAILED;
10269                   }
10270                }
10271                break;
10272             }
10273          case ProtocolIE_ID_id_SCell_ToBeSetup_List:
10274             {
10275                DU_LOG("\nINFO   -->  DU_APP: Received SCell_ToBeSetup_List but  Not processing the list");
10276                break;
10277             }
10278          case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
10279             {
10280                if(extractSrbListToSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List,\
10281                &duUeCb->f1UeDb->duUeCfg))
10282                {
10283                   DU_LOG("\nERROR  -->  DU APP : Failed at extractSrbListToSetup()");
10284                   //TODO: Update the failure cause in ue context Setup Response
10285                   ret = RFAILED;
10286                }
10287                break;
10288             }
10289          case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
10290             {
10291                lcId = getDrbLcId(&duUeCb->drbBitMap);
10292                if(lcId != RFAILED)
10293                {
10294                   drbCfg = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List;
10295                   if(extractDrbListToSetup(lcId, drbCfg, NULL, drbCfg->list.count, &duUeCb->f1UeDb->duUeCfg))
10296                   {
10297                      DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetup()");
10298                      //TODO: Update the failure cause in ue context Setup Response
10299                      ret = RFAILED;
10300                   }
10301                }
10302                else
10303                   ret = RFAILED;
10304                break;
10305             }
10306          case ProtocolIE_ID_id_RRCContainer:
10307             {
10308                /* Filling Dl RRC Msg Info */
10309                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
10310                if(!duUeCb->f1UeDb->dlRrcMsg)
10311                {
10312                   DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
10313                   ret = RFAILED;
10314                }
10315                else
10316                {
10317                   duUeCb->f1UeDb->dlRrcMsgPres = true;
10318                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
10319                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
10320                         &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer);
10321                }
10322                break;
10323             }
10324          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10325             {
10326                if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
10327                {
10328                   duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
10329                }
10330                else
10331                {
10332                   DU_LOG("\nERROR  -->  Ignoring delivery report, since rrcContainer is not present");
10333                }
10334                break;
10335             }
10336          case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
10337             {
10338                /* MaximumBitRate Uplink */
10339                bitRateSize = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.size;
10340                if(bitRateSize > 0)
10341                {
10342                   DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.ambrCfg, bitRateSize);
10343                   if(!duUeCb->f1UeDb->duUeCfg.ambrCfg)
10344                   {
10345                      DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
10346                      ret = RFAILED;
10347                   }
10348                   else
10349                   {
10350                      memset(duUeCb->f1UeDb->duUeCfg.ambrCfg, 0, sizeof(AmbrCfg));
10351                      memcpy(&duUeCb->f1UeDb->duUeCfg.ambrCfg->ulBr,
10352                            ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf, bitRateSize);
10353                   }
10354                }
10355                else
10356                   ret = RFAILED;
10357                break;
10358             }
10359          default:
10360             {
10361                break;
10362             }
10363       }
10364    }
10365    if(ret == RFAILED)
10366    {
10367       /*TODO : Negative case*/
10368       // BuildAndSendUeContextSetupRsp(cellId,ueIdx);
10369       DU_LOG("\nERROR  -->  F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
10370    }
10371    else
10372       ret = duProcUeContextSetupRequest(duUeCb);
10373
10374    freeAperDecodeF1UeContextSetupReq(ueSetReq);
10375    return ret;
10376
10377 }
10378 /*******************************************************************
10379  * @brief Free the memory allocated for Dl Tunnel Info
10380  *
10381  * @details
10382  *
10383  *    Function : freeDlTnlInfo
10384  *
10385  *    Functionality:
10386  *       Free the memory allocated for Dl Tunnel Info
10387  *
10388  * @params[in] DLUPTNLInformation_ToBeSetup_List_t *
10389  * @return void
10390  *
10391  * ****************************************************************/
10392
10393 void freeDlTnlInfo(DLUPTNLInformation_ToBeSetup_List_t *tnlInfo)
10394 {
10395    uint8_t arrIdx = 0;
10396
10397    for(arrIdx=0; arrIdx < tnlInfo->list.count; arrIdx++)
10398    {
10399       DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
10400    }
10401 }
10402
10403 /*******************************************************************
10404  * @brief Free the memory allocated for DRB setup List
10405  *
10406  * @details
10407  *
10408  *    Function : freeDrbSetupList
10409  *
10410  *    Functionality:
10411  *       Free the memory allocated for DRB setup list
10412  *
10413  * @params[in] DRBs_Setup_List_t *
10414  * @return void
10415  *
10416  * ****************************************************************/
10417 void freeDrbSetupList(DRBs_Setup_List_t *drbSetupList)
10418 {
10419    uint8_t arrIdx = 0;
10420    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
10421
10422    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
10423    {
10424       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
10425       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
10426    }
10427 }
10428
10429 /*******************************************************************
10430  * @brief Free the memory allocated for UE Setup response
10431  *
10432  * @details
10433  *
10434  *    Function : FreeUeContextSetupRsp
10435  *
10436  *    Functionality:
10437  *       Free the memory allocated for UE Setup response
10438  *
10439  * @params[in] F1AP PDU for UE setup response
10440  * @return ROK     - success
10441  *         RFAILED - failure
10442  *
10443  * ****************************************************************/
10444 void FreeUeContextSetupRsp(F1AP_PDU_t *f1apMsg)
10445 {
10446    uint8_t idx;
10447    UEContextSetupResponse_t *ueSetRsp = NULLP;
10448
10449    if(f1apMsg)
10450    {
10451       if(f1apMsg->choice.successfulOutcome)
10452       {
10453          ueSetRsp = &f1apMsg->choice.successfulOutcome->value.choice.\
10454                     UEContextSetupResponse;
10455          if(ueSetRsp->protocolIEs.list.array)
10456          {
10457             for(idx = 0; idx < ueSetRsp->protocolIEs.list.count; idx++)
10458             {
10459                if(ueSetRsp->protocolIEs.list.array[idx])
10460                {
10461                   switch(ueSetRsp->protocolIEs.list.array[idx]->id)
10462                   {
10463                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10464                         break;
10465                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10466                         break;
10467                      case ProtocolIE_ID_id_DUtoCURRCInformation:
10468                         {
10469                            CellGroupConfig_t *cellGrpCfg = NULLP;
10470                            cellGrpCfg  = &ueSetRsp->protocolIEs.list.array[idx]->value.choice.\
10471                                          DUtoCURRCInformation.cellGroupConfig;
10472                            if(cellGrpCfg->buf != NULLP)
10473                            {
10474                               DU_FREE(cellGrpCfg->buf, cellGrpCfg->size);
10475                               cellGrpCfg = NULLP;
10476                            }
10477                            break;
10478                         }
10479                     case ProtocolIE_ID_id_DRBs_Setup_List:
10480                         {
10481                            freeDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
10482                            break;
10483                         }
10484                      default:
10485                         DU_LOG("\nERROR  -->  DUAPP: Invalid Id %ld at FreeUeContextSetupRsp()",\
10486                         ueSetRsp->protocolIEs.list.array[idx]->id);
10487                         break;
10488                   }
10489                   DU_FREE(ueSetRsp->protocolIEs.list.array[idx],\
10490                         sizeof(UEContextSetupResponseIEs_t));
10491                }
10492             }
10493             DU_FREE(ueSetRsp->protocolIEs.list.array, \
10494                   ueSetRsp->protocolIEs.list.size);
10495          }
10496          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
10497       }
10498       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10499    }
10500 }
10501
10502 /*******************************************************************
10503  *
10504  * @brief Builds Ue context Setup Rsp DU To CU Info
10505  *
10506  * @details
10507  *
10508  *    Function : EncodeUeCntxtDuToCuInfo
10509  *
10510  *    Functionality: Builds Ue context Setup Rsp DU To CU Info
10511  *
10512  * @params[in] CellGroupConfig_t *, CellGroupConfigRrc_t *
10513  *
10514  * @return ROK     - success
10515  *         RFAILED - failure
10516  *
10517  ******************************************************************/
10518
10519 uint8_t EncodeUeCntxtDuToCuInfo(CellGroupConfig_t *duToCuCellGrp, CellGroupConfigRrc_t *duCellGrpCfg)
10520 {
10521    asn_enc_rval_t        encRetVal;
10522
10523    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, duCellGrpCfg);
10524    memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
10525    encBufSize = 0;
10526    encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, duCellGrpCfg, PrepFinalEncBuf, encBuf);
10527    /* Encode results */
10528    if(encRetVal.encoded == ENCODE_FAIL)
10529    {
10530       DU_LOG( "\nERROR  -->  F1AP : Could not encode UeCntxtDuToCuInfo (at %s)\n",\
10531             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10532       return RFAILED;
10533    }
10534    else
10535    {
10536       DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
10537       for(int i=0; i< encBufSize; i++)
10538       {
10539          printf("%x",encBuf[i]);
10540       }
10541    }
10542    duToCuCellGrp->size = encBufSize;
10543    DU_ALLOC(duToCuCellGrp->buf, duToCuCellGrp->size);
10544    if(!duToCuCellGrp->buf)
10545    {
10546       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in UeCntxtDuToCuInfo");
10547    }
10548    memcpy(duToCuCellGrp->buf, encBuf, duToCuCellGrp->size);
10549    return ROK;
10550 }
10551
10552 /*******************************************************************
10553  *
10554  * @brief Fills Dl Gtp tunnel Info
10555  *
10556  * @details
10557  *
10558  *    Function : fillGtpTunnelforDl
10559  *
10560  *    Functionality: Fills Dl Gtp tunnel Info
10561  *
10562  * @params[in]
10563  *
10564  * @return ROK     - success
10565  *         RFAILED - failure
10566  *
10567  * ****************************************************************/
10568
10569 uint8_t fillGtpTunnelforDl(GTPTunnel_t *gtpDl, GtpTnlCfg *gtpUeCfg)
10570 {
10571    uint8_t bufSize = 0;
10572
10573    gtpDl->transportLayerAddress.size    = 4*sizeof(uint8_t);
10574    DU_ALLOC(gtpDl->transportLayerAddress.buf, gtpDl->transportLayerAddress.size);
10575    if(gtpDl->transportLayerAddress.buf == NULLP)
10576    {
10577       return RFAILED;
10578    }
10579    memcpy(gtpDl->transportLayerAddress.buf, &gtpUeCfg->dlTnlAddress, gtpDl->transportLayerAddress.size);
10580
10581    /*GTP TEID*/
10582    gtpDl->gTP_TEID.size = 4 * sizeof(uint8_t);
10583    DU_ALLOC(gtpDl->gTP_TEID.buf, gtpDl->gTP_TEID.size);
10584    if(gtpDl->gTP_TEID.buf == NULLP)
10585    {
10586       return RFAILED;
10587    }
10588    bufSize = 3; /*forming an Octect String*/
10589    fillTeIdString(bufSize, gtpUeCfg->teId, gtpDl->gTP_TEID.buf);
10590
10591    return ROK;
10592 }
10593
10594 /*******************************************************************
10595  *
10596  * @brief Fills DL Tunnel Setup List
10597  *
10598  * @details
10599  *
10600  *    Function : fillDlTnlSetupList
10601  *
10602  *    Functionality: Fills the DL Tunnel Setup List
10603  *
10604  * @params[in]
10605  *
10606  * @return ROK     - success
10607  *         RFAILED - failure
10608  *
10609  * ****************************************************************/
10610
10611 uint8_t fillDlTnlSetupList(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo, UpTnlCfg *tnlCfg)
10612 {
10613    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
10614
10615    eleCount = 1;
10616    dlTnlInfo->list.count = eleCount;
10617    dlTnlInfo->list.size = (eleCount * sizeof(DLUPTNLInformation_ToBeSetup_Item_t *));
10618
10619    /* Initialize the DL Tnl Setup List Members */
10620    DU_ALLOC(dlTnlInfo->list.array, dlTnlInfo->list.size);
10621    if(dlTnlInfo->list.array == NULLP)
10622    {
10623       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL Tnl Setup List in fillDlTnlSetupList()");
10624       ret = RFAILED;
10625    }
10626    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
10627    {
10628       DU_ALLOC(dlTnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
10629       if(dlTnlInfo->list.array[arrIdx] == NULLP)
10630       {
10631          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDlTnlSetupList()", arrIdx);
10632          return RFAILED;
10633       }
10634       dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
10635       DU_ALLOC(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
10636       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel == NULLP)
10637       {
10638          DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL tunnel info in fillDlTnlSetupList()");
10639          return RFAILED;
10640       }
10641       ret = fillGtpTunnelforDl(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel,\
10642                tnlCfg->tnlCfg1);
10643       if(ret != ROK)
10644          break;
10645    }
10646    return ret;
10647 }
10648
10649 /*******************************************************************
10650  *
10651  * @brief Fills the Drb Setup List for Ue Context Setup Response
10652  *
10653  * @details
10654  *
10655  *    Function : fillDrbSetupList
10656  *
10657  *    Functionality: Fills the Drb Setup List for Ue Context Setup Response
10658  *
10659  * @params[in]
10660  *
10661  * @return ROK     - success
10662  *         RFAILED - failure
10663  *
10664  * ****************************************************************/
10665 uint8_t fillDrbSetupList(DRBs_Setup_List_t *drbSetupList, DuUeCfg *ueCfg)
10666 {
10667    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
10668    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
10669
10670    eleCount = ueCfg->numDrb;
10671    drbSetupList->list.count = eleCount;
10672    drbSetupList->list.size = \
10673         (eleCount * sizeof(DRBs_Setup_Item_t *));
10674
10675    /* Initialize the Drb Setup List Members */
10676    DU_ALLOC(drbSetupList->list.array, drbSetupList->list.size);
10677    if(drbSetupList->list.array == NULLP)
10678    {
10679       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DRB Setup List in fillDrbSetupList()");
10680       ret = RFAILED;
10681    }
10682
10683    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
10684    {
10685       DU_ALLOC(drbSetupList->list.array[arrIdx], sizeof(DRBs_Setup_Item_t));
10686       if(drbSetupList->list.array[arrIdx] == NULLP)
10687       {
10688          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDrbSetupList()", arrIdx);
10689          return RFAILED;
10690       }
10691       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
10692       drbItemIe->id = ProtocolIE_ID_id_DRBs_Setup_Item;
10693       drbItemIe->criticality = Criticality_reject;
10694       drbItemIe->value.present = DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item;
10695       drbItemIe->value.choice.DRBs_Setup_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
10696       ret = fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List,\
10697           &ueCfg->upTnlInfo[arrIdx]);
10698       if(ret != ROK)
10699          break;
10700    }
10701    return ret;
10702 }
10703
10704 /*******************************************************************
10705  *
10706  * @brief Builds and sends the UE Setup Response
10707  *
10708  * @details
10709  *
10710  *    Function : BuildAndSendUeContextSetupRsp
10711  *
10712  *    Functionality: Constructs the UE Setup Response and sends
10713  *                   it to the DU through SCTP.
10714  *
10715  * @params[in] uint8_t cellId,uint8_t ueIdx
10716  *
10717  * @return ROK     - success
10718  *         RFAILED - failure
10719  *
10720  * ****************************************************************/
10721 uint8_t BuildAndSendUeContextSetupRsp(uint8_t cellId,uint8_t ueIdx)
10722 {
10723    uint8_t   idx, ret, cellIdx, elementCnt;
10724    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
10725    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
10726    asn_enc_rval_t  encRetVal;        /* Encoder return value */
10727    F1AP_PDU_t               *f1apMsg = NULLP;
10728    UEContextSetupResponse_t *ueSetRsp = NULLP;
10729    CellGroupConfigRrc_t     *cellGrpCfg = NULLP;
10730    DuUeCb                   *ueCb = NULLP;
10731
10732    DU_LOG("\n INFO   -->  F1AP : Building UE Context Setup Response for cellId %d, ueIdx %d\n", cellId, ueIdx);
10733
10734    while(true)
10735    {
10736       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10737       if(f1apMsg == NULLP)
10738       {
10739          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
10740          ret = RFAILED;
10741          break;
10742       }
10743
10744       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
10745       DU_ALLOC(f1apMsg->choice.successfulOutcome,
10746             sizeof(SuccessfulOutcome_t));
10747       if(f1apMsg->choice.successfulOutcome == NULLP)
10748       {
10749          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
10750          ret = RFAILED;
10751          break;
10752       }
10753
10754       f1apMsg->choice.successfulOutcome->procedureCode = \
10755                                                          ProcedureCode_id_UEContextSetup;
10756       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
10757       f1apMsg->choice.successfulOutcome->value.present = \
10758                                                          SuccessfulOutcome__value_PR_UEContextSetupResponse;
10759
10760       ueSetRsp =
10761          &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
10762       elementCnt = 4;
10763       ueSetRsp->protocolIEs.list.count = elementCnt;
10764       ueSetRsp->protocolIEs.list.size = \
10765                                         elementCnt * sizeof(UEContextSetupResponse_t *);
10766
10767       /* Initialize the UESetup members */
10768       DU_ALLOC(ueSetRsp->protocolIEs.list.array, \
10769             ueSetRsp->protocolIEs.list.size);
10770       if(ueSetRsp->protocolIEs.list.array == NULLP)
10771       {
10772          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
10773          ret = RFAILED;
10774          break;
10775       }
10776
10777       for(idx=0; idx<elementCnt; idx++)
10778       {
10779          DU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
10780                sizeof(UEContextSetupResponseIEs_t));
10781          if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
10782          {
10783             DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
10784             ret = RFAILED;
10785             break;
10786          }
10787       }
10788       /* Fetching Ue Cb Info*/
10789       GET_CELL_IDX(cellId, cellIdx);
10790       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
10791       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
10792       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
10793
10794       idx = 0;
10795       /*GNB CU UE F1AP ID*/
10796       ueSetRsp->protocolIEs.list.array[idx]->id = \
10797                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
10798       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10799       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
10800                                                              UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
10801       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
10802
10803       /*GNB DU UE F1AP ID*/
10804       idx++;
10805       ueSetRsp->protocolIEs.list.array[idx]->id = \
10806                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
10807       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10808       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
10809                                                              UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
10810       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
10811
10812
10813       /*DUtoCURRC Information */
10814       idx++;
10815       ueSetRsp->protocolIEs.list.array[idx]->id  = \
10816                                                    ProtocolIE_ID_id_DUtoCURRCInformation;
10817       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10818       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
10819                                                             UEContextSetupResponseIEs__value_PR_DUtoCURRCInformation;
10820       if(ueCb->f1UeDb)
10821       {
10822          if(ueCb->f1UeDb->duUeCfg.cellGrpCfg)
10823          {
10824             cellGrpCfg = (CellGroupConfigRrc_t*)ueCb->f1UeDb->duUeCfg.cellGrpCfg;
10825             ret = EncodeUeCntxtDuToCuInfo(&ueSetRsp->protocolIEs.list.array[idx]->value.\
10826                      choice.DUtoCURRCInformation.cellGroupConfig, cellGrpCfg);
10827             if(ret == RFAILED)
10828             {
10829                DU_LOG("\nERROR  -->  F1AP : Failed to EncodeUeCntxtDuToCuInfo in BuildAndSendUeContextSetupRsp()");
10830                freeF1UeDb(ueCb->f1UeDb);
10831                ueCb->f1UeDb = NULLP;
10832                break;
10833             }
10834          }
10835       }
10836       else
10837       {
10838          DU_LOG("\nERROR  -->  F1AP : Failed to form DUtoCU RRCInfo at BuildAndSendUeContextSetupRsp()");
10839          ret = RFAILED;
10840          break;
10841       }
10842
10843       /* Drb Setup List */
10844       idx++;
10845       ueSetRsp->protocolIEs.list.array[idx]->id  = \
10846                                  ProtocolIE_ID_id_DRBs_Setup_List;
10847       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10848       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
10849                                  UEContextSetupResponseIEs__value_PR_DRBs_Setup_List;
10850       ret = fillDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List,\
10851                &ueCb->f1UeDb->duUeCfg);
10852       if(ret == RFAILED)
10853       {
10854          DU_LOG("\nERROR  -->  F1AP : Failed to fillDrbSetupList in BuildAndSendUeContextSetupRsp()");
10855          freeF1UeDb(ueCb->f1UeDb);
10856          ueCb->f1UeDb = NULLP;
10857          break;
10858       }
10859
10860        /* Free UeContext Db created during Ue context Req */
10861        freeF1UeDb(ueCb->f1UeDb);
10862        ueCb->f1UeDb = NULLP;
10863
10864       /* TODO: To send Drb list */
10865       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10866
10867       /* Encode the UE context setup response type as APER */
10868       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
10869       encBufSize = 0;
10870       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
10871             encBuf);
10872       /* Encode results */
10873       if(encRetVal.encoded == ENCODE_FAIL)
10874       {
10875          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Response structure (at %s)\n",\
10876                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10877          ret = RFAILED;
10878          break;
10879       }
10880       else
10881       {
10882          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Setup Response\n");
10883          for(int i=0; i< encBufSize; i++)
10884          {
10885             printf("%x",encBuf[i]);
10886          }
10887       }
10888
10889       /* Sending  msg  */
10890       if(sendF1APMsg()  != ROK)
10891       {
10892          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Response failed");
10893          ret = RFAILED;
10894          break;
10895       }
10896       break;
10897    }
10898    FreeUeContextSetupRsp(f1apMsg);
10899    return ret;
10900 }/* End of BuildAndSendUeContextSetupRsp */
10901 /*******************************************************************
10902 *
10903 * @brief  Build And Send Ue Context Rsp
10904 *
10905 * @details
10906 *
10907 *    Function : BuildAndSendUeCtxtRsp
10908 *
10909 *    Functionality : Build And Send Ue Context Rsp
10910
10911 * @params[in]
10912 * @return sucess = ROK
10913 *         failure = RFAILED
10914 *
10915 * ****************************************************************/
10916 uint8_t BuildAndSendUeCtxtRsp(uint8_t cellId, uint8_t ueIdx)
10917 {
10918    uint8_t cellIdx = 0, actionType = 0;
10919
10920    GET_CELL_IDX(cellId, cellIdx);
10921    actionType = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].f1UeDb->actionType;
10922
10923    switch(actionType)
10924    {
10925       case UE_CTXT_SETUP:
10926          {
10927             BuildAndSendUeContextSetupRsp(cellId,ueIdx);
10928             break;
10929          }
10930       case UE_CTXT_MOD:
10931          {
10932             BuildAndSendUeContextModRsp(cellId, ueIdx);
10933             break;
10934          }
10935       default:
10936          DU_LOG("ERROR  -->  F1AP: Invalid Action Type %d at BuildAndSendUeCtxtRsp()", actionType);
10937          break;
10938
10939    }
10940    return ROK;
10941 }
10942
10943 /*******************************************************************
10944  *
10945  * @brief deallocating the memory of  F1reset msg
10946  *
10947  * @details
10948  *
10949  *    Function : FreeF1ResetReq
10950  *
10951  *    Functionality :
10952  *         - freeing memory of F1reset request msg
10953  *
10954  * @params[in]
10955  * @return void
10956  *
10957  *
10958  * ****************************************************************/
10959 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
10960 {
10961    uint8_t idx =0 ;
10962    Reset_t *f1ResetMsg;
10963
10964    if(f1apMsg)
10965    {
10966       if(f1apMsg->choice.initiatingMessage)
10967       {
10968          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
10969
10970          if(f1ResetMsg->protocolIEs.list.array)
10971          {
10972             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
10973             {
10974                if(f1ResetMsg->protocolIEs.list.array[idx])
10975                {
10976                   DU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
10977                }
10978             }
10979             DU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
10980          }
10981          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10982       }
10983       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10984    }
10985 }
10986 /*******************************************************************
10987  *
10988  * @brief Build and Send F1reset request
10989  *
10990  * @details
10991  *
10992  *    Function : BuildAndSendF1ResetReq
10993  *
10994  *    Functionality:
10995  *         - Build and Send F1reset request msg
10996  *
10997  * @params[in]
10998  * @return ROK     - success
10999  *         RFAILED - failure
11000  *
11001  * ****************************************************************/
11002 uint8_t BuildAndSendF1ResetReq()
11003 {
11004    uint8_t          elementCnt=0;
11005    uint8_t          idx=0;
11006    uint8_t          ret= RFAILED;
11007    Reset_t          *f1ResetMsg = NULLP;
11008    F1AP_PDU_t       *f1apMsg = NULLP;
11009    asn_enc_rval_t   encRetVal;
11010    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset request \n");
11011    do
11012    {
11013       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11014       if(f1apMsg == NULLP)
11015       {
11016          break;
11017       }
11018       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
11019       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11020       if(f1apMsg->choice.initiatingMessage == NULLP)
11021       {
11022          break;
11023       }
11024       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
11025       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
11026       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
11027
11028       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11029
11030       elementCnt = 3;
11031       f1ResetMsg->protocolIEs.list.count = elementCnt;
11032       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
11033
11034       /* Initialize the F1Setup members */
11035       DU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
11036       if(f1ResetMsg->protocolIEs.list.array == NULLP)
11037       {
11038          break;
11039       }
11040       for(idx=0; idx<elementCnt; idx++)
11041       {
11042          DU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
11043          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
11044          {
11045             break;
11046          }
11047       }
11048
11049       /*TransactionID*/
11050       idx=0;
11051       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
11052       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11053       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
11054       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
11055
11056       /*Cause*/
11057       idx++;
11058       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
11059       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
11060       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
11061       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
11062       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
11063
11064       /*Reset Type*/
11065       idx++;
11066       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
11067       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11068       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
11069       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
11070       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
11071
11072       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11073
11074       /* Encode the F1SetupRequest type as APER */
11075       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11076       encBufSize = 0;
11077       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11078             encBuf);
11079
11080       /* Encode results */
11081       if(encRetVal.encoded == ENCODE_FAIL)
11082       {
11083          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
11084                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11085          break;
11086       }
11087       else
11088       {
11089          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1Reset\n");
11090          for(idx=0; idx< encBufSize; idx++)
11091          {
11092             printf("%x",encBuf[idx]);
11093          }
11094       }
11095
11096       if(sendF1APMsg() != ROK)
11097       {
11098          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
11099          break;
11100       }
11101
11102       ret = ROK;
11103       break;
11104    }while(true);
11105
11106    FreeF1ResetReq(f1apMsg);
11107    return ret;
11108 }
11109 /*******************************************************************
11110  *
11111  * @brief Build And Send F1ResetAck
11112  *
11113  * @details
11114  *
11115  *    Function : BuildAndSendF1ResetAck
11116  *
11117  *    Functionality:
11118  *         - Build And Send  F1ResetRSP
11119  *
11120  * @return ROK     - success
11121  *         RFAILED - failure
11122  *
11123  * ****************************************************************/
11124 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
11125 {
11126    uint8_t idx;
11127    ResetAcknowledge_t *f1ResetAck;
11128
11129    if(f1apMsg)
11130    {
11131       if(f1apMsg->choice.successfulOutcome)
11132       {
11133          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
11134
11135          if(f1ResetAck->protocolIEs.list.array)
11136          {
11137             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
11138             {
11139                if(f1ResetAck->protocolIEs.list.array[idx])
11140                {
11141                   DU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
11142                }
11143             }
11144             DU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
11145          }
11146          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11147       }
11148       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11149    }
11150 }
11151
11152 /*******************************************************************
11153  *
11154  * @brief Build And Send F1ResetAck
11155  *
11156  * @details
11157  *
11158  *    Function : BuildAndSendF1ResetAck
11159  *
11160  *    Functionality:
11161  *         - Build And Send  F1ResetRSP
11162  *
11163  *  @params[in]
11164  * @return ROK     - success
11165  *         RFAILED - failure
11166  *
11167  * ****************************************************************/
11168 uint8_t BuildAndSendF1ResetAck()
11169 {
11170    uint8_t                idx = 0;
11171    uint8_t                elementCnt = 0;
11172    uint8_t                ret = RFAILED;
11173    F1AP_PDU_t             *f1apMsg = NULL;
11174    ResetAcknowledge_t     *f1ResetAck = NULLP;
11175    asn_enc_rval_t         encRetVal;
11176    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset Acknowledgment \n");
11177
11178    do{
11179       /* Allocate the memory for F1ResetRequest_t */
11180       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11181       if(f1apMsg == NULLP)
11182       {
11183          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11184          break;
11185       }
11186
11187       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
11188
11189       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11190       if(f1apMsg->choice.successfulOutcome == NULLP)
11191       {
11192          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11193          break;
11194       }
11195       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
11196       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
11197       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
11198
11199       elementCnt = 1;
11200
11201       f1ResetAck->protocolIEs.list.count = elementCnt;
11202       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
11203
11204       DU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
11205       if(f1ResetAck->protocolIEs.list.array == NULLP)
11206       {
11207          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
11208          break;
11209       }
11210
11211       for(idx=0; idx<elementCnt; idx++)
11212       {
11213          DU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
11214          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
11215          {
11216             break;
11217          }
11218       }
11219       /*TransactionID*/
11220       idx = 0;
11221       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
11222       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11223       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
11224       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
11225
11226       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11227
11228       /* Encode the F1SetupRequest type as UPER */
11229       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11230       encBufSize = 0;
11231       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
11232
11233       /* Check encode results */
11234       if(encRetVal.encoded == ENCODE_FAIL)
11235       {
11236          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
11237                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11238          break;
11239       }
11240       else
11241       {
11242          DU_LOG("\nDUBUG   -->  F1AP : Created APER encoded buffer for F1ResetAck\n");
11243          for(int i=0; i< encBufSize; i++)
11244          {
11245             printf("%x",encBuf[i]);
11246          }
11247       }
11248       /* Sending msg */
11249       if(sendF1APMsg() != ROK)
11250       {
11251          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Acknowledgement failed");
11252          break;
11253       }
11254
11255       ret = ROK;
11256       break;
11257    }while(true);
11258
11259    FreeF1ResetAck(f1apMsg);
11260    return ret;
11261 }
11262 /******************************************************************
11263 *
11264 * @brief free F1 reset msg allocated by aper_decoder
11265 *
11266 * @details
11267 *
11268 *    Function : freeAperDecodeF1ResetMsg
11269 *
11270 *    Functionality: free F1 reset msg allocated by aper_decoder
11271 *
11272 * @params[in] Reset_t *f1ResetMsg
11273 * @return void
11274 *
11275 * ****************************************************************/
11276
11277 void freeAperDecodeF1ResetMsg(Reset_t *f1ResetMsg)
11278 {
11279    uint8_t ieIdx =0;
11280    if(f1ResetMsg->protocolIEs.list.array)
11281    {
11282       for(ieIdx=0 ;ieIdx < f1ResetMsg->protocolIEs.list.count ; ieIdx++)
11283       {
11284          if(f1ResetMsg->protocolIEs.list.array[ieIdx])
11285          {
11286             free(f1ResetMsg->protocolIEs.list.array[ieIdx]);
11287          }
11288       }
11289       free(f1ResetMsg->protocolIEs.list.array);
11290    }
11291 }
11292
11293 /******************************************************************
11294  *
11295  * @brief Processes DL RRC Message Transfer  sent by CU
11296  *
11297  * @details
11298  *
11299  *    Function : procF1ResetReq
11300  *
11301  *    Functionality: Processes DL RRC Message Transfer sent by CU
11302  *
11303  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11304  * @return ROK     - success
11305  *         RFAILED - failure
11306  *
11307  * ****************************************************************/
11308 uint8_t procF1ResetReq(F1AP_PDU_t *f1apMsg)
11309 {
11310    /* we are currently not supporting Ue release. right now we are supporting only init case of fireset */
11311    uint8_t       ieIdx = 0;
11312    uint8_t        ret = ROK;
11313    Reset_t       *f1ResetMsg = NULLP;
11314
11315    DU_LOG("\nINFO   -->  Processing F1 reset request");
11316    f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11317
11318    for(ieIdx=0; ieIdx<f1ResetMsg->protocolIEs.list.count; ieIdx++)
11319    {
11320       switch(f1ResetMsg->protocolIEs.list.array[ieIdx]->id)
11321       {
11322          case ProtocolIE_ID_id_TransactionID:
11323             break;
11324
11325          case ProtocolIE_ID_id_Cause:
11326             break;
11327
11328          case ProtocolIE_ID_id_ResetType:
11329             {
11330                break;
11331             }
11332
11333          default:
11334             break;
11335       }
11336    }
11337    ret = BuildAndSendF1ResetAck();
11338    DU_LOG("\nINFO   -->  UE release is not supported for now");
11339
11340    freeAperDecodeF1ResetMsg(f1ResetMsg);
11341
11342    return ret;
11343 }
11344
11345 /*******************************************************************
11346  *
11347  * @brief free the RRC delivery report
11348  *
11349  * @details
11350  *
11351  *    Function : freeRrcDeliveryReport
11352  *
11353  *    Functionality: free the RRC delivery report
11354  *
11355  * @params[in]
11356  * @return ROK     - success
11357  *         RFAILED - failure
11358  *
11359  * ****************************************************************/
11360 void freeRrcDeliveryReport(F1AP_PDU_t  *f1apMsg )
11361 {
11362    uint8_t idx=0;
11363    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11364
11365    if(f1apMsg)
11366    {
11367       if(f1apMsg->choice.initiatingMessage)
11368       {
11369          rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11370          if(rrcDeliveryReport->protocolIEs.list.array)
11371          {
11372             for(idx =0 ;idx <rrcDeliveryReport->protocolIEs.list.count ;
11373                   idx++)
11374             {
11375                if(rrcDeliveryReport->protocolIEs.list.array[idx])
11376                {
11377                   DU_FREE(rrcDeliveryReport->protocolIEs.list.array[idx],
11378                         sizeof(RRCDeliveryReportIEs_t));
11379                }
11380             }
11381             DU_FREE(rrcDeliveryReport->protocolIEs.list.array,
11382                   rrcDeliveryReport->protocolIEs.list.size);
11383          }
11384          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11385       }
11386       DU_FREE(f1apMsg,
11387             sizeof(F1AP_PDU_t));
11388    }
11389 }
11390
11391 /*******************************************************************
11392 *
11393 * @brief Builds and sends the RRC delivery report
11394 *
11395 * @details
11396 *
11397 *    Function : BuildAndSendRrcDeliveryReport
11398 *
11399 *    Functionality: Builds and sends the RRC delivery report
11400 *
11401 * @params[in]
11402 *
11403 * @return ROK     - success
11404 *         RFAILED - failure
11405 *
11406 * ****************************************************************/
11407 uint8_t BuildAndSendRrcDeliveryReport(uint32_t gnbCuUeF1apId, \
11408    uint32_t gnbDuUeF1apId, RrcDeliveryReport *rrcDelivery)
11409 {
11410    uint8_t             ret = RFAILED;
11411    uint8_t             idx    = 0;
11412    uint8_t             idx1   = 0;
11413    uint8_t             elementCnt = 0;
11414    F1AP_PDU_t          *f1apMsg = NULLP;
11415    asn_enc_rval_t      encRetVal;
11416    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11417
11418    do{
11419
11420       DU_LOG("\nINFO   -->  F1AP : Building RRC delivery Message Transfer Message\n");
11421       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11422       if(f1apMsg == NULLP)
11423       {
11424          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11425          break;
11426       }
11427       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
11428       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11429       if(f1apMsg->choice.initiatingMessage == NULLP)
11430       {
11431          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU  failed");
11432          break;
11433       }
11434       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_RRCDeliveryReport;
11435       f1apMsg->choice.initiatingMessage->criticality   = Criticality_ignore;
11436       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RRCDeliveryReport;
11437
11438       rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11439       elementCnt = 4;
11440       rrcDeliveryReport->protocolIEs.list.count = elementCnt;
11441       rrcDeliveryReport->protocolIEs.list.size = elementCnt * sizeof(RRCDeliveryReportIEs_t *);
11442
11443       /* Initialize the F1Setup members */
11444       DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array, rrcDeliveryReport->protocolIEs.list.size);
11445       if(rrcDeliveryReport->protocolIEs.list.array == NULLP)
11446       {
11447          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRC Delivery  failed");
11448          break;
11449       }
11450       for(idx =0 ;idx <elementCnt; idx++)
11451       {
11452          DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array[idx], sizeof(RRCDeliveryReportIEs_t));
11453          if(rrcDeliveryReport->protocolIEs.list.array[idx] == NULLP)
11454          {
11455             break;
11456          }
11457       }
11458
11459       idx1 = 0;
11460
11461       /*GNB CU UE F1AP ID*/
11462       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11463       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
11464       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_CU_UE_F1AP_ID;
11465       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
11466
11467       /*GNB DU UE F1AP ID*/
11468       idx1++;
11469       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11470       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
11471       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_DU_UE_F1AP_ID;
11472       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
11473
11474       /*RRC delivery status*/
11475       idx1++;
11476       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_RRCDeliveryStatus;
11477       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
11478       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_RRCDeliveryStatus;
11479       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.delivery_status =\
11480       rrcDelivery->rrcDeliveryStatus.deliveryStatus;
11481       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.triggering_message =\
11482       rrcDelivery->rrcDeliveryStatus.triggeringMessage;
11483
11484       /* SRB ID */
11485       idx1++;
11486       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
11487       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
11488       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_SRBID;
11489       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.SRBID =  rrcDelivery->srbId;
11490
11491       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11492
11493       /* Encode the RRC DELIVERY REPORT type as APER */
11494       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11495       encBufSize = 0;
11496       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11497             encBuf);
11498
11499       /* Encode results */
11500       if(encRetVal.encoded == ENCODE_FAIL)
11501       {
11502          DU_LOG("\nERROR  -->  F1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
11503                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11504          break;
11505       }
11506       else
11507       {
11508          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for RRC Delivery Msg \n");
11509          for(idx=0; idx< encBufSize; idx++)
11510          {
11511             printf("%x",encBuf[idx]);
11512          }
11513       }
11514
11515       /* Sending msg */
11516       if(sendF1APMsg() != ROK)
11517       {
11518          DU_LOG("\nERROR  -->  F1AP : Sending RRC delivery  msg request failed");
11519          break;
11520       }
11521       ret = ROK;
11522       break;
11523
11524    }while(true);
11525
11526    freeRrcDeliveryReport(f1apMsg);
11527    return ret;
11528 }
11529
11530 /*******************************************************************
11531  *
11532  * @brief Processes cells to be activated
11533  *
11534  * @details
11535  *
11536  *    Function : extractCellsToBeActivated
11537  *
11538  *    Functionality:
11539  *      - Processes cells to be activated list received in F1SetupRsp
11540  *
11541  * @params[in] void
11542  * @return ROK     - success
11543  *         RFAILED - failure
11544  *
11545  * ****************************************************************/
11546
11547 uint8_t extractCellsToBeActivated(Cells_to_be_Activated_List_t cellsToActivate)
11548 {
11549    uint8_t  ret = ROK;
11550    uint16_t idx, nci, pci = 0;
11551    Cells_to_be_Activated_List_Item_t cell;
11552
11553    for(idx=0; idx<cellsToActivate.list.count; idx++)
11554    {
11555       nci = 0;
11556       cell = cellsToActivate.list.array[idx]->value.choice.Cells_to_be_Activated_List_Item;
11557       bitStringToInt(&cell.nRCGI.nRCellIdentity, &nci);
11558
11559       if(cell.nRPCI)
11560       {
11561          pci = *cell.nRPCI;
11562       }
11563       ret = duProcCellsToBeActivated(cell.nRCGI.pLMN_Identity.buf, nci, pci);
11564    }
11565    return ret;
11566 }
11567 /******************************************************************
11568 *
11569 * @brief Processes F1 Setup Response allocated by aper_decoder
11570 *
11571 * @details
11572 *
11573 *    Function : freeF1SetupRsp
11574 *
11575 *    Functionality: free F1 Setup Response allocated by aper_decoder
11576 *
11577 * @params[in] F1SetupResponse_t *f1SetRspMsg
11578 * @return void
11579 *
11580 * ****************************************************************/
11581
11582 void freeAperDecodeF1SetupRsp(F1SetupResponse_t *f1SetRspMsg)
11583 {
11584    uint8_t ieIdx =0;
11585    uint8_t arrIdx =0;
11586    Cells_to_be_Activated_List_t *cellToActivate =NULLP;
11587    RRC_Version_t      *rrcVer =NULLP;
11588
11589    if(f1SetRspMsg->protocolIEs.list.array)
11590    {
11591       for(ieIdx=0; ieIdx<f1SetRspMsg->protocolIEs.list.count; ieIdx++)
11592       {
11593          if(f1SetRspMsg->protocolIEs.list.array[ieIdx])
11594          {
11595             switch(f1SetRspMsg->protocolIEs.list.array[ieIdx]->id)
11596             {
11597                case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11598                   {
11599                      cellToActivate =
11600                         &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.Cells_to_be_Activated_List;
11601                      if(cellToActivate->list.array)
11602                      {
11603                         for(arrIdx=0; arrIdx<cellToActivate->list.count ; arrIdx++)
11604                         {
11605                            if(cellToActivate->list.array[arrIdx])
11606                            {
11607
11608                               if(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.\
11609                               pLMN_Identity.buf)
11610                               {
11611                                  if(cellToActivate->list.array[0]->value.choice.\
11612                                        Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf)
11613                                  {
11614                                     free(cellToActivate->list.array[0]->value.choice.\
11615                                           Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf);
11616                                  }
11617
11618                                  free(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
11619                                        nRCGI.pLMN_Identity.buf);
11620                               }
11621                               free(cellToActivate->list.array[arrIdx]);
11622                            }
11623                         }
11624                         free(cellToActivate->list.array);
11625                      }
11626                      break;
11627                   }
11628                case ProtocolIE_ID_id_TransactionID:
11629                   {
11630                      break;
11631                   }
11632                case ProtocolIE_ID_id_gNB_CU_Name:
11633                   {
11634                      free(f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_Name.buf);
11635                      break;
11636                   }
11637                case ProtocolIE_ID_id_GNB_CU_RRC_Version:
11638                   {
11639                      rrcVer = &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
11640                      if(rrcVer->latest_RRC_Version.buf)
11641                      {
11642                         if(rrcVer->iE_Extensions)
11643                         {
11644                            if(rrcVer->iE_Extensions->list.array)
11645                            {
11646                               if(rrcVer->iE_Extensions->list.array[0])
11647                               {
11648                                  if(rrcVer->iE_Extensions->list.\
11649                                        array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf)
11650                                  {
11651                                     free(rrcVer->iE_Extensions->list.\
11652                                           array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf);
11653                                  }
11654                                  free(rrcVer->iE_Extensions->list.array[0]);
11655                               }
11656                               free(rrcVer->iE_Extensions->list.array);
11657                            }
11658                            free(rrcVer->iE_Extensions);
11659                         }
11660                         free(rrcVer->latest_RRC_Version.buf);
11661                      }
11662                      break;
11663
11664                   }
11665                default:
11666                   {
11667                      DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
11668                            f1SetRspMsg->protocolIEs.list.array[ieIdx]->id);
11669                   }
11670             }
11671             free(f1SetRspMsg->protocolIEs.list.array[ieIdx]);
11672          }
11673       }
11674       free(f1SetRspMsg->protocolIEs.list.array);
11675    }
11676 }
11677 /******************************************************************
11678  *
11679  * @brief Processes F1 Setup Response sent by CU
11680  *
11681  * @details
11682  *
11683  *    Function : procF1SetupRsp
11684  *
11685  *    Functionality: Processes F1 Setup Response sent by CU
11686  *
11687  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11688  * @return ROK     - success
11689  *         RFAILED - failure
11690  *
11691  * ****************************************************************/
11692 uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg)
11693 {
11694    uint8_t ret = ROK;
11695    uint16_t idx =0;
11696    F1SetupResponse_t *f1SetRspMsg = NULLP;
11697    GNB_CU_Name_t     *cuName = NULLP;
11698    F1SetupRsp  f1SetRspDb;
11699    RRC_Version_t      *rrcVer =NULLP;
11700
11701    memset(&f1SetRspDb, 0, sizeof(F1SetupRsp));
11702
11703    DU_LOG("\nINFO   -->  F1AP : F1 Setup Response received");
11704    f1SetRspMsg = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
11705
11706    for(idx=0; idx<f1SetRspMsg->protocolIEs.list.count; idx++)
11707    {
11708       switch(f1SetRspMsg->protocolIEs.list.array[idx]->id)
11709       {
11710          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11711             {
11712                extractCellsToBeActivated(f1SetRspMsg->protocolIEs.list.array[idx]->\
11713                      value.choice.Cells_to_be_Activated_List);
11714                break;
11715             }
11716          case ProtocolIE_ID_id_TransactionID:
11717             {
11718                f1SetRspDb.transId = f1SetRspMsg->protocolIEs.list.array[idx]->\
11719                                     value.choice.TransactionID;
11720                break;
11721             }
11722          case ProtocolIE_ID_id_gNB_CU_Name:
11723             {
11724                cuName = &f1SetRspMsg->protocolIEs.list.array[idx]->\
11725                         value.choice.GNB_CU_Name;
11726                strcpy(f1SetRspDb.cuName, (const char*)cuName->buf);
11727                break;
11728             }
11729          case ProtocolIE_ID_id_GNB_CU_RRC_Version:
11730             {
11731                rrcVer = &f1SetRspMsg->protocolIEs.list.array[idx]->value.choice.RRC_Version;
11732                strcpy(f1SetRspDb.rrcVersion.rrcVer,
11733                      (const char*)rrcVer->latest_RRC_Version.buf);
11734                break;
11735             }
11736          default:
11737             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
11738                   f1SetRspMsg->protocolIEs.list.array[idx]->id);
11739       }
11740       duProcF1SetupRsp();
11741    }
11742
11743    freeAperDecodeF1SetupRsp(f1SetRspMsg);
11744    return ret;
11745 }
11746 /*******************************************************************
11747 *
11748 * @brief free GNB DU config update ack
11749 *
11750 * @details
11751 *
11752 *    Function : freeAperDecodeGnbDuAck
11753 *
11754 *    Functionality: Processes GNB DU config update ack And
11755 *                     added free part for the memory allocated by aper_decoder
11756 *
11757 * @params[in] F1AP_PDU_t ASN decoded F1AP message
11758 * @return ROK     - success
11759 *         RFAILED - failure
11760 *
11761 * ****************************************************************/
11762
11763 void freeAperDecodeGnbDuAck(GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck)
11764 {
11765    uint8_t ieIdx = 0;
11766
11767    if(gnbDuAck->protocolIEs.list.array)
11768    {
11769       for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
11770       {
11771          if(gnbDuAck->protocolIEs.list.array[ieIdx])
11772          {
11773             free(gnbDuAck->protocolIEs.list.array[ieIdx]);
11774          }
11775       }
11776       free(gnbDuAck->protocolIEs.list.array);
11777    }
11778 }
11779
11780 /*******************************************************************
11781 *
11782 * @brief Building  result of gnb-du config update ack output
11783 *
11784 * @details
11785 *
11786 *    Function : duProcGnbDuCfgUpdAckMsg
11787 *
11788 *    Functionality:
11789 *        Building output of gnb-du config update ack
11790 *
11791 * @params[in] transId
11792 * @return void
11793 *
11794 * ****************************************************************/
11795
11796 uint8_t duProcGnbDuCfgUpdAckMsg(uint8_t transId)
11797 {
11798    uint8_t  ieIdx=0, arrIdx=0;
11799    uint8_t  ueId =0 , ueIdx =0;
11800    uint16_t cellId =0, cellIdx =0, crnti=0;
11801    CmLList *f1apPduNode = NULLP;
11802    ReservedF1apPduInfo *f1apPduInfo =NULLP;
11803    F1AP_PDU_t *f1apMsgPdu = NULLP;
11804    GNBDUConfigurationUpdate_t *gnbDuConfigUpdate = NULLP;
11805    BIT_STRING_t *cellIdentity=NULLP;
11806    struct Served_Cells_To_Delete_ItemIEs *deleteItemIe=NULLP;
11807    Served_Cells_To_Delete_List_t *cellsToDelete=NULLP;
11808    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
11809
11810    DU_LOG("\nINFO   -->  DU APP: GNB-DU config update Ack received ");
11811    f1apPduNode = searchFromReservedF1apPduList(transId);
11812    f1apPduInfo = (ReservedF1apPduInfo *)f1apPduNode->node;
11813    f1apMsgPdu = (F1AP_PDU_t *)f1apPduInfo->f1apMsg;
11814
11815    if(f1apMsgPdu)
11816    {
11817       if(f1apMsgPdu->choice.initiatingMessage)
11818       {
11819          gnbDuConfigUpdate = &f1apMsgPdu->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
11820          for(ieIdx=0; ieIdx < gnbDuConfigUpdate->protocolIEs.list.count; ieIdx++)
11821          {
11822             switch(gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->id)
11823             {
11824                case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
11825                {
11826                   cellsToDelete = &gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
11827                   Served_Cells_To_Delete_List;
11828                   if(cellsToDelete->list.array)
11829                   {
11830                      if(cellsToDelete->list.array[arrIdx])
11831                      {
11832                         deleteItemIe = (Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx];
11833                         deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
11834                         if(deleteItem->oldNRCGI.nRCellIdentity.buf)
11835                         {
11836                            cellIdentity = &deleteItem->oldNRCGI.nRCellIdentity;
11837                            bitStringToInt(cellIdentity, &cellId);
11838                         }
11839                      }
11840                   }
11841
11842                   GET_CELL_IDX(cellId, cellIdx);
11843                   if(duCb.actvCellLst[cellIdx] != NULLP)
11844                   {
11845                      for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
11846                      {
11847                         crnti = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].crnti;
11848                         GET_UE_IDX(crnti,ueId);
11849                         BuildAndSendUeContextReleaseReq(cellId, ueId);
11850                      }
11851                   }
11852                   else
11853                   {
11854                      DU_LOG("ERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): CellId [%d] not found", cellId);
11855                      return RFAILED;
11856                   }
11857
11858                   break;
11859                }
11860
11861                default:
11862                   break;
11863             }
11864          }
11865       }
11866    }
11867
11868    FreeDUConfigUpdate(f1apMsgPdu);
11869    deleteFromReservedF1apPduList(f1apPduNode);
11870    return ROK;
11871 }
11872
11873 /*******************************************************************
11874 *
11875 * @brief Processes GNB DU config update ack
11876 *
11877 * @details
11878 *
11879 *    Function : procF1GNBDUCfgUpdAck
11880 *
11881 *    Functionality: added free part for the memory allocated by aper_decoder
11882 *
11883 * @params[in] F1AP_PDU_t *f1apMsg
11884 * @return void
11885 *
11886 * ****************************************************************/
11887 uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
11888 {
11889    uint8_t ieIdx=0,transId=0;
11890    GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
11891
11892    DU_LOG("\nINFO   -->  F1AP : GNB-DU config update acknowledgment");
11893    gnbDuAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
11894
11895    for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
11896    {
11897       switch(gnbDuAck->protocolIEs.list.array[ieIdx]->id)
11898       {
11899          case ProtocolIE_ID_id_TransactionID:
11900             {
11901                transId = gnbDuAck->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
11902                break;
11903             }
11904          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11905             {
11906                break;
11907             }
11908          default :
11909             {
11910                DU_LOG("\nERROR  -->  F1AP: procF1GNBDUCfgUpdAck(): Invalid IE Received: %ld", \
11911                      gnbDuAck->protocolIEs.list.array[ieIdx]->id);
11912                break;
11913             }
11914       }
11915    }
11916
11917    duProcGnbDuCfgUpdAckMsg(transId);
11918
11919 #if 0
11920    /* presently we are not supporting F1 Reset from DU to CU , we are only
11921     * supporting F1 Reset from CU to DU */
11922
11923    if(BuildAndSendF1ResetReq() != ROK)
11924    {
11925       return RFAILED;
11926    }
11927 #endif
11928
11929    freeAperDecodeGnbDuAck(gnbDuAck);
11930    return ROK;
11931 }
11932 /******************************************************************
11933 *
11934 * @brief free DL RRC Message Transfer allocated by aper_decoder
11935 *
11936 * @details
11937 *
11938 *    Function : freeAperDecodef1DlRrcMsg
11939 *
11940 *    Functionality: free DL RRC Message Transfer allocated by aper_decoder
11941 *
11942 * @params[in] DLRRCMessageTransfer_t *f1DlRrcMsg
11943 * @return ROK     - success
11944 *         RFAILED - failure
11945 *
11946 * ****************************************************************/
11947
11948 void freeAperDecodef1DlRrcMsg(DLRRCMessageTransfer_t *f1DlRrcMsg)
11949 {
11950    uint8_t ieIdx =0;
11951    RRCContainer_t *rrcContainer = NULLP;
11952
11953    if(f1DlRrcMsg->protocolIEs.list.array)
11954    {
11955       for(ieIdx=0; ieIdx<f1DlRrcMsg->protocolIEs.list.count; ieIdx++)
11956       {
11957          if(f1DlRrcMsg->protocolIEs.list.array[ieIdx])
11958          {
11959             switch(f1DlRrcMsg->protocolIEs.list.array[ieIdx]->id)
11960             {
11961                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11962                   break;
11963                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11964                   break;
11965                case ProtocolIE_ID_id_SRBID:
11966                   break;
11967                case ProtocolIE_ID_id_RRCContainer:
11968                   {
11969                      rrcContainer =&f1DlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
11970                      free(rrcContainer->buf);
11971                   }
11972                case ProtocolIE_ID_id_ExecuteDuplication:
11973                   break;
11974                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
11975                   break;
11976                   break;
11977             }
11978             free(f1DlRrcMsg->protocolIEs.list.array[ieIdx]);
11979          }
11980       }
11981       free(f1DlRrcMsg->protocolIEs.list.array);
11982    }
11983 }
11984 /******************************************************************
11985  *
11986  * @brief Processes DL RRC Message Transfer  sent by CU
11987  *
11988  * @details
11989  *
11990  *    Function : procF1DlRrcMsgTrans
11991  *
11992  *    Functionality: Processes DL RRC Message Transfer sent by CU
11993  *
11994  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11995  * @return ROK     - success
11996  *         RFAILED - failure
11997  *
11998  * ****************************************************************/
11999 uint8_t procF1DlRrcMsgTrans(F1AP_PDU_t *f1apMsg)
12000 {
12001    uint8_t  idx, ret;
12002    DLRRCMessageTransfer_t *f1DlRrcMsg = NULLP;
12003    F1DlRrcMsg dlMsg;
12004    memset(&dlMsg, 0, sizeof(F1DlRrcMsg));
12005
12006    DU_LOG("\nINFO   -->  DU_APP : DL RRC message transfer Recevied");
12007    f1DlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
12008
12009    ret = ROK;
12010
12011    for(idx=0; idx<f1DlRrcMsg->protocolIEs.list.count; idx++)
12012    {
12013       switch(f1DlRrcMsg->protocolIEs.list.array[idx]->id)
12014       {
12015          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12016             {
12017                dlMsg.gnbCuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
12018                break;
12019             }
12020          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12021             {
12022                dlMsg.gnbDuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
12023                break;
12024             }
12025          case ProtocolIE_ID_id_SRBID:
12026             {
12027                dlMsg.srbId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
12028                break;
12029             }
12030          case ProtocolIE_ID_id_ExecuteDuplication:
12031             dlMsg.execDup = true;
12032             break;
12033
12034          case ProtocolIE_ID_id_RRCContainer:
12035             {
12036                if(f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0)
12037                {
12038                   dlMsg.rrcMsgSize = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
12039                   DU_ALLOC(dlMsg.rrcMsgPdu, dlMsg.rrcMsgSize);
12040                   if(dlMsg.rrcMsgPdu)
12041                   {
12042                      memcpy(dlMsg.rrcMsgPdu, f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
12043                         dlMsg.rrcMsgSize);
12044                   }
12045                   else
12046                   {
12047                      DU_LOG("\nERROR  -->  DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
12048                      return RFAILED;
12049                   }
12050                }
12051                else
12052                {
12053                   DU_LOG("\nERROR  -->  DU_APP : RRC Container Size is invalid:%ld",\
12054                   f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
12055                   return RFAILED;
12056                }
12057                break;
12058             }
12059          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
12060             {
12061                dlMsg.deliveryStatRpt = true;
12062                break;
12063             }
12064          default:
12065             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
12066                   f1DlRrcMsg->protocolIEs.list.array[idx]->id);
12067       }
12068    }
12069
12070    ret = duProcDlRrcMsg(&dlMsg);
12071
12072    freeAperDecodef1DlRrcMsg(f1DlRrcMsg);
12073    return ret;
12074 }
12075 /*******************************************************************
12076  *
12077 * @brief Builds the DRB to be Setup Mod list
12078 *
12079 * @details
12080 *
12081 *    Function :
12082 *
12083 *    Functionality: Constructs the DRB to be Setup Mod list
12084 *
12085 * @params[in] DRBs_SetupMod_List_t *drbSet
12086 *
12087 * @return ROK     - success
12088 *         RFAILED - failure
12089 *
12090 * ****************************************************************/
12091
12092 uint8_t BuildDrbSetupModList(DRBs_SetupMod_List_t *drbSet , DuUeCfg *ueCfg)
12093 {
12094    uint8_t arrIdx =0;
12095    uint8_t drbCnt =0;
12096    struct DRBs_SetupMod_ItemIEs *drbItemIe;
12097
12098    drbCnt = 1;
12099    drbSet->list.count = drbCnt;
12100    drbSet->list.size = drbCnt * sizeof(DRBs_SetupMod_ItemIEs_t *);
12101    DU_ALLOC(drbSet->list.array, drbSet->list.size);
12102    if(drbSet->list.array == NULLP)
12103    {
12104       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
12105       return  RFAILED;
12106    }
12107    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
12108    {
12109       DU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
12110       if(drbSet->list.array[arrIdx] == NULLP)
12111       {
12112               DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
12113               return  RFAILED;
12114       }
12115
12116       drbItemIe = (struct DRBs_SetupMod_ItemIEs *)drbSet->list.array[arrIdx];
12117       drbItemIe->id = ProtocolIE_ID_id_DRBs_SetupMod_Item;
12118       drbItemIe->criticality = Criticality_reject;
12119       drbItemIe->value.present = DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item;
12120       drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
12121       if(fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List,\
12122       &ueCfg->upTnlInfo[arrIdx])!= ROK)
12123       {
12124          DU_LOG("\nERROR  -->  F1AP : Failed to fill DlTnl SetupList in BuildDrbToBeSetupModList");
12125          return RFAILED;
12126       }
12127
12128    }
12129
12130    return ROK;
12131 }
12132 /*******************************************************************
12133 * @brief Free the memory allocated for DRB setup List
12134 *
12135 * @details
12136 *
12137 *    Function : FreeDrbSetupModList
12138 *
12139 *    Functionality:
12140 *       Free the memory allocated for DRB setup list
12141 *
12142 * @params[in] DRBs_Setup_List_t *
12143 * @return void
12144 *
12145 * ****************************************************************/
12146 void FreeDrbSetupModList(DRBs_SetupMod_List_t *drbSetupList)
12147 {
12148    uint8_t arrIdx = 0;
12149    DRBs_SetupMod_ItemIEs_t *drbItemIe = NULLP;
12150
12151    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
12152    {
12153       drbItemIe = ((DRBs_SetupMod_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
12154       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
12155    }
12156 }
12157 /*******************************************************************
12158 * @brief Free the memory allocated for UE Context Mod Response
12159 *
12160 * @details
12161 *
12162 *    Function : FreeUeContextModResp
12163 *
12164 *    Functionality:
12165 *       Free the memory allocated for UE Context Mod Response
12166 *
12167 * @params[in] F1AP_PDU_t *f1apMsg
12168 * @return void
12169 *
12170 * ****************************************************************/
12171
12172 void FreeUeContextModResp(F1AP_PDU_t *f1apMsg)
12173 {
12174    uint8_t ieIdx;
12175    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
12176    if(f1apMsg)
12177    {
12178       if(f1apMsg->choice.successfulOutcome)
12179       {
12180          ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
12181          if(ueContextModifyRes->protocolIEs.list.array)
12182          {
12183             for(ieIdx=0 ; ieIdx<ueContextModifyRes->protocolIEs.list.count; ieIdx++)
12184             {
12185                if(ueContextModifyRes->protocolIEs.list.array[ieIdx])
12186                {
12187                   switch(ueContextModifyRes->protocolIEs.list.array[ieIdx]->id)
12188                   {
12189                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12190                         break;
12191                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12192                         break;
12193                      case ProtocolIE_ID_id_DRBs_SetupMod_List:
12194                         {
12195                             FreeDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
12196                             value.choice.DRBs_SetupMod_List));
12197                             break;
12198                         }
12199                   }
12200                   DU_FREE(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
12201                }
12202
12203             }
12204             DU_FREE(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
12205          }
12206          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12207       }
12208       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12209    }
12210 }
12211
12212 /*****************************************************************i
12213 *
12214 * @brief Creating the ue context modifcation response and sending
12215 *
12216 * @details
12217 *
12218 *    Function : BuildAndSendUeContextModRsp
12219 *
12220 *    Functionality:
12221 *         - Creating the ue context modifcation response
12222 *
12223 * @params[in] uint8_t cellId,uint8_t ueIdx
12224 * @return ROK     - success
12225 *         RFAILED - failure
12226 *
12227 * ****************************************************************/
12228 uint8_t BuildAndSendUeContextModRsp(uint8_t cellId,uint8_t ueIdx)
12229 {
12230    uint8_t   ieIdx = 0;
12231    uint8_t   cellIdx =0;
12232    uint8_t   elementCnt = 0;
12233    uint8_t   ret = RFAILED;
12234    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
12235    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
12236    F1AP_PDU_t *f1apMsg = NULLP;
12237    asn_enc_rval_t         encRetVal;
12238    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
12239    DuUeCb                   *ueCb = NULLP;
12240
12241    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification response\n");
12242
12243    while(1)
12244    {
12245       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12246       if(f1apMsg == NULLP)
12247       {
12248          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
12249          break;
12250       }
12251
12252       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
12253
12254       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12255       if(f1apMsg->choice.successfulOutcome == NULLP)
12256       {
12257          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
12258          break;
12259       }
12260       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextModification;
12261       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
12262       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_UEContextModificationResponse;
12263
12264       ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
12265
12266       elementCnt = 3;
12267       ueContextModifyRes->protocolIEs.list.count = elementCnt;
12268       ueContextModifyRes->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationResponse_t*);
12269
12270       /* Initialize the UE context modification members */
12271       DU_ALLOC(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
12272       if(ueContextModifyRes->protocolIEs.list.array == NULLP)
12273       {
12274          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
12275          break;
12276       }
12277
12278       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
12279       {
12280          DU_ALLOC(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
12281          if(ueContextModifyRes->protocolIEs.list.array[ieIdx] == NULLP)
12282          {
12283             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
12284             break;
12285          }
12286       }
12287
12288       /* Fetching Ue Cb Info*/
12289       GET_CELL_IDX(cellId, cellIdx);
12290       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
12291       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
12292       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
12293
12294       ieIdx=0;
12295       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
12296       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12297       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
12298       UEContextModificationResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
12299       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
12300
12301       ieIdx++;
12302       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
12303       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12304       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present=\
12305       UEContextModificationResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
12306       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
12307
12308       ieIdx++;
12309       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_SetupMod_List;
12310       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12311       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
12312       UEContextModificationResponseIEs__value_PR_DRBs_SetupMod_List;
12313       if(ueCb->f1UeDb)
12314       {
12315          ret = BuildDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
12316                   value.choice.DRBs_SetupMod_List) , &ueCb->f1UeDb->duUeCfg);
12317          if(ret != ROK)
12318          {
12319             DU_LOG( "\nERROR  -->  F1AP : Failed to build drb setupmod List ");
12320             break;
12321          }
12322          freeF1UeDb(ueCb->f1UeDb);
12323          ueCb->f1UeDb = NULLP;
12324       }
12325       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12326
12327       /* Encode the F1SetupRequest type as APER */
12328       memset(encBuf, 0, ENC_BUF_MAX_LEN);
12329       encBufSize = 0;
12330       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,encBuf);
12331
12332       /* Encode results */
12333       if(encRetVal.encoded == ENCODE_FAIL)
12334       {
12335          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
12336                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12337          ret = RFAILED;
12338          break;
12339       }
12340       else
12341       {
12342          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Modification Response\n");
12343          for(int i=0; i< encBufSize; i++)
12344          {
12345             printf("%x",encBuf[i]);
12346          }
12347       }
12348
12349       /* Sending  msg  */
12350       if(sendF1APMsg() != ROK)
12351       {
12352          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Res Failed");
12353          ret = RFAILED;
12354          break;
12355       }
12356       break;
12357    }
12358    FreeUeContextModResp(f1apMsg);
12359    return ret;
12360 }
12361 /*******************************************************************
12362  *
12363  * @brief Deallocating the memory allocated by the aper decoder
12364  *          for QOSInfo
12365  *
12366  * @details
12367  *
12368  *    Function : freeAperDecodeQosInfo
12369  *
12370  *    Functionality:  Deallocating the memory allocated for QOSInfo
12371  *
12372  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
12373  *
12374  * @return void
12375  *
12376  * ****************************************************************/
12377
12378 void freeAperDecodeQosInfo(QoSFlowLevelQoSParameters_t *drbQos)
12379 {
12380    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
12381    {
12382       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
12383       {
12384          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
12385          {
12386             free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
12387          }
12388          free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
12389       }
12390       free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI);
12391    }
12392 }
12393 /*******************************************************************
12394  *
12395  * @brief Deallocating the memory allocated by the aper decoder
12396  *          for UlTnlInfoforDrb
12397  *
12398  * @details
12399  *
12400  *    Function : freeAperDecodeUlTnlInfoforDrbSetupMod
12401  *
12402  *    Functionality:  Deallocating memory allocated for UlTnlInfoforDrb
12403  *
12404  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
12405  *
12406  * @return void
12407  *
12408  * ****************************************************************/
12409 void freeAperDecodeUlTnlInfoforDrbSetupMod(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
12410 {
12411    uint8_t arrIdx =0;
12412
12413    if(ulInfo->list.array)
12414    {
12415       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
12416       {
12417          if(ulInfo->list.array[arrIdx])
12418          {
12419             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
12420             {
12421                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
12422                {
12423                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
12424                   {
12425                      free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12426                            gTP_TEID.buf);
12427                   }
12428                   free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12429                         transportLayerAddress.buf);
12430                }
12431                free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel);
12432             }
12433             free(ulInfo->list.array[arrIdx]);
12434          }
12435       }
12436       free(ulInfo->list.array);
12437    }
12438 }
12439 /*******************************************************************
12440  *
12441  * @brief Deallocating the memory allocated by the aper decoder
12442  *          for DrbSetupModItem
12443  *
12444  * @details
12445  *
12446  *    Function : freeAperDecodeDrbSetupModItem
12447  *
12448  *    Functionality:  Deallocating memory allocated for DrbSetupModItem
12449  *
12450  * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
12451  *
12452  * @return void
12453  *
12454  * ****************************************************************/
12455
12456 void freeAperDecodeDrbSetupModItem(DRBs_ToBeSetupMod_Item_t *drbItem)
12457 {
12458    uint8_t arrIdx =0;
12459    SNSSAI_t *snssai =NULLP;
12460    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
12461
12462    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
12463    switch(drbItem->qoSInformation.present)
12464    {
12465       case QoSInformation_PR_NOTHING:
12466          break;
12467       case QoSInformation_PR_eUTRANQoS:
12468          {
12469             if(drbItem->qoSInformation.choice.eUTRANQoS)
12470             {
12471                free(drbItem->qoSInformation.choice.eUTRANQoS);
12472             }
12473             break;
12474          }
12475       case QoSInformation_PR_choice_extension:
12476          {
12477             if(drbItem->qoSInformation.choice.choice_extension)
12478             {
12479                freeAperDecodeQosInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.\
12480                      DRB_Information.dRB_QoS);
12481                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
12482                if(snssai->sST.buf)
12483                {
12484                   free(snssai->sST.buf);
12485                }
12486                if(snssai->sD)
12487                {
12488                   if(snssai->sD->buf)
12489                   {
12490                      free(snssai->sD->buf);
12491                   }
12492                   free(snssai->sD);
12493                }
12494
12495                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.\
12496                          DRB_Information.flows_Mapped_To_DRB_List;
12497                if(flowMap->list.array)
12498                {
12499                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
12500                   {
12501                      if(flowMap->list.array[arrIdx] )
12502                      {
12503                         freeAperDecodeQosInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
12504                         free(flowMap->list.array[arrIdx]);
12505                      }
12506                   }
12507                   free(flowMap->list.array);
12508                }
12509
12510                free(drbItem->qoSInformation.choice.choice_extension);
12511             }
12512             break;
12513          }
12514
12515    }
12516    freeAperDecodeUlTnlInfoforDrbSetupMod(&drbItem->uLUPTNLInformation_ToBeSetup_List);
12517    if(drbItem->uLConfiguration)
12518    {
12519       free(drbItem->uLConfiguration);
12520    }
12521 }
12522
12523 /*******************************************************************
12524  *
12525  * @brief Deallocating the memory allocated by the aper decoder
12526  *          for DrbToBeSetupModList
12527  *
12528  * @details
12529  *
12530  *    Function : freeAperDecodeDrbToBeSetupModList
12531  *
12532  *    Functionality:  Deallocating memory allocated for DrbToBeSetupModList
12533  *
12534  * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
12535  *
12536  * @return void
12537  *
12538  * ****************************************************************/
12539
12540 void freeAperDecodeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
12541 {
12542    uint8_t arrIdx =0;
12543    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
12544
12545    if(drbSet->list.array)
12546    {
12547       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
12548       {
12549          if(drbSet->list.array[arrIdx] != NULLP)
12550          {
12551             if(arrIdx == 0)
12552             {
12553                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
12554                freeAperDecodeDrbSetupModItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
12555             }
12556             free(drbSet->list.array[arrIdx]);
12557          }
12558       }
12559       free(drbSet->list.array);
12560    }
12561
12562 }
12563 /*******************************************************************
12564  *
12565  * @brief Deallocating the memory allocated by the aper decoder
12566  *          for UeContextModificationReqMsg
12567  *
12568  * @details
12569  *
12570  *    Function : freeAperDecodeUeContextModificationReqMsg
12571  *
12572  *    Functionality:  Deallocating memory allocated for
12573  *                  UeContextModificationReqMsg
12574  *
12575  * @params[in] UEContextModificationRequest_t *UeContextModifyReq
12576  *
12577  * @return void
12578  *
12579  * ****************************************************************/
12580 void freeAperDecodeUeContextModificationReqMsg(UEContextModificationRequest_t *UeContextModifyReq )
12581 {
12582    uint8_t arrIdx, ieId;
12583
12584    if(UeContextModifyReq->protocolIEs.list.array)
12585    {
12586       for( arrIdx = 0 ; arrIdx<UeContextModifyReq->protocolIEs.list.count ; arrIdx++)
12587       {
12588          if(UeContextModifyReq->protocolIEs.list.array[arrIdx])
12589          {
12590             ieId = UeContextModifyReq->protocolIEs.list.array[arrIdx]->id;
12591             switch(ieId)
12592             {
12593                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12594                   break;
12595                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12596                   break;
12597                case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
12598                   {
12599                      freeAperDecodeDrbToBeSetupModList(&UeContextModifyReq->protocolIEs.list.array[arrIdx]->\
12600                            value.choice.DRBs_ToBeSetupMod_List);
12601                      break;
12602                   }
12603             }
12604             free(UeContextModifyReq->protocolIEs.list.array[arrIdx]);
12605          }
12606       }
12607       free(UeContextModifyReq->protocolIEs.list.array);
12608    }
12609 }
12610 /*******************************************************************
12611  *
12612  * @brief processing the F1 UeContextModificationReq
12613  *
12614  * @details
12615  *
12616  *    Function : procF1UeContextModificationReq
12617  *
12618  *    Functionality:  processing the F1 UeContextModificationReq
12619  *
12620  * @params[in] F1AP_PDU_t *f1apMsg
12621  *
12622  * @return
12623  * ****************************************************************/
12624 uint8_t procF1UeContextModificationReq(F1AP_PDU_t *f1apMsg)
12625 {
12626    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
12627    uint8_t  ret = ROK, ieIdx = 0, lcId =0,cellIdx=0, ueIdx=0;
12628    DuUeCb   *duUeCb = NULLP;
12629    DRBs_ToBeSetupMod_List_t *drbSetupModCfg;
12630    uint32_t gnbCuUeF1apId, gnbDuUeF1apId;
12631
12632    ueContextModifyReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
12633    for(ieIdx=0; (ieIdx < ueContextModifyReq->protocolIEs.list.count && ret == ROK); ieIdx++)
12634    {
12635       switch(ueContextModifyReq->protocolIEs.list.array[ieIdx]->id)
12636       {
12637          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12638             {
12639                gnbCuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
12640                break;
12641             }
12642          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12643             {
12644                gnbDuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
12645                break;
12646             }
12647          case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
12648             {
12649                for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
12650                {
12651                   for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
12652                   {
12653                      if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
12654                            (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
12655                      {
12656
12657                         duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
12658                         lcId = getDrbLcId(&duUeCb->drbBitMap);
12659                         if(lcId != RFAILED)
12660                         {
12661                            DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
12662                            if(duUeCb->f1UeDb)
12663                            {
12664                               duUeCb->f1UeDb->actionType = UE_CTXT_MOD;
12665                               drbSetupModCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
12666                               choice.DRBs_ToBeSetupMod_List;
12667                               if(extractDrbListToSetup(lcId, NULL, drbSetupModCfg ,drbSetupModCfg->list.count, \
12668                               &duUeCb->f1UeDb->duUeCfg))
12669                               {
12670                                  DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetup()");
12671                                  ret = RFAILED;
12672                               }
12673                            }
12674                         }
12675                      }
12676                      else
12677                      {
12678                         DU_LOG("\nERROR  -->  DU APP : wrong values of gnbCuUeF1apId and gnbDuUeF1apId ");
12679                         ret = RFAILED;
12680                      }
12681                   }
12682                }
12683                break;
12684             }
12685       }
12686    }
12687    if(ret != RFAILED)
12688    {
12689       ret = duProcUeContextModReq(duUeCb);
12690    }
12691    freeAperDecodeUeContextModificationReqMsg(ueContextModifyReq);
12692    return ret;
12693 }
12694 /*****************************************************************i
12695 *
12696 * @brief Free memory allocated for UE Context Release Request
12697 *
12698 * @details
12699 *
12700 *    Function : FreeUeContextReleaseReq
12701 *
12702 *    Functionality:
12703 *         - Free memory allocated for UE Context Release Request
12704 *
12705 * @params[in] F1AP_PDU_t *f1apMsg
12706 * @return void
12707 *
12708 * *************************************************************/
12709 void FreeUeContextReleaseReq(F1AP_PDU_t *f1apMsg)
12710 {
12711    uint8_t ieIdx;
12712    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
12713
12714    if(f1apMsg)
12715    {
12716       if(f1apMsg->choice.initiatingMessage)
12717       {
12718          ueReleaseReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
12719          if(ueReleaseReq->protocolIEs.list.array)
12720          {
12721             for(ieIdx=0 ; ieIdx<ueReleaseReq->protocolIEs.list.count; ieIdx++)
12722             {
12723                DU_FREE(ueReleaseReq->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseRequest_t));
12724             }
12725             DU_FREE(ueReleaseReq->protocolIEs.list.array, ueReleaseReq->protocolIEs.list.size);
12726          }
12727          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
12728       }
12729       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12730    }
12731
12732 }
12733 /*****************************************************************i
12734 *
12735 * @brief Build and Send UE Context Release Request
12736 *
12737 * @details
12738 *
12739 *    Function : BuildAndSendUeContextReleaseReq
12740 *
12741 *    Functionality:
12742 *         - Build and Send UE Context Release Request
12743 *
12744 * @params[in]
12745 * @return ROK     - success
12746 *         RFAILED - failure
12747 *
12748 * *************************************************************/
12749 uint8_t BuildAndSendUeContextReleaseReq(uint16_t cellId, uint8_t ueIdx)
12750 {
12751    bool memAllocFail = false;
12752    uint8_t ieIdx =0;
12753    uint8_t ret = RFAILED;
12754    uint16_t cellIdx =0;
12755    uint16_t crnti = 0;
12756    uint8_t  elementCnt = 0;
12757    uint32_t  gnbCuUeF1apId =0;   /* gNB-CU UE F1AP Id */
12758    uint32_t  gnbDuUeF1apId =0;   /* gNB-DU UE F1AP Id */
12759    asn_enc_rval_t encRetVal;
12760    F1AP_PDU_t *f1apMsg = NULLP;
12761    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
12762
12763    DU_LOG("\nINFO  --> Building the UE Context Release Request");
12764    do
12765    {
12766       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12767       if(f1apMsg == NULLP)
12768       {
12769          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for f1apMsg");
12770          break;
12771       }
12772
12773       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
12774       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
12775       if(f1apMsg->choice.initiatingMessage == NULLP)
12776       {
12777          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for\
12778          initiatingMessage");
12779          break;
12780       }
12781       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextReleaseRequest;
12782       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
12783       f1apMsg->choice.initiatingMessage->value.present = \
12784       InitiatingMessage__value_PR_UEContextReleaseRequest;
12785
12786       ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
12787
12788       elementCnt = 2;
12789
12790       ueReleaseReq->protocolIEs.list.count = elementCnt;
12791       ueReleaseReq->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseRequest_t *);
12792
12793       /* Initialize the F1Setup members */
12794       DU_ALLOC(ueReleaseReq->protocolIEs.list.array,ueReleaseReq->protocolIEs.list.size);
12795       if(ueReleaseReq->protocolIEs.list.array == NULLP)
12796       {
12797          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE array");
12798          break;
12799       }
12800       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
12801       {
12802          DU_ALLOC(ueReleaseReq->protocolIEs.list.array[ieIdx],\
12803                sizeof(UEContextReleaseRequest_t));
12804          if(ueReleaseReq->protocolIEs.list.array[ieIdx] == NULLP)
12805          {
12806             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE elements");
12807             memAllocFail = true;
12808             break;
12809          }
12810       }
12811       if(memAllocFail == true)
12812          break;
12813
12814       /* Fetching Ue Cb Info*/
12815       GET_CELL_IDX(cellId, cellIdx);
12816       if(duCb.actvCellLst[cellIdx] == NULLP)
12817       {
12818          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): CellId[%d] does not exist", cellId);
12819          break;
12820       }
12821       else
12822       {
12823          GET_CRNTI(crnti, ueIdx);
12824          if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].crnti != crnti)
12825          {
12826             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): crnti[%d] does not exist", crnti);
12827             break;
12828          }
12829          gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
12830          gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
12831       }
12832
12833       ieIdx=0;
12834       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
12835       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
12836       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present = \
12837       UEContextReleaseRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
12838       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
12839
12840       ieIdx++;
12841       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
12842       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
12843       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present =\
12844       UEContextReleaseRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
12845       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
12846
12847       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12848
12849       /* Encode the F1SetupRequest type as APER */
12850       memset(encBuf, 0, ENC_BUF_MAX_LEN);
12851       encBufSize = 0;
12852       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
12853       /* Encode results */
12854       if(encRetVal.encoded == ENCODE_FAIL)
12855       {
12856          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseRequest structure (at %s)\n",\
12857                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12858          break;
12859       }
12860       else
12861       {
12862          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseRequest\n");
12863          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
12864          {
12865             printf("%x",encBuf[ieIdx]);
12866          }
12867       }
12868
12869       /* Sending msg */
12870       if(sendF1APMsg() != ROK)
12871       {
12872          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Request failed");
12873          break;
12874       }
12875       ret = ROK;
12876       break;
12877    }while(true);
12878
12879    FreeUeContextReleaseReq(f1apMsg);
12880    return ret;
12881 }
12882 /*****************************************************************i
12883  *
12884  * @brief Free memory allocated for UE Context Release Complete
12885  *
12886  * @details
12887  *
12888  *    Function : FreeUeContextReleaseComplete
12889  *
12890  *    Functionality:
12891  *         - Free memory allocated for UE Context Release Complete
12892  *
12893  * @params[in] F1AP_PDU_t *f1apMsg
12894  * @return void
12895  *
12896  * *************************************************************/
12897 void FreeUeContextReleaseComplete(F1AP_PDU_t *f1apMsg)
12898 {
12899    uint8_t ieIdx;
12900    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
12901
12902    if(f1apMsg)
12903    {
12904       if(f1apMsg->choice.successfulOutcome)
12905       {
12906          ueReleaseComplete =&f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
12907          if(ueReleaseComplete->protocolIEs.list.array)
12908          {
12909             for(ieIdx=0 ; ieIdx<ueReleaseComplete->protocolIEs.list.count; ieIdx++)
12910             {
12911                DU_FREE(ueReleaseComplete->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseComplete_t));
12912             }
12913             DU_FREE(ueReleaseComplete->protocolIEs.list.array, ueReleaseComplete->protocolIEs.list.size);
12914          }
12915          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12916       }
12917       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12918    }
12919
12920 }
12921 /*****************************************************************i
12922  *
12923  * @brief Build and Send UE Context Release Complete
12924  *
12925  * @details
12926  *
12927  *    Function : BuildAndSendUeContextReleaseComplete
12928  *
12929  *    Functionality:
12930  *         - Build and Send UE Context Release Complete
12931  *
12932  * @params[in]  cellId,  gnbCuUeF1apId, gnbDuUeF1apId
12933  * @return ROK     - success
12934  *         RFAILED - failure
12935  *
12936  * *************************************************************/
12937 uint8_t BuildAndSendUeContextReleaseComplete(uint16_t cellId, uint32_t gnbCuUeF1apId, uint32_t gnbDuUeF1apId)
12938 {
12939    bool memAllocFail = false;
12940    uint8_t ieIdx =0, ret = RFAILED, elementCnt = 0;
12941    asn_enc_rval_t encRetVal;
12942    F1AP_PDU_t *f1apMsg = NULLP;
12943    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
12944
12945    DU_LOG("\nINFO  --> Building the UE Context Release Complete");
12946    do
12947    {
12948       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12949       if(f1apMsg == NULLP)
12950       {
12951          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for f1apMsg");
12952          break;
12953       }
12954
12955       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
12956       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12957       if(f1apMsg->choice.successfulOutcome == NULLP)
12958       {
12959          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for\
12960                successfulOutcome");
12961          break;
12962       }
12963       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextRelease;
12964       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
12965       f1apMsg->choice.successfulOutcome->value.present = \
12966       SuccessfulOutcome__value_PR_UEContextReleaseComplete;
12967
12968       ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
12969
12970       elementCnt = 2;
12971       ueReleaseComplete->protocolIEs.list.count = elementCnt;
12972       ueReleaseComplete->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseComplete_t *);
12973
12974       /* Initialize the UE Release Complete members */
12975       DU_ALLOC(ueReleaseComplete->protocolIEs.list.array,ueReleaseComplete->protocolIEs.list.size);
12976       if(ueReleaseComplete->protocolIEs.list.array == NULLP)
12977       {
12978          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE array");
12979          break;
12980       }
12981       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
12982       {
12983          DU_ALLOC(ueReleaseComplete->protocolIEs.list.array[ieIdx],\
12984                sizeof(UEContextReleaseComplete_t));
12985          if(ueReleaseComplete->protocolIEs.list.array[ieIdx] == NULLP)
12986          {
12987             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE\
12988             elements");
12989             memAllocFail = true;
12990             break;
12991          }
12992       }
12993       if(memAllocFail == true)
12994          break;
12995
12996
12997       ieIdx=0;
12998       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
12999       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13000       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present = \
13001       UEContextReleaseCompleteIEs__value_PR_GNB_CU_UE_F1AP_ID;
13002       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
13003
13004       ieIdx++;
13005       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
13006       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13007       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present =\
13008       UEContextReleaseCompleteIEs__value_PR_GNB_DU_UE_F1AP_ID;
13009       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
13010
13011       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13012
13013       /* Encode the F1SetupComplete type as APER */
13014       memset(encBuf, 0, ENC_BUF_MAX_LEN);
13015       encBufSize = 0;
13016       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
13017       /* Encode results */
13018       if(encRetVal.encoded == ENCODE_FAIL)
13019       {
13020          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseComplete structure (at %s)\n",\
13021                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13022          break;
13023       }
13024       else
13025       {
13026          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseComplete\n");
13027          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
13028          {
13029             printf("%x",encBuf[ieIdx]);
13030          }
13031       }
13032
13033       /* Sending msg */
13034       if(sendF1APMsg() != ROK)
13035       {
13036          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Complete failed");
13037          break;
13038       }
13039       ret = ROK;
13040       break;
13041    }while(true);
13042
13043    if(ret == ROK)
13044    {
13045       duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
13046       ret = duSendCellDeletReq(cellId);
13047       if(ret != ROK)
13048       {
13049          DU_LOG("\nERROR  -->  F1AP: BuildAndSendUeContextReleaseComplete(): Failed to process cell\
13050                Delete req for CellId");
13051       }
13052    }
13053    FreeUeContextReleaseComplete(f1apMsg);
13054    return ret;
13055
13056 }
13057
13058 /*******************************************************************
13059 *
13060 * @brief added free part for the memory allocated by aper_decoder
13061 *
13062 * @details
13063 *
13064 *    Function : freeAperDecodeUeContextReleaseCommand
13065 *
13066 *    Functionality: added free part for the memory allocated by aper_decoder
13067 *
13068 * @params[in] F1AP_PDU_t *f1apMsg
13069 * @return void
13070 *
13071 * ****************************************************************/
13072 void freeAperDecodeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
13073 {
13074    uint8_t ieIdx=0;
13075    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
13076
13077    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
13078
13079    if(ueContextReleaseCommand->protocolIEs.list.array)
13080    {
13081       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
13082       {
13083          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
13084          {
13085             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
13086             {
13087                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13088                   break;
13089                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13090                   break;
13091                case ProtocolIE_ID_id_Cause:
13092                   break;
13093                case ProtocolIE_ID_id_RRCContainer:
13094                {
13095                   if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
13096                   {
13097                      free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
13098                   }
13099                   break;
13100                }
13101                default :
13102                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
13103                        ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
13104                   break;
13105             }
13106          }
13107          free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]);
13108       }
13109       free(ueContextReleaseCommand->protocolIEs.list.array);
13110    }
13111 }
13112 /*******************************************************************
13113 *
13114 * @brief processing of UE Context Release Command
13115 *
13116 * @details
13117 *
13118 *    Function : procF1UeContextReleaseCommand
13119 *
13120 *    Functionality: processing of UE Context Release Command
13121 *
13122 * @params[in] F1AP_PDU_t *f1apMsg
13123 * @return void
13124 *
13125 * ****************************************************************/
13126 uint8_t procF1UeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
13127 {
13128    uint8_t  ieIdx=0, ret=ROK, ueIdx=0;
13129    uint16_t cellIdx =0;
13130    bool ueIdxFound;
13131    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0;
13132    DuUeCb   *duUeCb = NULLP;
13133    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
13134
13135    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
13136
13137    if(ueContextReleaseCommand->protocolIEs.list.array)
13138    {
13139       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
13140       {
13141          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
13142          {
13143             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
13144             {
13145                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13146                   {
13147                      gnbCuUeF1apId= ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13148                                     value.choice.GNB_CU_UE_F1AP_ID;
13149                      break;
13150                   }
13151
13152                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13153                   {
13154                      gnbDuUeF1apId = ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13155                                      value.choice.GNB_DU_UE_F1AP_ID;
13156                      break;
13157                   }
13158
13159                case ProtocolIE_ID_id_Cause:
13160                   {
13161                      break;
13162                   }
13163
13164                case ProtocolIE_ID_id_RRCContainer:
13165                   {
13166                      for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
13167                      {
13168                         for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
13169                         {
13170                            if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
13171                                  (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
13172                            {
13173                               duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
13174                               DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
13175                               if(duUeCb->f1UeDb)
13176                               {
13177                                  memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
13178                                  duUeCb->f1UeDb->actionType = UE_CTXT_RELEASE;
13179                                  duUeCb->f1UeDb->cellIdx = cellIdx;
13180                                  /* Filling Dl RRC Msg Info */
13181                                  DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
13182                                  if(!duUeCb->f1UeDb->dlRrcMsg)
13183                                  {
13184                                     DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
13185                                     Memory allocation failed ");
13186                                     ret = RFAILED;
13187                                  }
13188                                  else
13189                                  {
13190                                     duUeCb->f1UeDb->dlRrcMsgPres = true;
13191                                     memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
13192                                     ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
13193                                           &ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13194                                           value.choice.RRCContainer);
13195                                  }
13196
13197                               }
13198                               else
13199                               {
13200                                  DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
13201                                  Memory allocation failed ");
13202                                  ret = RFAILED;
13203
13204                               }
13205
13206                               ueIdxFound = true;
13207                               break;
13208                            }
13209                         }
13210                         if(ueIdxFound == true)
13211                         {
13212                            break;
13213                         }
13214                      }
13215                      if(!ueIdxFound)
13216                      {
13217                         DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
13218                         ret = RFAILED;
13219                      }
13220
13221
13222                      break;
13223                   }
13224                default :
13225                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
13226                         ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
13227                   break;
13228             }
13229          }
13230       }
13231    }
13232    if(ret != RFAILED)
13233    {
13234       duProcUeContextReleaseCommand(duUeCb);
13235    }
13236    freeAperDecodeUeContextReleaseCommand(f1apMsg);
13237    return ret;
13238 }
13239 /**************************************************************
13240  *
13241  * @brief Handles received F1AP message and sends back response
13242  *
13243  * @details
13244  *
13245  *    Function : F1APMsgHdlr
13246  *
13247  *    Functionality:
13248  *         - Decodes received F1AP control message
13249  *         - Prepares response message, encodes and sends to SCTP
13250  *
13251  * @params[in]
13252  * @return ROK     - success
13253  *         RFAILED - failure
13254  *
13255  * ****************************************************************/
13256 void F1APMsgHdlr(Buffer *mBuf)
13257 {
13258    int i =0;
13259    char *recvBuf =NULLP;
13260    MsgLen copyCnt =0;
13261    MsgLen recvBufLen =0;
13262    F1AP_PDU_t *f1apMsg =NULLP;
13263    asn_dec_rval_t rval; /* Decoder return value */
13264    F1AP_PDU_t f1apasnmsg ;
13265    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
13266    ODU_PRINT_MSG(mBuf, 0,0);
13267
13268    /* Copy mBuf into char array to decode it */
13269    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
13270    DU_ALLOC(recvBuf, (Size)recvBufLen);
13271
13272    if(recvBuf == NULLP)
13273    {
13274       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
13275       return;
13276    }
13277    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
13278    {
13279       DU_LOG("\nERROR   -->  F1AP : Failed while copying %d", copyCnt);
13280       return;
13281    }
13282
13283    printf("\nDEBUG   -->  F1AP : Received flat buffer to be decoded : ");
13284    for(i=0; i< recvBufLen; i++)
13285    {
13286       printf("%x",recvBuf[i]);
13287    }
13288
13289    /* Decoding flat buffer into F1AP messsage */
13290    f1apMsg = &f1apasnmsg;
13291    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
13292
13293    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
13294    DU_FREE(recvBuf, (Size)recvBufLen);
13295
13296    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
13297    {
13298       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
13299       return;
13300    }
13301    printf("\n");
13302    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13303
13304    switch(f1apMsg->present)
13305    {
13306       case F1AP_PDU_PR_successfulOutcome:
13307          {
13308             switch(f1apMsg->choice.successfulOutcome->value.present)
13309             {
13310                case SuccessfulOutcome__value_PR_ResetAcknowledge:
13311                   {
13312                      DU_LOG("\nINFO   -->  F1AP : F1ResetAcknowledge is received successfully ");
13313                      break;
13314                   }
13315                case SuccessfulOutcome__value_PR_F1SetupResponse:
13316                   {
13317 #ifndef ODU_TEST_STUB
13318                      procF1SetupRsp(f1apMsg);
13319 #endif
13320                      break;
13321                   }
13322
13323                case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
13324                   {
13325                      procF1GNBDUCfgUpdAck(f1apMsg);
13326                      break;
13327                   }
13328
13329                default:
13330                   {
13331                      DU_LOG("\nERROR  -->  F1AP : Invalid type of SuccessfulOutcome__value_PR_ResetAcknowledge [%d]",\
13332                            f1apMsg->choice.successfulOutcome->value.present);
13333                      return;
13334                   }
13335             }/* End of switch(successfulOutcome) */
13336             free(f1apMsg->choice.successfulOutcome);
13337             break;
13338          }
13339       case F1AP_PDU_PR_initiatingMessage:
13340          {
13341             switch(f1apMsg->choice.initiatingMessage->value.present)
13342             {
13343                case InitiatingMessage__value_PR_Reset:
13344                   {
13345                      procF1ResetReq(f1apMsg);
13346                      break;
13347                   }
13348                case InitiatingMessage__value_PR_DLRRCMessageTransfer:
13349                   {
13350                      procF1DlRrcMsgTrans(f1apMsg);
13351                      break;
13352                   }
13353                case InitiatingMessage__value_PR_UEContextSetupRequest:
13354                   {
13355                      procF1UeContextSetupReq(f1apMsg);
13356                      break;
13357                   }
13358                case InitiatingMessage__value_PR_UEContextModificationRequest:
13359                   {
13360                      procF1UeContextModificationReq(f1apMsg);
13361                      break;
13362                   }
13363                case InitiatingMessage__value_PR_UEContextReleaseCommand:
13364                   {
13365                       procF1UeContextReleaseCommand(f1apMsg);
13366                       break;
13367                   }
13368                default:
13369                   {
13370                      DU_LOG("\nERROR  -->  F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
13371                            f1apMsg->choice.initiatingMessage->value.present);
13372                      return;
13373                   }
13374             }/* End of switch(initiatingMessage) */
13375             free(f1apMsg->choice.initiatingMessage);
13376             break;
13377          }
13378
13379       default:
13380          {
13381             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
13382             return;
13383          }
13384          free(f1apMsg);
13385
13386    }/* End of switch(f1apMsg->present) */
13387
13388 } /* End of F1APMsgHdlr */
13389
13390 /**********************************************************************
13391   End of file
13392  **********************************************************************/