src/du_app/du_f1ap_msg_hdl.c

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   4 #                                                                              #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
   6 #   you may not use this file except in compliance with the License.           #
   7 #   You may obtain a copy of the License at                                    #
   8 #                                                                              #
   9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10 #                                                                              #
  11 #   Unless required by applicable law or agreed to in writing, software        #
  12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
  14 #   See the License for the specific language governing permissions and        #
  15 #   limitations under the License.                                             #
  16 ################################################################################
  17 *******************************************************************************/
  18
  19 /* This file contains F1AP message handler functions */
  20 #include "common_def.h"
  21 #include "lrg.h"
  22 #include "legtp.h"
  23 #include "lkw.x"
  24 #include "lrg.x"
  25 #include "F1AP-PDU.h"
  26 #include "du_app_mac_inf.h"
  27 #include "du_cfg.h"
  28 #include "du_app_rlc_inf.h"
  29 #include "du_mgr_main.h"
  30 #include "du_utils.h"
  31 #include "RAT-Type.h"
  32 #include "FeatureSetUplinkPerCC.h"
  33 #include "FeatureSetDownlinkPerCC.h"
  34 #include "FeatureSets.h"
  35 #include "UE-NR-Capability.h"
  36 #include "UE-CapabilityRAT-Container.h"
  37 #include "UE-CapabilityRAT-ContainerListRRC.h"
  38 #include "GNB-DU-System-Information.h"
  39 #include "CellGroupConfigRrc.h"
  40 #include "MAC-CellGroupConfig.h"
  41 #include "SchedulingRequestConfig.h"
  42 #include "SchedulingRequestToAddMod.h"
  43 #include "BSR-Config.h"
  44 #include "TAG-Config.h"
  45 #include "TAG.h"
  46 #include "PHR-Config.h"
  47 #include "RLC-Config.h"
  48 #include "UL-AM-RLC.h"
  49 #include "DL-AM-RLC.h"
  50 #include "LogicalChannelConfig.h"
  51 #include "RLC-BearerConfig.h"
  52 #include "PhysicalCellGroupConfig.h"
  53 #include "SpCellConfig.h"
  54 #include "TDD-UL-DL-ConfigDedicated.h"
  55 #include "ServingCellConfig.h"
  56 #include "ControlResourceSet.h"
  57 #include "SearchSpace.h"
  58 #include "PDCCH-Config.h"
  59 #include "PDSCH-TimeDomainResourceAllocation.h"
  60 #include "PDSCH-TimeDomainResourceAllocationList.h"
  61 #include "PDSCH-CodeBlockGroupTransmission.h"
  62 #include "PDSCH-ServingCellConfig.h"
  63 #include "DMRS-DownlinkConfig.h"
  64 #include "PDSCH-Config.h"
  65 #include "BWP-DownlinkDedicated.h"
  66 #include "PUSCH-TimeDomainResourceAllocation.h"
  67 #include "PUSCH-TimeDomainResourceAllocationList.h"
  68 #include "DMRS-UplinkConfig.h"
  69 #include "PUSCH-Config.h"
  70 #include "SRS-ResourceId.h"
  71 #include "SRS-Resource.h"
  72 #include "SRS-ResourceSet.h"
  73 #include "SRS-Config.h"
  74 #include "BWP-UplinkDedicated.h"
  75 #include "PUSCH-ServingCellConfig.h"
  76 #include "UplinkConfig.h"
  77 #include "DUtoCURRCContainer.h"
  78 #include "GBR-QoSFlowInformation.h"
  79 #include "QoSFlowLevelQoSParameters.h"
  80 #include "PUCCH-Config.h"
  81 #include "PUCCH-ResourceSet.h"
  82 #include "PUCCH-Resource.h"
  83 #include "PUCCH-PowerControl.h"
  84 #include "P0-PUCCH.h"
  85 #include "PUCCH-PathlossReferenceRS.h"
  86 #include "PUCCH-format0.h"
  87 #include "PUCCH-format1.h"
  88 #include "PUCCH-format2.h"
  89 #include "PUCCH-format3.h"
  90 #include "PUCCH-format4.h"
  91 #include "PUCCH-FormatConfig.h"
  92 #include "SchedulingRequestResourceConfig.h"
  93 #include<ProtocolIE-Field.h>
  94 #include "ProtocolExtensionField.h"
  95 #include "odu_common_codec.h"
  96 #include "du_mgr.h"
  97 #include "du_cell_mgr.h"
  98 #include "du_f1ap_msg_hdl.h"
  99 #include "DRBs-Setup-Item.h"
 100 #include "DLUPTNLInformation-ToBeSetup-List.h"
 101 #include "DLUPTNLInformation-ToBeSetup-Item.h"
 102 #include "UPTransportLayerInformation.h"
 103 #include "GTPTunnel.h"
 104
 105 #ifdef O1_ENABLE
 106 #include "ConfigInterface.h"
 107 extern StartupConfig g_cfg;
 108 #endif
 109
 110 DuCfgParams duCfgParam;
 111
 112 /************************************************************************
 113  *
 114  * @brief Converts enum values into actual value of Poll retransmit timer
 115  *
 116  * @details
 117  *
 118  *    Function : getPollPdu
 119  *
 120  *    Functionality: Converts enum values into actual value of poll
 121  *    retransmit timer
 122  *
 123  * @params[in] Enum value of pollPdu
 124  * @return Actual value of pollPdu
 125  *
 126  * **********************************************************************/
 127
 128 uint16_t getPollRetxTmr(uint8_t pollRetxTmrCfg)
 129 {
 130    uint16_t pollRetxTmr;
 131
 132    /* All values of poll retx timer are at interval of 5ms.
 133     * This is valid upto 250ms
 134     * Hence converting the enum value to actual value by multiplying it to 5
 135     */
 136    if(pollRetxTmrCfg <= T_PollRetransmit_ms250)
 137       pollRetxTmr = (pollRetxTmrCfg + 1) * 5;
 138    else
 139    {
 140       switch(pollRetxTmrCfg)
 141       {
 142          case T_PollRetransmit_ms300:
 143             pollRetxTmr = 300;
 144             break;
 145          case T_PollRetransmit_ms350:
 146             pollRetxTmr = 350;
 147             break;
 148          case T_PollRetransmit_ms400:
 149             pollRetxTmr = 400;
 150             break;
 151          case T_PollRetransmit_ms450:
 152             pollRetxTmr = 450;
 153             break;
 154          case T_PollRetransmit_ms500:
 155             pollRetxTmr = 500;
 156             break;
 157          case T_PollRetransmit_ms800:
 158             pollRetxTmr = 800;
 159             break;
 160          default:
 161             DU_LOG("\nERROR  -->  F1AP: Invalid value of Poll Retransmit timer");
 162             pollRetxTmr = 0;
 163       }
 164    }
 165    return pollRetxTmr;
 166 }
 167
 168 /*******************************************************************
 169  *
 170  * @brief Converts enum values into actual value of PollPdu
 171  *
 172  * @details
 173  *
 174  *    Function : getPollPdu
 175  *
 176  *    Functionality: Converts enum values into actual value of PollPdu
 177  *
 178  * @params[in] Enum value of pollPdu
 179  * @return Actual value of pollPdu
 180  *
 181  * ****************************************************************/
 182 int32_t getPollPdu(uint8_t pollPduCfg)
 183 {
 184    int32_t pollPdu;
 185    switch(pollPduCfg)
 186    {
 187       case PollPDU_p4:
 188          pollPdu = 4;
 189          break;
 190       case PollPDU_p8:
 191          pollPdu = 8;
 192          break;
 193       case PollPDU_p16:
 194          pollPdu = 16;
 195          break;
 196       case PollPDU_p32:
 197          pollPdu = 32;
 198          break;
 199       case PollPDU_p64:
 200          pollPdu = 64;
 201          break;
 202       case PollPDU_p128:
 203          pollPdu = 128;
 204          break;
 205       case PollPDU_p256:
 206          pollPdu = 256;
 207          break;
 208       case PollPDU_p512:
 209          pollPdu = 512;
 210          break;
 211       case PollPDU_p1024:
 212          pollPdu = 1024;
 213          break;
 214       case PollPDU_p2048:
 215          pollPdu = 2048;
 216          break;
 217       case PollPDU_p4096:
 218          pollPdu = 4096;
 219          break;
 220       case PollPDU_p6144:
 221          pollPdu = 6144;
 222          break;
 223       case PollPDU_p8192:
 224          pollPdu = 8192;
 225          break;
 226       case PollPDU_p12288:
 227          pollPdu = 12288;
 228          break;
 229       case PollPDU_p16384:
 230          pollPdu = 16384;
 231          break;
 232       case PollPDU_p20480:
 233          pollPdu = 20480;
 234          break;
 235       case PollPDU_p24576:
 236          pollPdu = 24576;
 237          break;
 238       case PollPDU_p28672:
 239          pollPdu = 28672;
 240          break;
 241       case PollPDU_p32768:
 242          pollPdu = 32768;
 243          break;
 244       case PollPDU_p40960:
 245          pollPdu = 40960;
 246          break;
 247       case PollPDU_p49152:
 248          pollPdu = 49152;
 249          break;
 250       case PollPDU_p57344:
 251          pollPdu = 57344;
 252          break;
 253       case PollPDU_p65536:
 254          pollPdu = 65536;
 255          break;
 256       case PollPDU_infinity:
 257          pollPdu = -1;
 258          break;
 259       default:
 260          DU_LOG("\nERROR  -->  F1AP: Invalid value of poll pdu");
 261          pollPdu = 0;
 262          break;
 263    }
 264    return pollPdu;
 265 }
 266
 267 /*******************************************************************
 268  *
 269  * @brief Converts enum values into actual value of poll bytes
 270  *
 271  * @details
 272  *
 273  *    Function : getPollByte
 274  *
 275  *    Functionality: Converts enum values into actual value of pollBytes
 276  *
 277  * @params[in] Enum value
 278  * @return Actual value
 279  *
 280  * ****************************************************************/
 281 int32_t getPollByte(uint16_t pollBytesCfg)
 282 {
 283    int32_t pollBytes;
 284    switch(pollBytesCfg)
 285    {
 286       case PollByte_kB1:
 287          pollBytes = 1000;
 288          break;
 289       case PollByte_kB2:
 290          pollBytes = 2000;
 291          break;
 292       case PollByte_kB5:
 293          pollBytes = 5000;
 294          break;
 295       case PollByte_kB8:
 296          pollBytes = 8000;
 297          break;
 298       case PollByte_kB10:
 299          pollBytes = 10000;
 300          break;
 301       case PollByte_kB15:
 302          pollBytes = 15000;
 303          break;
 304       case PollByte_kB25:
 305          pollBytes = 25000;
 306          break;
 307       case PollByte_kB50:
 308          pollBytes = 50000;
 309          break;
 310       case PollByte_kB75:
 311          pollBytes = 75000;
 312          break;
 313       case PollByte_kB100:
 314          pollBytes = 100000;
 315          break;
 316       case PollByte_kB125:
 317          pollBytes = 125000;
 318          break;
 319       case PollByte_kB250:
 320          pollBytes = 250000;
 321          break;
 322       case PollByte_kB375:
 323          pollBytes = 375000;
 324          break;
 325       case PollByte_kB500:
 326          pollBytes = 500000;
 327          break;
 328       case PollByte_kB750:
 329          pollBytes = 750000;
 330          break;
 331       case PollByte_kB1000:
 332          pollBytes = 1000000;
 333          break;
 334       case PollByte_kB1250:
 335          pollBytes = 1250000;
 336          break;
 337       case PollByte_kB1500:
 338          pollBytes = 1500000;
 339          break;
 340       case PollByte_kB2000:
 341          pollBytes = 2000000;
 342          break;
 343       case PollByte_kB3000:
 344          pollBytes = 3000000;
 345          break;
 346       case PollByte_kB4000:
 347          pollBytes = 4000000;
 348          break;
 349       case PollByte_kB4500:
 350          pollBytes = 4500000;
 351          break;
 352       case PollByte_kB5000:
 353          pollBytes = 5000000;
 354          break;
 355       case PollByte_kB5500:
 356          pollBytes = 5500000;
 357          break;
 358       case PollByte_kB6000:
 359          pollBytes = 6000000;
 360          break;
 361       case PollByte_kB6500:
 362          pollBytes = 6500000;
 363          break;
 364       case PollByte_kB7000:
 365          pollBytes = 7000000;
 366          break;
 367       case PollByte_kB7500:
 368          pollBytes = 7500000;
 369          break;
 370       case PollByte_mB8:
 371          pollBytes = 8000000;
 372          break;
 373       case PollByte_mB9:
 374          pollBytes = 9000000;
 375          break;
 376       case PollByte_mB10:
 377          pollBytes = 10000000;
 378          break;
 379       case PollByte_mB11:
 380          pollBytes = 11000000;
 381          break;
 382       case PollByte_mB12:
 383          pollBytes = 12000000;
 384          break;
 385       case PollByte_mB13:
 386          pollBytes = 13000000;
 387          break;
 388       case PollByte_mB14:
 389          pollBytes = 14000000;
 390          break;
 391       case PollByte_mB15:
 392          pollBytes = 15000000;
 393          break;
 394       case PollByte_mB16:
 395          pollBytes = 16000000;
 396          break;
 397       case PollByte_mB17:
 398          pollBytes = 17000000;
 399          break;
 400       case PollByte_mB18:
 401          pollBytes = 18000000;
 402          break;
 403       case PollByte_mB20:
 404          pollBytes = 20000000;
 405          break;
 406       case PollByte_mB25:
 407          pollBytes = 25000000;
 408          break;
 409       case PollByte_mB30:
 410          pollBytes = 30000000;
 411          break;
 412       case PollByte_mB40:
 413          pollBytes = 40000000;
 414          break;
 415       case PollByte_infinity:
 416          pollBytes = -1;
 417          break;
 418       default:
 419          DU_LOG("\nERROR  -->  F1AP: Invalid value of poll bytes");
 420          pollBytes = 0;
 421    }
 422    return pollBytes;
 423 }
 424
 425 /*******************************************************************
 426  *
 427  * @brief Converts enum values into actual value of maxRetx
 428  *
 429  * @details
 430  *
 431  *    Function : getMaxRetx
 432  *
 433  *    Functionality: Converts enum values into actual value of maxRetx
 434  *
 435  * @params[in] Enum value
 436  * @return Actual value
 437  *
 438  * ****************************************************************/
 439 uint8_t getMaxRetx(uint8_t maxRetxCfg)
 440 {
 441    uint8_t maxRetx;
 442    switch(maxRetxCfg)
 443    {
 444       case UL_AM_RLC__maxRetxThreshold_t1:
 445          maxRetx = 1;
 446          break;
 447       case UL_AM_RLC__maxRetxThreshold_t2:
 448          maxRetx = 2;
 449          break;
 450       case UL_AM_RLC__maxRetxThreshold_t3:
 451          maxRetx = 3;
 452          break;
 453       case UL_AM_RLC__maxRetxThreshold_t4:
 454          maxRetx = 4;
 455          break;
 456       case UL_AM_RLC__maxRetxThreshold_t6:
 457          maxRetx = 6;
 458          break;
 459       case UL_AM_RLC__maxRetxThreshold_t8:
 460          maxRetx = 8;
 461          break;
 462       case UL_AM_RLC__maxRetxThreshold_t16:
 463          maxRetx = 16;
 464          break;
 465       case UL_AM_RLC__maxRetxThreshold_t32:
 466          maxRetx = 32;
 467          break;
 468       default:
 469          DU_LOG("\nERROR  -->  F1AP: Invalid configuration for Max retransmission threshold");
 470          maxRetx = 0;
 471    }
 472    return maxRetx;
 473 }
 474
 475 /*******************************************************************
 476  * @brief Converts enum values into actual value of reassembly timer
 477  *
 478  * @details
 479  *
 480  *    Function : getReAsmblTmr
 481  *
 482  *    Functionality: Converts enum values into actual value of reassembly
 483  *    timer
 484  *
 485  * @params[in] Enum value of reassembly timer
 486  * @return Actual value of reassembly timer
 487  *
 488  * **********************************************************************/
 489
 490 int8_t getReAsmblTmr(uint8_t reAsmblTmrCfg)
 491 {
 492    int8_t reAsmblTmr = 0;
 493
 494    if(reAsmblTmrCfg == T_Reassembly_ms0)
 495    {
 496       reAsmblTmr = 0;
 497    }
 498    else if(reAsmblTmrCfg >= T_Reassembly_ms5 || reAsmblTmrCfg <= T_Reassembly_ms100)
 499    {
 500      /* All values of re assembly timer are at interval of 5ms.
 501       * This is valid upto 100ms
 502       * Hence converting the enum value to actual value by multiplying it to 5
 503       */
 504       reAsmblTmr = reAsmblTmrCfg * 5;
 505    }
 506    else if(reAsmblTmrCfg >= T_Reassembly_ms110 || reAsmblTmrCfg <= T_Reassembly_ms200)
 507    {
 508      /* All values of re assembly timer are at interval of 10ms.
 509       * This is valid upto 200ms
 510       * since enum value starts from 20 for 100ms, subtracting 10 and
 511       * converting the enum value to actual value by multiplying it to 10
 512       */
 513       reAsmblTmr = ((reAsmblTmrCfg-10) * 10);
 514    }
 515    else
 516    {
 517       DU_LOG("\nERROR  -->  F1AP : Invalid value of Re Assembly timer %d", reAsmblTmrCfg);
 518       reAsmblTmr = -1;
 519    }
 520    return reAsmblTmr;
 521 }
 522
 523 /************************************************************************
 524  *
 525  * @brief Converts enum values into actual value of status prohibit timer
 526  *
 527  * @details
 528  *
 529  *    Function : getStatProhTmr
 530  *
 531  *    Functionality: Converts enum values into actual value of status prohibit
 532  *    timer
 533  *
 534  * @params[in] Enum value of status prohibit timer
 535  * @return Actual value of status prohibit timer
 536  *
 537  * **********************************************************************/
 538
 539 int16_t getStatProhTmr(uint8_t statProhTmrCfg)
 540 {
 541    int16_t statProhTmr =0;
 542
 543    if(statProhTmrCfg == T_StatusProhibit_ms0)
 544    {
 545       statProhTmr = 0;
 546    }
 547    else if(statProhTmrCfg >= T_StatusProhibit_ms5 || statProhTmrCfg <= T_StatusProhibit_ms250)
 548    {
 549       /* All values of re assembly timer are at interval of 5ms.
 550        * This is valid upto 250ms
 551        * Hence converting the enum value to actual value by multiplying it to 5
 552        */
 553       statProhTmr = statProhTmrCfg * 5;
 554    }
 555    else
 556    {
 557       switch(statProhTmrCfg)
 558       {
 559          case T_StatusProhibit_ms300:
 560             statProhTmr = 300;
 561             break;
 562          case T_StatusProhibit_ms350:
 563             statProhTmr = 350;
 564             break;
 565          case T_StatusProhibit_ms400:
 566             statProhTmr = 400;
 567             break;
 568          case T_StatusProhibit_ms450:
 569             statProhTmr = 450;
 570             break;
 571          case T_StatusProhibit_ms500:
 572             statProhTmr = 500;
 573             break;
 574          case T_StatusProhibit_ms800:
 575             statProhTmr = 800;
 576             break;
 577          case T_StatusProhibit_ms1000:
 578             statProhTmr = 1000;
 579             break;
 580          case T_StatusProhibit_ms1200:
 581             statProhTmr = 1200;
 582             break;
 583          case T_StatusProhibit_ms1600:
 584             statProhTmr = 1600;
 585             break;
 586          case T_StatusProhibit_ms2000:
 587             statProhTmr = 2000;
 588             break;
 589          case T_StatusProhibit_ms2400:
 590             statProhTmr = 2400;
 591             break;
 592          default:
 593             DU_LOG("\nInvalid value of Status Prohibit timer %d", statProhTmrCfg);
 594             statProhTmr = -1;
 595             break;
 596       }
 597    }
 598    return statProhTmr;
 599 }
 600
 601 /*******************************************************************
 602 *
 603 * @brief Adding F1AP pdu to reserved pdu list
 604 *
 605 * @details
 606 *
 607 *    Function : addToReservedF1apPduList
 608 *
 609 *    Functionality: Adding F1AP pdu to reserved pdu list.
 610 *     These pdu are awaiting aknowledgment from CU
 611 *
 612 * @params[in] uint8_t transId, F1AP_PDU_t *f1apMsg
 613 *
 614 * @return ROK - success
 615 *         RFAILED - failure
 616 *
 617 * ****************************************************************/
 618
 619 void addToReservedF1apPduList(uint8_t transId, F1AP_PDU_t *f1apPdu)
 620 {
 621    CmLList         *node = NULLP;
 622    ReservedF1apPduInfo *pduInfo = NULLP;
 623    DU_ALLOC(pduInfo, sizeof(ReservedF1apPduInfo));
 624    if(pduInfo)
 625    {
 626       DU_ALLOC(node, sizeof(CmLList));
 627       if(node)
 628       {
 629          pduInfo->transId = transId;
 630          pduInfo->f1apMsg = (void*) f1apPdu;
 631
 632          node->node = (PTR)pduInfo;
 633          cmLListAdd2Tail(&duCb.reservedF1apPduList, node);
 634       }
 635    }
 636 }
 637
 638 /*******************************************************************
 639 *
 640 * @brief searching for F1AP pdu from ReservedF1apPduList
 641 *
 642 * @details
 643 *
 644 *    Function : searchFromReservedF1apPduList
 645 *
 646 *    Functionality: searching for F1AP pdu information
 647 *
 648 * @params[in] uint8_t transId
 649 *
 650 * @return pointer to F1AP_PDU_t
 651 *
 652 * ****************************************************************/
 653
 654 CmLList *searchFromReservedF1apPduList(uint8_t transId)
 655 {
 656    CmLList         *node;
 657    ReservedF1apPduInfo *f1apPdu;
 658    if(duCb.reservedF1apPduList.count)
 659    {
 660       CM_LLIST_FIRST_NODE(&duCb.reservedF1apPduList, node);
 661       while(node)
 662       {
 663          f1apPdu = (ReservedF1apPduInfo*)node->node;
 664          if(f1apPdu->transId == transId)
 665          {
 666             return node;
 667          }
 668          node = node->next;
 669       }
 670    }
 671    return NULL;
 672 }
 673
 674 /*******************************************************************
 675 *
 676 * @brief deleting F1AP pdu information from ReservedF1apPduList
 677 *
 678 * @details
 679 *
 680 *    Function : deleteFromReservedF1apPduList
 681 *
 682 *    Functionality: deleting pdu information from ReservedF1apPduList
 683 *
 684 * @params[in] CmLList *node
 685 *
 686 * @return void
 687 *
 688 * ****************************************************************/
 689
 690 void deleteFromReservedF1apPduList(CmLList *node)
 691 {
 692    ReservedF1apPduInfo *f1apPdu;
 693
 694    if(node != NULL)
 695    {
 696       f1apPdu = (ReservedF1apPduInfo *)node->node;
 697       cmLListDelFrm(&duCb.reservedF1apPduList, node);
 698       DU_FREE(f1apPdu, sizeof(ReservedF1apPduInfo));
 699       DU_FREE(node, sizeof(CmLList));
 700       node = NULL;
 701    }
 702 }
 703
 704 /*******************************************************************
 705  *
 706  * @brief Builds Uplink Info for NR
 707  *
 708  * @details
 709  *
 710  *    Function : BuildULNRInfo
 711  *
 712  *    Functionality: Building NR Uplink Info
 713  *
 714  * @params[in] NRFreqInfo_t *ulnrfreq
 715  * @return ROK     - success
 716  *         RFAILED - failure
 717  *
 718  * ****************************************************************/
 719 uint8_t BuildULNRInfo(NRFreqInfo_t *ulnrfreq)
 720 {
 721    uint8_t idx=0;
 722    ulnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 723                        fdd.ulNrFreqInfo.nrArfcn;
 724    ulnrfreq->freqBandListNr.list.count = 1;
 725    ulnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 726    DU_ALLOC(ulnrfreq->freqBandListNr.list.array,ulnrfreq->freqBandListNr.list.size);
 727    if(ulnrfreq->freqBandListNr.list.array == NULLP)
 728    {
 729       return RFAILED;
 730    }
 731    for(idx=0;idx<ulnrfreq->freqBandListNr.list.count;idx++)
 732    {
 733       DU_ALLOC(ulnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 734       if(ulnrfreq->freqBandListNr.list.array[idx] == NULLP)
 735       {
 736          return RFAILED;
 737       }
 738    }
 739    ulnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 740                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
 741                                                                  freqBand[0].nrFreqBand;
 742    ulnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 743    return ROK;
 744 }
 745 /*******************************************************************
 746  *
 747  * @brief Builds Downlink NR Info
 748  *
 749  * @details
 750  *
 751  *    Function : BuildDLNRInfo
 752  *
 753  *    Functionality: Building Downlink NR Info
 754  *
 755  * @params[in] NRFreqInfo_t *dlnrfreq
 756  * @return ROK     - success
 757  *         RFAILED - failure
 758  *
 759  * ****************************************************************/
 760 uint8_t BuildDLNRInfo(NRFreqInfo_t *dlnrfreq)
 761 {
 762    uint8_t idx=0;
 763    dlnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 764                        fdd.dlNrFreqInfo.nrArfcn;
 765    dlnrfreq->freqBandListNr.list.count = 1;
 766    dlnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 767    DU_ALLOC(dlnrfreq->freqBandListNr.list.array,dlnrfreq->freqBandListNr.list.size);
 768    if(dlnrfreq->freqBandListNr.list.array == NULLP)
 769    {
 770       return RFAILED;
 771    }
 772    for(idx=0;idx< dlnrfreq->freqBandListNr.list.count;idx++)
 773    {
 774       DU_ALLOC(dlnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 775       if(dlnrfreq->freqBandListNr.list.array[idx] == NULLP)
 776       {
 777          return RFAILED;
 778       }
 779    }
 780    dlnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 781                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
 782                                                                  freqBand[0].nrFreqBand;
 783    dlnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 784
 785    return ROK;
 786 }
 787
 788 /*******************************************************************
 789  *
 790  * @brief Builds NRCell ID
 791  *
 792  * @details
 793  *
 794  *    Function : BuildNrCellId
 795  *
 796  *    Functionality: Building the NR Cell ID
 797  *
 798  * @params[in] BIT_STRING_t *nrcell
 799  * @return ROK     - success
 800  *         RFAILED - failure
 801  *
 802  * ****************************************************************/
 803
 804 S16 BuildNrCellId(BIT_STRING_t *nrcell)
 805 {
 806    memset(nrcell->buf, 0, nrcell->size);
 807    nrcell->buf[4]   = 16;
 808    nrcell->bits_unused = 4;
 809    return ROK;
 810 }
 811
 812 /*******************************************************************
 813  *
 814  * @brief Builds Nrcgi
 815  *
 816  * @details
 817  *
 818  *    Function : BuildNrcgi
 819  *
 820  *    Functionality: Building the PLMN ID and NR Cell id
 821  *
 822  * @params[in] NRCGI_t *nrcgi
 823  * @return ROK     - success
 824  *         RFAILED - failure
 825  *
 826  * ****************************************************************/
 827 uint8_t BuildNrcgi(NRCGI_t *nrcgi)
 828 {
 829    uint8_t ret;
 830    uint8_t byteSize = 5;
 831    /* Allocate Buffer Memory */
 832    nrcgi->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 833    DU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
 834    if(nrcgi->pLMN_Identity.buf == NULLP)
 835    {
 836       return RFAILED;
 837    }
 838    ret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 839          nrcgi->pLMN_Identity.buf); // Building PLMN function
 840    if(ret != ROK)
 841    {
 842       return RFAILED;
 843    }
 844    /*nrCellIdentity*/
 845    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
 846    DU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
 847    if(nrcgi->nRCellIdentity.buf == NULLP)
 848    {
 849       return RFAILED;
 850    }
 851    BuildNrCellId(&nrcgi->nRCellIdentity);
 852
 853    return ROK;
 854 }
 855 /*******************************************************************
 856  *
 857  * @brief Builds FiveGStac
 858  *
 859  * @details
 860  *
 861  *    Function : BuildFiveGSTac
 862  *
 863  *    Functionality: Building the FiveGSTac
 864  *
 865  * @params[in] OCTET_STRING_t *fivegsTac
 866  * @return ROK     - success
 867  *         RFAILED - failure
 868  *
 869  * ****************************************************************/
 870 uint8_t BuildFiveGSTac(Served_Cell_Information_t *servcell)
 871 {
 872    DU_ALLOC(servcell->fiveGS_TAC,sizeof(FiveGS_TAC_t));
 873    if(servcell->fiveGS_TAC == NULLP)
 874    {
 875       return RFAILED;
 876    }
 877    servcell->fiveGS_TAC->size = 3 * sizeof(uint8_t);
 878    DU_ALLOC(servcell->fiveGS_TAC->buf,\
 879          sizeof(servcell->fiveGS_TAC->size));
 880    if(servcell->fiveGS_TAC->buf == NULLP)
 881    {
 882       return RFAILED;
 883    }
 884    servcell->fiveGS_TAC->buf[0] = 0;
 885    servcell->fiveGS_TAC->buf[1] = 0;
 886    servcell->fiveGS_TAC->buf[2] = duCfgParam.srvdCellLst[0].duCellInfo.tac;
 887    return ROK;
 888 }
 889 /*******************************************************************
 890  *
 891  * @brief Builds NR Mode
 892  *
 893  * @details
 894  *
 895  *    Function : BuildNrMode
 896  *
 897  *    Functionality: Building the NR Mode
 898  *
 899  * @params[in] NR_Mode_Info_t *fdd
 900  * @return ROK     - success
 901  *         RFAILED - failure
 902  *
 903  * ****************************************************************/
 904 uint8_t BuildNrMode(NR_Mode_Info_t *mode)
 905 {
 906    uint8_t BuildDLNRInforet=0;
 907    uint8_t BuildULNRInforet=0;
 908    /* FDD Mode */
 909    mode->present = NR_Mode_Info_PR_fDD;
 910    if(mode->present == NR_Mode_Info_PR_fDD)
 911    {
 912       DU_ALLOC(mode->choice.fDD,sizeof(FDD_Info_t));
 913       if(mode->choice.fDD == NULLP)
 914       {
 915          return RFAILED;
 916       }
 917       BuildULNRInforet = BuildULNRInfo(&mode->choice.fDD->uL_NRFreqInfo);
 918       if(BuildULNRInforet != ROK)
 919       {
 920          return RFAILED;
 921       }
 922       BuildDLNRInforet = BuildDLNRInfo(&mode->choice.fDD->dL_NRFreqInfo);
 923       if(BuildDLNRInforet != ROK)
 924       {
 925          return RFAILED;
 926       }
 927    }
 928    mode->choice.fDD->uL_Transmission_Bandwidth.nRSCS = \
 929                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 930                                                        f1Mode.mode.fdd.ulTxBw.nrScs;
 931    mode->choice.fDD->uL_Transmission_Bandwidth.nRNRB = \
 932                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 933                                                        f1Mode.mode.fdd.ulTxBw.nrb;
 934    mode->choice.fDD->dL_Transmission_Bandwidth.nRSCS = \
 935                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 936                                                        f1Mode.mode.fdd.dlTxBw.nrScs;
 937    mode->choice.fDD->dL_Transmission_Bandwidth.nRNRB = \
 938                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 939                                                        f1Mode.mode.fdd.dlTxBw.nrb;
 940    return ROK;
 941 }
 942 /*******************************************************************
 943  *
 944  * @brief Builds IE Extensions for Served PLMNs
 945  *
 946  * @details
 947  *
 948  *    Function : BuildExtensions
 949  *
 950  *    Functionality: Building the IE Extensions
 951  *
 952  * @params[in] struct ProtocolExtensionContainer_4624P3 *buildextend
 953  * @return ROK     - success
 954  *         RFAILED - failure
 955  *
 956  * ****************************************************************/
 957 uint8_t BuildExtensions(ProtocolExtensionContainer_4624P3_t **ieExtend)
 958 {
 959    uint8_t idx=0, plmnidx=0, sliceLstIdx=0;
 960    uint8_t elementCnt=0, extensionCnt=0;
 961
 962    extensionCnt=IE_EXTENSION_LIST_COUNT;
 963    DU_ALLOC(*ieExtend,sizeof(ProtocolExtensionContainer_4624P3_t));
 964    if((*ieExtend) == NULLP)
 965    {
 966       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 967       return RFAILED;
 968    }
 969    (*ieExtend)->list.count = extensionCnt;
 970    (*ieExtend)->list.size = \
 971                             extensionCnt * sizeof(ServedPLMNs_ItemExtIEs_t *);
 972    DU_ALLOC((*ieExtend)->list.array,(*ieExtend)->list.size);
 973    if((*ieExtend)->list.array == NULLP)
 974    {
 975       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 976       return RFAILED;
 977    }
 978    for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
 979    {
 980       DU_ALLOC((*ieExtend)->list.array[plmnidx],\
 981             sizeof(ServedPLMNs_ItemExtIEs_t));
 982       if((*ieExtend)->list.array[plmnidx] == NULLP)
 983       {
 984          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 985          return RFAILED;
 986       }
 987    }
 988
 989    elementCnt = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].taiSliceSuppLst.numSupportedSlices;
 990    idx = 0;
 991    (*ieExtend)->list.array[idx]->id = ProtocolIE_ID_id_TAISliceSupportList;
 992    (*ieExtend)->list.array[idx]->criticality = Criticality_ignore;
 993    (*ieExtend)->list.array[idx]->extensionValue.present = \
 994    ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
 995    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 996       list.count = elementCnt;
 997    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 998       list.size = (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 999       list.count * sizeof(SliceSupportItem_t *);
1000
1001    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1002          list.array, elementCnt * sizeof(SliceSupportItem_t *));
1003    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1004          list.array == NULLP)
1005    {
1006       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1007       return RFAILED;
1008    }
1009
1010    for(sliceLstIdx =0; sliceLstIdx<elementCnt; sliceLstIdx++)
1011    {
1012       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1013             list.array[sliceLstIdx],sizeof(SliceSupportItem_t));
1014       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1015             list.array[sliceLstIdx] == NULLP)
1016       {
1017          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1018          return RFAILED;
1019       }
1020       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1021          list.array[sliceLstIdx]->sNSSAI.sST.size = sizeof(uint8_t);
1022       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
1023             .list.array[sliceLstIdx]->sNSSAI.sST.buf,(*ieExtend)->list.array[idx]->\
1024             extensionValue.choice.SliceSupportList.\
1025             list.array[sliceLstIdx]->sNSSAI.sST.size);
1026       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
1027             .list.array[sliceLstIdx]->sNSSAI.sST.buf == NULLP)
1028       {
1029          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1030          return RFAILED;
1031       }
1032       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1033          list.array[sliceLstIdx]->sNSSAI.sST.buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.\
1034          cellInfo.srvdPlmn[0].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
1035
1036       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1037             list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1038       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1039             list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
1040       {
1041          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1042          return RFAILED;
1043       }
1044       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1045          list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
1046       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1047             list.array[sliceLstIdx]->sNSSAI.sD->buf, (*ieExtend)->list.array[idx]->extensionValue.choice.\
1048             SliceSupportList.list.array[sliceLstIdx]->sNSSAI.sD->size);
1049       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1050             list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
1051       {
1052          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1053          return RFAILED;
1054       }
1055       memcpy((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1056       list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[0].duCellInfo.\
1057       cellInfo.srvdPlmn[0].taiSliceSuppLst.snssai[sliceLstIdx]->sd, (*ieExtend)->list.array[idx]->\
1058       extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->sNSSAI.sD->size);
1059    }
1060    return ROK;
1061 }
1062 /*******************************************************************
1063  *
1064  * @brief Builds Served PLMN
1065  *
1066  * @details
1067  *
1068  *    Function : BuildServedPlmn
1069  *
1070  *    Functionality: Building the Served PLMN
1071  *
1072  * @params[in] GNB_DU_Served_Cells_Item_t *srvCellItem
1073  * @return ROK     - success
1074  *         RFAILED - failure
1075  *
1076  * ****************************************************************/
1077 uint8_t  BuildServedPlmn(ServedPLMNs_List_t *srvplmn)
1078 {
1079    uint8_t  plmnidx;
1080    uint8_t  servPlmnCnt=1;
1081    uint8_t buildPlmnIdret=0;
1082    uint8_t BuildExtensionsret=0;
1083    srvplmn->list.count = servPlmnCnt;
1084    srvplmn->list.size = \
1085                         servPlmnCnt*sizeof(ServedPLMNs_Item_t *);
1086    DU_ALLOC(srvplmn->list.array,srvplmn->list.size);
1087    if(srvplmn->list.array == NULLP)
1088    {
1089       return RFAILED;
1090    }
1091    for(plmnidx=0; plmnidx<servPlmnCnt; plmnidx++)
1092    {
1093       DU_ALLOC(srvplmn->list.array[plmnidx],\
1094             sizeof(ServedPLMNs_Item_t));
1095       if(srvplmn->list.array[plmnidx] == NULLP)
1096       {
1097          return RFAILED;
1098       }
1099    }
1100    srvplmn->list.array[0]->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
1101    DU_ALLOC(srvplmn->list.array[0]->pLMN_Identity.buf, srvplmn->list.array[0]->pLMN_Identity.size);
1102    buildPlmnIdret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
1103          srvplmn->list.array[0]->pLMN_Identity.buf);
1104    if(buildPlmnIdret!= ROK)
1105    {
1106       return RFAILED;
1107    }
1108    BuildExtensionsret = BuildExtensions(&srvplmn->list.array[0]->iE_Extensions);
1109    if(BuildExtensionsret!= ROK)
1110    {
1111       return RFAILED;
1112    }
1113    return ROK;
1114 }
1115 /*******************************************************************
1116  *
1117  * @brief Builds Served Cell List
1118  *
1119  * @details
1120  *
1121  *    Function : BuildServedCellList
1122  *
1123  *    Functionality: Building Served Cell List
1124  *
1125  * @params[in] PLMNID plmn
1126  * @return ROK     - success
1127  *         RFAILED - failure
1128  *
1129  * ****************************************************************/
1130
1131 uint8_t BuildServedCellList(GNB_DU_Served_Cells_List_t *duServedCell)
1132 {
1133    uint8_t  BuildNrcgiret=0;
1134    uint8_t  BuildFiveGSTacret=0;
1135    uint8_t  BuildServedPlmnret=0;
1136    uint8_t  BuildNrModeret=0;
1137    uint8_t  idx;
1138    uint8_t  plmnidx;
1139    uint8_t  plmnCnt=1;
1140    GNB_DU_Served_Cells_Item_t *srvCellItem;
1141    duServedCell->list.size = plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t *);
1142    duServedCell->list.count = plmnCnt;
1143
1144    DU_ALLOC(duServedCell->list.array, duServedCell->list.size);
1145    if(duServedCell->list.array == NULLP)
1146    {
1147       return RFAILED;
1148    }
1149    for(plmnidx=0; plmnidx<plmnCnt; plmnidx++)
1150    {
1151       DU_ALLOC(duServedCell->list.array[plmnidx],\
1152             sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1153       if(duServedCell->list.array[plmnidx] == NULLP)
1154       {
1155          return RFAILED;
1156       }
1157    }
1158    idx = 0;
1159    duServedCell->list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_Served_Cells_Item;
1160    duServedCell->list.array[idx]->criticality = Criticality_reject;
1161    duServedCell->list.array[idx]->value.present = \
1162                                                   GNB_DU_Served_Cells_ItemIEs__value_PR_GNB_DU_Served_Cells_Item;
1163    srvCellItem = \
1164                  &duServedCell->list.array[idx]->value.choice.GNB_DU_Served_Cells_Item;
1165    /*nRCGI*/
1166    BuildNrcgiret = BuildNrcgi(&srvCellItem->served_Cell_Information.nRCGI);
1167    if(BuildNrcgiret != ROK)
1168    {
1169       return RFAILED;
1170    }
1171    /*nRPCI*/
1172    srvCellItem->served_Cell_Information.nRPCI = \
1173                                                 duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
1174
1175    /*fiveGS_TAC*/
1176    BuildFiveGSTacret = BuildFiveGSTac(&srvCellItem->served_Cell_Information);
1177    if(BuildFiveGSTacret != ROK)
1178    {
1179       return RFAILED;
1180    }
1181    /*Served PLMNs*/
1182    BuildServedPlmnret = BuildServedPlmn(&srvCellItem->served_Cell_Information.servedPLMNs);
1183    if(BuildServedPlmnret !=ROK)
1184    {
1185       return RFAILED;
1186    }
1187    /*nR Mode Info with FDD*/
1188    BuildNrModeret = BuildNrMode(&srvCellItem->served_Cell_Information.nR_Mode_Info);
1189    if(BuildNrModeret != ROK)
1190    {
1191       return RFAILED;
1192    }
1193    /*Measurement timing Config*/
1194    srvCellItem->served_Cell_Information.measurementTimingConfiguration.\
1195       size = sizeof(uint8_t);
1196    DU_ALLOC(srvCellItem->served_Cell_Information.\
1197          measurementTimingConfiguration.buf,srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1198    if(srvCellItem->served_Cell_Information.\
1199          measurementTimingConfiguration.buf == NULLP)
1200    {
1201       return RFAILED;
1202    }
1203    srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf[0] = \
1204                                                                                 duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
1205
1206    /* GNB DU System Information */
1207    DU_ALLOC(srvCellItem->gNB_DU_System_Information,
1208          sizeof(GNB_DU_System_Information_t));
1209    if(!srvCellItem->gNB_DU_System_Information)
1210    {
1211       return RFAILED;
1212    }
1213    /* MIB */
1214    srvCellItem->gNB_DU_System_Information->mIB_message.size = duCfgParam.srvdCellLst[0].duSysInfo.mibLen;
1215    DU_ALLOC(srvCellItem->gNB_DU_System_Information->mIB_message.buf,
1216          srvCellItem->gNB_DU_System_Information->mIB_message.size);
1217    if(!srvCellItem->gNB_DU_System_Information->mIB_message.buf)
1218    {
1219       return RFAILED;
1220    }
1221    memcpy(srvCellItem->gNB_DU_System_Information->mIB_message.buf, duCfgParam.srvdCellLst[0].duSysInfo.mibMsg, \
1222                    srvCellItem->gNB_DU_System_Information->mIB_message.size);
1223
1224    /* SIB1 */
1225    srvCellItem->gNB_DU_System_Information->sIB1_message.size =\
1226                                                               duCfgParam.srvdCellLst[0].duSysInfo.sib1Len;
1227
1228    DU_ALLOC(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,
1229          srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1230    if(!srvCellItem->gNB_DU_System_Information->sIB1_message.buf)
1231    {
1232       return RFAILED;
1233    }
1234    for(int x=0; x<srvCellItem->gNB_DU_System_Information->sIB1_message.size; x++)
1235    {
1236       srvCellItem->gNB_DU_System_Information->sIB1_message.buf[x]=\
1237                                                                   duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg[x];
1238    }
1239    return ROK;
1240 }
1241 /*******************************************************************
1242  *
1243  * @brief Builds RRC Version
1244  *
1245  * @details
1246  *
1247  *    Function : BuildRrcVer
1248  *
1249  *    Functionality: Building RRC Version
1250  *
1251  * @params[in] int idx,int elementCnt,RRC_Version_t *rrcver
1252  * @return ROK     - success
1253  *         RFAILED - failure
1254  *
1255  * ****************************************************************/
1256 uint8_t BuildRrcVer(RRC_Version_t *rrcVer)
1257 {
1258    uint8_t rrcExt;
1259    uint8_t rrcLatest;
1260    rrcVer->latest_RRC_Version.size = sizeof(uint8_t);
1261    DU_ALLOC(rrcVer->latest_RRC_Version.buf,sizeof(uint8_t));
1262    if(rrcVer->latest_RRC_Version.buf == NULLP)
1263    {
1264       return RFAILED;
1265    }
1266    rrcVer->latest_RRC_Version.buf[0] = 0;
1267    rrcVer->latest_RRC_Version.bits_unused = 5;
1268    DU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1269    if(rrcVer->iE_Extensions == NULLP)
1270    {
1271       return RFAILED;
1272    }
1273    rrcVer->iE_Extensions->list.count = 1;
1274    rrcVer->iE_Extensions->list.size = sizeof(RRC_Version_ExtIEs_t *);
1275    DU_ALLOC(rrcVer->iE_Extensions->list.array,rrcVer->iE_Extensions->list.size);
1276    if(rrcVer->iE_Extensions->list.array == NULLP)
1277    {
1278       return RFAILED;
1279    }
1280    rrcExt = 0;
1281    DU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
1282          sizeof(RRC_Version_ExtIEs_t));
1283    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
1284    {
1285       return RFAILED;
1286    }
1287    rrcVer->iE_Extensions->list.array[rrcExt]->id = \
1288                                                    ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
1289    rrcVer->iE_Extensions->list.array[rrcExt]->criticality = Criticality_reject;
1290    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.present =\
1291                                                                       RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
1292    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1293       .Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
1294    DU_ALLOC(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1295          .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1296          array[rrcExt]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1297    if(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1298          .Latest_RRC_Version_Enhanced.buf == NULLP)
1299    {
1300       return RFAILED;
1301    }
1302    rrcLatest = 0;
1303    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1304       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 15;
1305    rrcLatest++;
1306    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1307       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 5;
1308    rrcLatest++;
1309    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1310       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 0;
1311    return ROK;
1312 }
1313 /*******************************************************************
1314  *
1315  * @brief Sends F1 msg over SCTP
1316  *
1317  * @details
1318  *
1319  *    Function : sendF1APMsg
1320  *
1321  *    Functionality: Sends F1 msg over SCTP
1322  *
1323  * @params[in] Region region
1324  *             Pool pool
1325  * @return ROK     - success
1326  *         RFAILED - failure
1327  *
1328  * ****************************************************************/
1329 uint8_t sendF1APMsg()
1330 {
1331    Buffer *mBuf = NULLP;
1332
1333    if(ODU_GET_MSG_BUF(DU_APP_MEM_REGION, DU_POOL, &mBuf) == ROK)
1334    {
1335       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
1336       {
1337             ODU_PRINT_MSG(mBuf, 0,0);
1338
1339             if(sctpSend(mBuf, F1_INTERFACE) != ROK)
1340             {
1341                DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
1342                ODU_PUT_MSG_BUF(mBuf);
1343                return RFAILED;
1344             }
1345       }
1346       else
1347       {
1348          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
1349          ODU_PUT_MSG_BUF(mBuf);
1350          return RFAILED;
1351       }
1352       ODU_PUT_MSG_BUF(mBuf);
1353    }
1354    else
1355    {
1356       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
1357       return RFAILED;
1358    }
1359    return ROK;
1360 } /* sendF1APMsg */
1361
1362 /*******************************************************************
1363  *
1364  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1365  *
1366  * @details
1367  *
1368  *    Function :  FreeRrcVer
1369  *
1370  *    Functionality: deallocating the memory of function BuildRrcVer
1371  *
1372  * @params[in] RRC_Version_t *rrcVer
1373  *
1374  * @return void
1375  *
1376  *****************************************************************/
1377 void FreeRrcVer(RRC_Version_t *rrcVer)
1378 {
1379    if(rrcVer->latest_RRC_Version.buf != NULLP)
1380    {
1381       if(rrcVer->iE_Extensions != NULLP)
1382       {
1383          if(rrcVer->iE_Extensions->list.array != NULLP)
1384          {
1385             if(rrcVer->iE_Extensions->list.array[0] != NULLP)
1386             {
1387                if(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf
1388                      != NULLP)
1389                {
1390                   DU_FREE(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice\
1391                         .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1392                         array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1393                }
1394                DU_FREE(rrcVer->iE_Extensions->list.array[0],sizeof(RRC_Version_ExtIEs_t));
1395             }
1396             DU_FREE(rrcVer->iE_Extensions->list.array,sizeof(RRC_Version_ExtIEs_t*));
1397          }
1398          DU_FREE(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1399       }
1400       DU_FREE(rrcVer->latest_RRC_Version.buf,rrcVer->latest_RRC_Version.size);
1401    }
1402 }
1403 /*******************************************************************
1404  *
1405  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1406  *
1407  * @details
1408  *
1409  *    Function :  FreeServedCellList
1410  *
1411  *    Functionality:  deallocating the memory of function BuildServedCellList
1412
1413  *
1414  * @params[in] GNB_DU_Served_Cells_List_t *duServedCell
1415  *
1416  * @return void
1417  *
1418  * ****************************************************************/
1419 void FreeServedCellList( GNB_DU_Served_Cells_List_t *duServedCell)
1420 {
1421    uint8_t   plmnCnt=MAX_PLMN;
1422    uint8_t  extensionCnt=IE_EXTENSION_LIST_COUNT;
1423    uint8_t  plmnIdx=0, sliceIdx=0;
1424    GNB_DU_Served_Cells_Item_t *srvCellItem;
1425    ServedPLMNs_Item_t  *servedPlmnItem;
1426    SliceSupportItem_t  *sliceSupportItem;
1427
1428    if(duServedCell->list.array!=NULLP)
1429    {
1430       if(duServedCell->list.array[0]!=NULLP)
1431       {
1432          srvCellItem= &duServedCell->list.array[0]->value.choice.GNB_DU_Served_Cells_Item;
1433
1434          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1435                srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size * sizeof(uint8_t));
1436          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1437                srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size * sizeof(uint8_t));
1438
1439          if(srvCellItem->served_Cell_Information.fiveGS_TAC!=NULLP)
1440          {
1441             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
1442                   sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
1443             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,sizeof(FiveGS_TAC_t));
1444          }
1445
1446          if(srvCellItem->served_Cell_Information.servedPLMNs.list.array!=NULLP)
1447          {
1448             if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx] != NULLP)
1449             {
1450                servedPlmnItem = srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx];
1451                DU_FREE(servedPlmnItem->pLMN_Identity.buf, servedPlmnItem->pLMN_Identity.size);
1452
1453                if(servedPlmnItem->iE_Extensions != NULLP)
1454                {
1455                   if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1456                   {
1457                      if(servedPlmnItem->iE_Extensions->list.array[0] != NULLP)
1458                      {
1459                         if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1460                         SliceSupportList.list.array != NULLP)
1461                         {
1462                            for(sliceIdx =0; sliceIdx<servedPlmnItem->iE_Extensions->list.array[0]->\
1463                            extensionValue.choice.SliceSupportList.list.count; sliceIdx++)
1464                            {
1465                               if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1466                               SliceSupportList.list.array[sliceIdx] != NULLP)
1467                               {
1468                                  sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[0]->\
1469                                  extensionValue.choice.SliceSupportList.list.array[sliceIdx];
1470
1471                                  DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sizeof(uint8_t));
1472
1473                                  if(sliceSupportItem->sNSSAI.sD != NULLP)
1474                                  {
1475                                     DU_FREE(sliceSupportItem->sNSSAI.sD->buf,\
1476                                     sliceSupportItem->sNSSAI.sD->size);
1477                                     DU_FREE(sliceSupportItem->sNSSAI.sD, sizeof(OCTET_STRING_t));
1478                                  }
1479
1480                                  DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.\
1481                                  choice.SliceSupportList.list.array[sliceIdx], sizeof(SliceSupportItem_t));
1482                               }
1483                            }
1484                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1485                            SliceSupportList.list.array, servedPlmnItem->iE_Extensions->list.array[0]->\
1486                            extensionValue.choice.SliceSupportList.list.size);
1487                         }
1488                         DU_FREE(servedPlmnItem->iE_Extensions->list.array[0],\
1489                         sizeof(ServedPLMNs_ItemExtIEs_t));
1490                      }
1491                      DU_FREE(servedPlmnItem->iE_Extensions->list.array,\
1492                      extensionCnt*sizeof(ServedPLMNs_ItemExtIEs_t*));
1493                   }
1494                   DU_FREE(servedPlmnItem->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P3_t));
1495                }
1496                DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx],\
1497                sizeof(ServedPLMNs_Item_t));
1498             }
1499             DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array,\
1500             sizeof(ServedPLMNs_Item_t *));
1501          }
1502
1503          if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD != NULLP)
1504          {
1505             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
1506                   freqBandListNr.list.array != NULLP)
1507             {
1508                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
1509                uL_NRFreqInfo.freqBandListNr.list.array[0],sizeof(FreqBandNrItem_t));
1510                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
1511                uL_NRFreqInfo.freqBandListNr.list.array,sizeof(FreqBandNrItem_t*));
1512             }
1513
1514             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1515                   freqBandListNr.list.array)
1516             {
1517                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1518                      freqBandListNr.list.array[0],sizeof(FreqBandNrItem_t));
1519                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1520                      freqBandListNr.list.array,sizeof(FreqBandNrItem_t *));
1521             }
1522             DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD, sizeof(FDD_Info_t));
1523          }
1524
1525          DU_FREE(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1526                srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1527
1528          if(srvCellItem->gNB_DU_System_Information != NULLP)
1529          {
1530             if(srvCellItem->gNB_DU_System_Information->mIB_message.buf != NULLP)
1531             {
1532                DU_FREE(srvCellItem->gNB_DU_System_Information->mIB_message.buf,\
1533                      srvCellItem->gNB_DU_System_Information->mIB_message.size);
1534             }
1535
1536             if(srvCellItem->gNB_DU_System_Information->sIB1_message.buf != NULLP)
1537             {
1538                DU_FREE(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,\
1539                      srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1540             }
1541
1542             DU_FREE(srvCellItem->gNB_DU_System_Information, sizeof(GNB_DU_System_Information_t));
1543          }
1544
1545          DU_FREE(duServedCell->list.array[0], sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1546       }
1547       DU_FREE(duServedCell->list.array, plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t*));
1548    }
1549 }
1550
1551 /*******************************************************************
1552  *
1553  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1554  *
1555  * @details
1556  *
1557  *    Function :  FreeF1SetupReq
1558  *
1559  *    Functionality:  deallocating the memory of function BuildAndSendF1SetupReq
1560  *
1561  * @params[in] F1AP_PDU_t *f1apMsg
1562  *
1563  * @return void
1564  *
1565  * ****************************************************************/
1566 void FreeF1SetupReq(F1AP_PDU_t *f1apMsg)
1567 {
1568    uint8_t ieIdx, ieIdx2;
1569    F1SetupRequest_t *f1SetupReq=NULLP;
1570
1571    if(f1apMsg != NULLP)
1572    {
1573       if(f1apMsg->choice.initiatingMessage != NULLP)
1574       {
1575          f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1576          if(f1SetupReq->protocolIEs.list.array != NULLP)
1577          {
1578             for(ieIdx = 0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
1579             {
1580                if(f1SetupReq->protocolIEs.list.array[ieIdx] != NULLP)
1581                {
1582                   switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
1583                   {
1584                      case ProtocolIE_ID_id_TransactionID:
1585                         break;
1586                      case ProtocolIE_ID_id_gNB_DU_ID:
1587                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1588                               f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1589                         break;
1590                      case ProtocolIE_ID_id_gNB_DU_Name:
1591                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,\
1592                               strlen((char *)duCfgParam.duName));
1593                         break;
1594                      case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
1595                         FreeServedCellList(&f1SetupReq->protocolIEs.list.\
1596                               array[ieIdx]->value.choice.GNB_DU_Served_Cells_List);
1597                         break;
1598                      case ProtocolIE_ID_id_GNB_DU_RRC_Version:
1599                         FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version);
1600                         break;
1601                      default:
1602                         DU_LOG("\nERROR  -->  Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id);
1603                         break;
1604                   }
1605                }
1606             }
1607             for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++)
1608             {
1609                DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx2],sizeof(F1SetupRequestIEs_t));
1610             }
1611             DU_FREE(f1SetupReq->protocolIEs.list.array,\
1612                   f1SetupReq->protocolIEs.list.size);
1613          }
1614          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1615       }
1616       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1617    }
1618 }
1619 /*******************************************************************
1620  *
1621  * @brief Builds and Send the F1SetupRequest
1622  *
1623  * @details
1624  *
1625  *    Function : BuildAndSendF1SetupReq
1626  *
1627  * Functionality:Fills the F1SetupRequest
1628  *
1629  * @return ROK     - success
1630  *         RFAILED - failure
1631  *
1632  ******************************************************************/
1633 uint8_t BuildAndSendF1SetupReq()
1634 {
1635    uint8_t   ret, ieIdx, elementCnt;
1636    F1AP_PDU_t                 *f1apMsg = NULLP;
1637    F1SetupRequest_t           *f1SetupReq=NULLP;
1638    GNB_DU_Served_Cells_List_t *duServedCell=NULLP;
1639    RRC_Version_t              *rrcVer=NULLP;
1640    asn_enc_rval_t             encRetVal;        /* Encoder return value */
1641    ret= RFAILED;
1642
1643    DU_LOG("\nINFO   -->  F1AP : Building F1 Setup Request\n");
1644    do
1645    {
1646       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1647       if(f1apMsg == NULLP)
1648       {
1649          break;
1650       }
1651       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1652       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1653       if(f1apMsg->choice.initiatingMessage == NULLP)
1654       {
1655          break;
1656       }
1657       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_F1Setup;
1658       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
1659       f1apMsg->choice.initiatingMessage->value.present = \
1660                                                          InitiatingMessage__value_PR_F1SetupRequest;
1661
1662       f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1663
1664       elementCnt = (duCfgParam.duName != NULL) ? 5 : 4;
1665
1666       f1SetupReq->protocolIEs.list.count = elementCnt;
1667       f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t );
1668
1669       /* Initialize the F1Setup members */
1670       DU_ALLOC(f1SetupReq->protocolIEs.list.array,f1SetupReq->protocolIEs.list.size);
1671       if(f1SetupReq->protocolIEs.list.array == NULLP)
1672       {
1673          break;
1674       }
1675       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
1676       {
1677          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx],\
1678                sizeof(F1SetupRequestIEs_t));
1679          if(f1SetupReq->protocolIEs.list.array[ieIdx] == NULLP)
1680          {
1681             break;
1682          }
1683       }
1684
1685       ieIdx = 0;
1686       /*TransactionID*/
1687       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransactionID;
1688       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1689       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present =\
1690                                                                F1SetupRequestIEs__value_PR_TransactionID;
1691       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = \
1692                                                                              TRANS_ID;
1693
1694       /*DU ID*/
1695       ieIdx++;
1696       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
1697       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1698       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1699                                                                 F1SetupRequestIEs__value_PR_GNB_DU_ID;
1700       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size =\
1701                                                                              sizeof(uint8_t);
1702
1703       DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1704             f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1705       if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == \
1706             NULLP)
1707       {
1708          break;
1709       }
1710
1711       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] =\
1712          duCfgParam.duId;
1713
1714       /*DU Name*/
1715       if(duCfgParam.duName != NULL)
1716       {
1717          ieIdx++;
1718          f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_Name;
1719          f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
1720          f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = F1SetupRequestIEs__value_PR_GNB_DU_Name;
1721          f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.size =\
1722             strlen((char *)duCfgParam.duName);
1723          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.\
1724                GNB_DU_Name.buf, strlen((char *)duCfgParam.duName));
1725          if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.\
1726                buf == NULLP)
1727          {
1728             break;
1729          }
1730          strcpy((char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.\
1731                choice.GNB_DU_Name.buf,
1732                (char*)&duCfgParam.duName);
1733
1734       }
1735
1736       /*Served Cell list */
1737       ieIdx++;
1738       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1739                                                      ProtocolIE_ID_id_gNB_DU_Served_Cells_List;
1740       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1741       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1742                                                                 F1SetupRequestIEs__value_PR_GNB_DU_Served_Cells_List;
1743       duServedCell = &f1SetupReq->protocolIEs.list.\
1744                      array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
1745       if(BuildServedCellList(duServedCell))
1746       {
1747          break;
1748       }
1749       /*RRC Version*/
1750       ieIdx++;
1751       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1752                                                      ProtocolIE_ID_id_GNB_DU_RRC_Version ;
1753       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1754       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1755                                                                 F1SetupRequestIEs__value_PR_RRC_Version;
1756       rrcVer = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
1757       if(BuildRrcVer(rrcVer))
1758       {
1759          break;
1760       }
1761       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1762
1763       /* Encode the F1SetupRequest type as APER */
1764       memset(encBuf, 0, ENC_BUF_MAX_LEN);
1765       encBufSize = 0;
1766       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1767             encBuf);
1768
1769       /* Encode results */
1770       if(encRetVal.encoded == ENCODE_FAIL)
1771       {
1772          DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupRequest structure (at %s)\n",\
1773                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1774          break;
1775       }
1776       else
1777       {
1778          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1SetupRequest\n");
1779          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
1780          {
1781             printf("%x",encBuf[ieIdx]);
1782          }
1783       }
1784
1785       /* Sending msg */
1786       if(sendF1APMsg() != ROK)
1787       {
1788          DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup request failed");
1789          break;
1790       }
1791
1792       ret=ROK;
1793       break;
1794    }while(true);
1795
1796    FreeF1SetupReq(f1apMsg);
1797
1798    return ret;
1799 }/* End of BuildAndSendF1SetupReq */
1800
1801 /*******************************************************************
1802  *
1803  * @brief Deallocating memory allocated for Served_Cells_To_Modify_Item_t
1804  *
1805  * @details
1806  *
1807  *    Function : freeCellsToModifyItem
1808  *
1809  *    Functionality: Deallocating memory of variables allocated in
1810  *                    BuildAndSendDUConfigUpdate function
1811  *
1812  * @params[in]  Served_Cells_To_Modify_Item_t *modifyItem
1813  *
1814  * @return ROK     - void
1815  *
1816  * ****************************************************************/
1817
1818 void freeCellsToModifyItem(Served_Cells_To_Modify_Item_t *modifyItem)
1819 {
1820    uint8_t arrIdx=0, servedPlmnIdx=0, sliceLstIdx=0;
1821    ServedPLMNs_Item_t *servedPlmnItem = NULLP;
1822    SliceSupportItem_t *sliceSupportItem = NULLP;
1823
1824    DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf, modifyItem->oldNRCGI.pLMN_Identity.size);
1825    DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf, modifyItem->oldNRCGI.nRCellIdentity.size);
1826
1827    DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1828            modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
1829    DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1830          modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
1831
1832    if(modifyItem->served_Cell_Information.servedPLMNs.list.array != NULLP)
1833    {
1834       if(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx] != NULLP)
1835       {
1836          servedPlmnItem = modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx];
1837
1838          DU_FREE(servedPlmnItem->pLMN_Identity.buf,servedPlmnItem->pLMN_Identity.size);
1839
1840          if(servedPlmnItem->iE_Extensions != NULLP)
1841          {
1842             if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1843             {
1844                if(servedPlmnItem->iE_Extensions->list.array[arrIdx] != NULLP)
1845                {
1846                   if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1847                         list.array != NULLP)
1848                   {
1849                      for(sliceLstIdx =0; sliceLstIdx<servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
1850                            extensionValue.choice.SliceSupportList.list.count; sliceLstIdx++)
1851                      {
1852                         if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1853                               list.array[sliceLstIdx] != NULLP)
1854                         {
1855
1856                            sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1857                                               SliceSupportList.list.array[sliceLstIdx];
1858
1859                            DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sliceSupportItem->sNSSAI.sST.size);
1860                            if(sliceSupportItem->sNSSAI.sD != NULLP)
1861                            {
1862                               DU_FREE(sliceSupportItem->sNSSAI.sD->buf, sliceSupportItem->sNSSAI.sD->size);
1863                               DU_FREE(sliceSupportItem->sNSSAI.sD,sizeof(OCTET_STRING_t));
1864                            }
1865                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1866                                  SliceSupportList.list.array[sliceLstIdx], sizeof(SliceSupportItem_t));
1867                         }
1868                      }
1869                      DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.\
1870                            choice.SliceSupportList.list.array,\
1871                            servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
1872                            extensionValue.choice.SliceSupportList.list.size);
1873                   }
1874                }
1875                for(servedPlmnIdx=0; servedPlmnIdx< servedPlmnItem->iE_Extensions->list.count ; servedPlmnIdx++)
1876                {
1877                   DU_FREE(servedPlmnItem->iE_Extensions->list.array[servedPlmnIdx], sizeof(ServedPLMNs_ItemExtIEs_t ));
1878                }
1879                DU_FREE(servedPlmnItem->iE_Extensions->list.array, servedPlmnItem->iE_Extensions->list.size);
1880             }
1881             DU_FREE(servedPlmnItem->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1882          }
1883       }
1884       for(servedPlmnIdx=0; servedPlmnIdx<modifyItem->served_Cell_Information.servedPLMNs.list.count; servedPlmnIdx++)
1885       {
1886          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[servedPlmnIdx], sizeof(ServedPLMNs_Item_t));
1887       }
1888       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1889          modifyItem->served_Cell_Information.servedPLMNs.list.size);
1890    }
1891
1892    if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD != NULLP)
1893    {
1894       if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1895       {
1896          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
1897                array[arrIdx], sizeof(FreqBandNrItem_t));
1898          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array, \
1899                modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1900       }
1901
1902       if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1903       {
1904          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.\
1905              array[arrIdx], sizeof(FreqBandNrItem_t));
1906          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,\
1907                modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1908       }
1909       DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD,sizeof(FDD_Info_t));
1910    }
1911
1912    DU_FREE(modifyItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1913       modifyItem->served_Cell_Information.measurementTimingConfiguration.size);
1914 }
1915
1916 /*******************************************************************
1917  *
1918  * @brief Deallocating memory of BuildAndSendDUConfigUpdate
1919  *
1920  * @details
1921  *
1922  *    Function : FreeDUConfigUpdate
1923  *
1924  *    Functionality: Deallocating memory of variables allocated in
1925  *                    BuildAndSendDUConfigUpdate function
1926  *
1927  * @params[in]  F1AP_PDU_t *f1apDuCfg
1928  *
1929  * @return ROK     - void
1930  *
1931  * ****************************************************************/
1932 void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg)
1933 {
1934    uint8_t  ieIdx=0, cellModifyIdx=0, cellDeleteIdx=0;
1935    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
1936    Served_Cells_To_Modify_List_t  *cellsToModify=NULLP;
1937    Served_Cells_To_Delete_List_t  *cellsToDelete=NULLP;
1938    Served_Cells_To_Delete_Item_t  *deleteItem = NULLP;
1939    Served_Cells_To_Delete_ItemIEs_t *deleteItemIe = NULLP;
1940
1941    if(f1apDuCfg != NULLP)
1942    {
1943       if(f1apDuCfg->choice.initiatingMessage != NULLP)
1944       {
1945          duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->\
1946                        value.choice.GNBDUConfigurationUpdate;
1947          if(duCfgUpdate->protocolIEs.list.array != NULLP)
1948          {
1949             for(ieIdx=0; ieIdx<duCfgUpdate->protocolIEs.list.count; ieIdx++)
1950             {
1951                if(duCfgUpdate->protocolIEs.list.array[ieIdx] != NULLP)
1952                {
1953                   switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
1954                   {
1955                      case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
1956                         {
1957                            cellsToModify = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1958                                            value.choice.Served_Cells_To_Modify_List;
1959                            if(cellsToModify->list.array != NULLP)
1960                            {
1961                               for(cellModifyIdx=0; cellModifyIdx<cellsToModify->list.count ;cellModifyIdx++)
1962                               {
1963                                  if(cellsToModify->list.array[cellModifyIdx] != NULLP)
1964                                  {
1965                                     freeCellsToModifyItem(&cellsToModify->list.array[cellModifyIdx]->value.choice.\
1966                                           Served_Cells_To_Modify_Item);
1967                                     DU_FREE(cellsToModify->list.array[cellModifyIdx],\
1968                                           sizeof(Served_Cells_To_Modify_ItemIEs_t));
1969                                  }
1970                               }
1971                               DU_FREE(cellsToModify->list.array,cellsToModify->list.size);
1972                            }
1973                            break;
1974                         }
1975                      case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
1976                         {
1977                            cellsToDelete = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1978                                            value.choice.Served_Cells_To_Delete_List;
1979                            if(cellsToDelete->list.array != NULLP)
1980                            {
1981                               for(cellDeleteIdx=0; cellDeleteIdx<cellsToDelete->list.count ;cellDeleteIdx++)
1982                               {
1983                                  if(cellsToDelete->list.array[cellDeleteIdx] != NULLP)
1984                                  {
1985                                     deleteItemIe = ((Served_Cells_To_Delete_ItemIEs_t*)\
1986                                           cellsToDelete->list.array[cellDeleteIdx]);
1987                                     deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
1988                                     DU_FREE(deleteItem->oldNRCGI.pLMN_Identity.buf,\
1989                                           deleteItem->oldNRCGI.pLMN_Identity.size);
1990                                     DU_FREE(deleteItem->oldNRCGI.nRCellIdentity.buf,\
1991                                           deleteItem->oldNRCGI.nRCellIdentity.size);
1992                                     DU_FREE(cellsToDelete->list.array[cellDeleteIdx],\
1993                                           sizeof(Served_Cells_To_Delete_ItemIEs_t));
1994                                  }
1995                               }
1996                               DU_FREE(cellsToDelete->list.array,cellsToDelete->list.size);
1997                            }
1998
1999                            break;
2000                         }
2001                      case ProtocolIE_ID_id_gNB_DU_ID:
2002                         {
2003                            DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2004                                  duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2005                            break;
2006                         }
2007                   }
2008                   DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx],\
2009                         sizeof(GNBDUConfigurationUpdateIEs_t));
2010                }
2011             }
2012             DU_FREE(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2013          }
2014          DU_FREE(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2015       }
2016       DU_FREE(f1apDuCfg, (Size)sizeof(F1AP_PDU_t));
2017    }
2018 }
2019
2020 /*******************************************************************
2021  *
2022  * @brief Fills Served Plmns required in ServCellInfo IE
2023  *
2024  * @details
2025  *
2026  *    Function : fillServedPlmns
2027  *
2028  *    Functionality: Fills Served Plmns required in ServCellInfo IE
2029  *
2030  * @params[in] Pointer to ServedPLMNs_List_t *
2031  *
2032  * @return ROK     - success
2033  *         RFAILED - failure
2034  *
2035  *****************************************************************/
2036
2037 uint8_t fillServedPlmns(ServedPLMNs_List_t *servedPlmn)
2038 {
2039    uint8_t ieIdx=0, arrayIdx=0, ieListCnt=0, elementCnt=0, sliceLstIdx=0;
2040
2041    servedPlmn->list.array[arrayIdx]->pLMN_Identity.size = 3*sizeof(uint8_t);
2042    DU_ALLOC(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf, servedPlmn->list.\
2043          array[arrayIdx]->pLMN_Identity.size);
2044    if(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf == NULLP)
2045    {
2046       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2047       return RFAILED;
2048    }
2049    buildPlmnId(duCfgParam.srvdCellLst[arrayIdx].duCellInfo.cellInfo.srvdPlmn[arrayIdx].plmn,\
2050          servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf);
2051    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
2052    if(servedPlmn->list.array[arrayIdx]->iE_Extensions == NULLP)
2053    {
2054       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2055       return RFAILED;
2056    }
2057
2058    ieListCnt=1;
2059    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.count = ieListCnt;
2060    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.size = ieListCnt *sizeof(ServedPLMNs_ItemExtIEs_t *);
2061    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array,servedPlmn->list.array[arrayIdx]->\
2062          iE_Extensions->list.size);
2063    if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array == NULLP)
2064    {
2065       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2066       return RFAILED;
2067    }
2068    for(ieIdx=arrayIdx;ieIdx<ieListCnt;ieIdx++)
2069    {
2070       DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx],\
2071             sizeof(ServedPLMNs_ItemExtIEs_t));
2072       if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx] == NULLP)
2073       {
2074          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2075          return RFAILED;
2076       }
2077    }
2078
2079    ieIdx = 0;
2080    elementCnt = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].taiSliceSuppLst.numSupportedSlices;
2081    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->id =ProtocolIE_ID_id_TAISliceSupportList;
2082    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->criticality = Criticality_ignore;
2083    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.present = \
2084    ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
2085    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2086       list.count = elementCnt;
2087    servedPlmn->list.array[arrayIdx]->\
2088       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2089       list.size = elementCnt * sizeof(SliceSupportItem_t *);
2090    DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2091          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2092          list.array,servedPlmn->list.array[arrayIdx]->\
2093          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.size);
2094    if(servedPlmn->list.array[arrayIdx]->\
2095          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2096          list.array == NULLP)
2097    {
2098       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2099       return RFAILED;
2100    }
2101
2102    for(sliceLstIdx =0; sliceLstIdx< elementCnt; sliceLstIdx++)
2103    {
2104       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2105       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2106       list.array[sliceLstIdx],sizeof( SliceSupportItem_t));
2107       if(servedPlmn->list.array[arrayIdx]->\
2108       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2109       list.array[sliceLstIdx] == NULLP)
2110       {
2111          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2112          return RFAILED;
2113       }
2114
2115       servedPlmn->list.array[arrayIdx]->\
2116       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2117       list.array[sliceLstIdx]->sNSSAI.sST.size = sizeof(uint8_t);
2118       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2119       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2120       list.array[sliceLstIdx]->sNSSAI.sST.buf,servedPlmn->list.array[arrayIdx]->\
2121       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->\
2122       sNSSAI.sST.size);
2123
2124       if(servedPlmn->list.array[arrayIdx]->\
2125       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2126       list.array[sliceLstIdx]->sNSSAI.sST.buf == NULLP)
2127       {
2128          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2129          return RFAILED;
2130       }
2131       servedPlmn->list.array[arrayIdx]->\
2132       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2133       list.array[sliceLstIdx]->sNSSAI.sST.buf[arrayIdx] =  duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
2134       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
2135
2136       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2137       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2138       list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
2139       if(servedPlmn->list.array[arrayIdx]->\
2140       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2141       list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
2142       {
2143          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2144          return RFAILED;
2145       }
2146       servedPlmn->list.array[arrayIdx]->\
2147       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2148       list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
2149       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2150       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2151       list.array[sliceLstIdx]->sNSSAI.sD->buf,servedPlmn->list.array[arrayIdx]->\
2152       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2153       list.array[sliceLstIdx]->sNSSAI.sD->size);
2154       if(servedPlmn->list.array[arrayIdx]->\
2155       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2156       list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
2157       {
2158          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2159          return RFAILED;
2160       }
2161       memcpy(servedPlmn->list.array[arrayIdx]->\
2162       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2163       list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
2164       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sd,\
2165       servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2166       list.array[sliceLstIdx]->sNSSAI.sD->size);
2167    }
2168    return ROK;
2169 }
2170
2171 /*******************************************************************
2172  *
2173  * @brief Fills Nr Fdd Info required in ServCellInfo IE
2174  *
2175  * @details
2176  *
2177  *    Function : fillNrFddInfo
2178  *
2179  *    Functionality: Fills Nr Fdd Info required in ServCellInfo IE
2180  *
2181  * @params[in] Pointer to NR_Mode_Info_t *
2182  *
2183  * @return ROK     - success
2184  *         RFAILED - failure
2185  *
2186  *****************************************************************/
2187
2188 uint8_t fillNrFddInfo(NR_Mode_Info_t *nrFdd)
2189 {
2190    nrFdd->choice.fDD->uL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.\
2191       f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn;
2192    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.count = 1;
2193    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t*);
2194    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
2195          array, nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size);
2196    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2197    {
2198       return RFAILED;
2199    }
2200    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0], \
2201       sizeof(FreqBandNrItem_t));
2202    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2203    {
2204       return RFAILED;
2205    }
2206    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2207       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
2208       freqBand[0].nrFreqBand;
2209    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2210    nrFdd->choice.fDD->dL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.\
2211       dlNrFreqInfo.nrArfcn;
2212    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.count = 1;
2213    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
2214    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,nrFdd->\
2215          choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
2216    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2217    {
2218       return RFAILED;
2219    }
2220    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0],\
2221          sizeof(FreqBandNrItem_t));
2222    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2223    {
2224       return RFAILED;
2225    }
2226    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2227       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
2228       freqBand[0].nrFreqBand;
2229    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2230
2231    /*Transmission Bandwidth*/
2232    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2233       f1Mode.mode.fdd.ulTxBw.nrScs;
2234    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2235       f1Mode.mode.fdd.ulTxBw.nrb;
2236    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2237       f1Mode.mode.fdd.dlTxBw.nrScs;
2238    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2239       f1Mode.mode.fdd.dlTxBw.nrb;
2240
2241    return ROK;
2242 }
2243
2244 /*******************************************************************
2245  *
2246  * @brief Fills ServCellInfo IE
2247  *
2248  * @details
2249  *
2250  *    Function : fillServedCellInfo
2251  *
2252  *    Functionality: Fills ServCellInfo
2253  *
2254  * @params[in] Pointer to Served_Cell_Information_t *
2255  *
2256  * @return ROK     - success
2257  *         RFAILED - failure
2258  *
2259  *****************************************************************/
2260
2261 uint8_t fillServedCellInfo(Served_Cell_Information_t *srvCellInfo)
2262 {
2263    uint8_t tmp, ieIdx, ieListCnt;
2264
2265    /*nRCGI*/
2266    srvCellInfo->nRCGI.pLMN_Identity.size =3*sizeof(uint8_t);
2267    DU_ALLOC(srvCellInfo->nRCGI.pLMN_Identity.buf,\
2268          srvCellInfo->nRCGI.pLMN_Identity.size);
2269    if(srvCellInfo->nRCGI.pLMN_Identity.buf == NULLP)
2270    {
2271       return RFAILED;
2272    }
2273    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2274          srvCellInfo->nRCGI.pLMN_Identity.buf);
2275    srvCellInfo->nRCGI.nRCellIdentity.size =5*sizeof(uint8_t);
2276    DU_ALLOC(srvCellInfo->nRCGI.nRCellIdentity.buf,\
2277          srvCellInfo->nRCGI.nRCellIdentity.size);
2278    if(srvCellInfo->nRCGI.nRCellIdentity.buf == NULLP)
2279    {
2280       return RFAILED;
2281    }
2282    for (tmp = 0 ; tmp < srvCellInfo->\
2283          nRCGI.nRCellIdentity.size-1 ; tmp++)
2284    {
2285       srvCellInfo->nRCGI.nRCellIdentity.buf[tmp] = 0;
2286    }
2287    srvCellInfo->nRCGI.nRCellIdentity.buf[4] = 16;
2288    srvCellInfo->nRCGI.nRCellIdentity.bits_unused =4;
2289
2290    /*nRPCI*/
2291    srvCellInfo->nRPCI = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
2292
2293    /*servedPLMNs*/
2294    ieListCnt = 1;
2295    srvCellInfo->servedPLMNs.list.count = ieListCnt;
2296    srvCellInfo->servedPLMNs.list.size = ieListCnt*sizeof(ServedPLMNs_Item_t *);
2297    DU_ALLOC(srvCellInfo->servedPLMNs.list.array,\
2298          srvCellInfo->servedPLMNs.list.size);
2299    if(srvCellInfo->servedPLMNs.list.array == NULLP)
2300    {
2301       return RFAILED;
2302    }
2303    for(ieIdx=0; ieIdx < ieListCnt; ieIdx++)
2304    {
2305       DU_ALLOC(srvCellInfo->servedPLMNs.list.array[ieIdx],\
2306             sizeof(ServedPLMNs_Item_t));
2307       if(srvCellInfo->servedPLMNs.list.array[ieIdx]== NULLP)
2308       {
2309          return RFAILED;
2310       }
2311    }
2312    if(fillServedPlmns(&srvCellInfo->servedPLMNs))
2313    {
2314       return RFAILED;
2315    }
2316
2317    /*nR Mode Info with FDD*/
2318    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_fDD;
2319    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.fDD,\
2320          sizeof(FDD_Info_t));
2321    if(srvCellInfo->nR_Mode_Info.choice.fDD == NULLP)
2322    {
2323       return RFAILED;
2324    }
2325    if(fillNrFddInfo(&srvCellInfo->nR_Mode_Info))
2326       return RFAILED;
2327
2328    /*Measurement timing Config*/
2329    srvCellInfo->measurementTimingConfiguration.size = sizeof(uint8_t);
2330    DU_ALLOC(srvCellInfo->measurementTimingConfiguration.\
2331          buf,srvCellInfo->measurementTimingConfiguration.size);
2332    if(srvCellInfo->measurementTimingConfiguration.buf == NULLP)
2333    {
2334       return RFAILED;
2335    }
2336    srvCellInfo->measurementTimingConfiguration.\
2337          buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
2338
2339    return ROK;
2340 }
2341
2342 /*******************************************************************
2343  *
2344  * @brief Fills ServCellToModItem IE
2345  *
2346  * @details
2347  *
2348  *    Function : fillServCellToModItem
2349  *
2350  *    Functionality: Fills ServCellToModItem IE
2351  *
2352  * @params[in] Pointer to Served_Cells_To_Modify_Item_t *
2353  *
2354  * @return ROK     - success
2355  *         RFAILED - failure
2356  *
2357  *****************************************************************/
2358
2359 uint8_t fillServCellToModItem(Served_Cells_To_Modify_Item_t *modifyItem)
2360 {
2361    uint8_t ieIdx;
2362
2363    /*pLMN_Identity*/
2364    modifyItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2365    DU_ALLOC(modifyItem->oldNRCGI.pLMN_Identity.buf,modifyItem->oldNRCGI.pLMN_Identity.size);
2366    if(modifyItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2367    {
2368       return RFAILED;
2369    }
2370    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2371          modifyItem->oldNRCGI.pLMN_Identity.buf);
2372
2373    /*nRCellIdentity*/
2374    modifyItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2375    DU_ALLOC(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2376          modifyItem->oldNRCGI.nRCellIdentity.size);
2377    if(modifyItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2378    {
2379       return RFAILED;
2380    }
2381    for(ieIdx = 0; ieIdx < modifyItem->oldNRCGI.nRCellIdentity.size-1; ieIdx++)
2382    {
2383       modifyItem->oldNRCGI.nRCellIdentity.buf[ieIdx] = 0;
2384    }
2385    modifyItem->oldNRCGI.nRCellIdentity.buf[4] = 16;
2386    modifyItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
2387
2388    if(fillServedCellInfo(&modifyItem->served_Cell_Information))
2389       return RFAILED;
2390    else
2391       return ROK;
2392 }
2393
2394 /*******************************************************************
2395  *
2396  * @brief Builds ServCellToModList
2397  *
2398  * @details
2399  *
2400  *    Function : buildServCellToModList
2401  *
2402  *    Functionality: Builds the serv cell to Mod List
2403  *
2404  * @params[in] Pointer to Served_Cells_To_Modify_List_t *
2405  *
2406  * @return ROK     - success
2407  *         RFAILED - failure
2408  *
2409  *****************************************************************/
2410
2411 uint8_t buildServCellToModList(Served_Cells_To_Modify_List_t *cellsToModify)
2412 {
2413    uint8_t ieListCnt, ieIdx;
2414    Served_Cells_To_Modify_Item_t *modifyItem = NULLP;
2415
2416    ieListCnt = 1;
2417    cellsToModify->list.count = ieListCnt;
2418    cellsToModify->list.size = ieListCnt*sizeof(Served_Cells_To_Modify_ItemIEs_t *);
2419    DU_ALLOC(cellsToModify->list.array,cellsToModify->list.size);
2420    if(cellsToModify->list.array == NULLP)
2421    {
2422       return RFAILED;
2423    }
2424    for(ieIdx=0; ieIdx< ieListCnt; ieIdx++)
2425    {
2426       DU_ALLOC(cellsToModify->list.array[ieIdx],sizeof(Served_Cells_To_Modify_ItemIEs_t));
2427       if(cellsToModify->list.array[ieIdx] == NULLP)
2428       {
2429          return RFAILED;
2430       }
2431    }
2432    cellsToModify->list.array[0]->id = ProtocolIE_ID_id_Served_Cells_To_Modify_Item;
2433    cellsToModify->list.array[0]->criticality = Criticality_reject;
2434    cellsToModify->list.array[0]->value.present =\
2435       Served_Cells_To_Modify_ItemIEs__value_PR_Served_Cells_To_Modify_Item;
2436    modifyItem=&cellsToModify->list.array[0]->value.choice.Served_Cells_To_Modify_Item;
2437
2438    if(fillServCellToModItem(modifyItem))
2439       return RFAILED;
2440    else
2441       return ROK;
2442 }
2443 /*******************************************************************
2444  *
2445  * @brief filling the DeleteItemList
2446  *
2447  * @details
2448  *
2449  *    Function : fillCellToDeleteItem
2450  *
2451  *    Functionality: Filling the DeleteItemIe
2452  *
2453  * @params[in] Pointer to Served_Cells_To_Delete_ItemIEs_t
2454  *
2455  * @return ROK     - success
2456  *         RFAILED - failure
2457  *
2458  *****************************************************************/
2459 uint8_t fillCellToDeleteItem(struct Served_Cells_To_Delete_ItemIEs *deleteItemIe)
2460 {
2461    uint8_t arrIdx;
2462    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
2463
2464    deleteItemIe->id = ProtocolIE_ID_id_Served_Cells_To_Delete_Item;
2465    deleteItemIe->criticality = Criticality_reject;
2466    deleteItemIe->value.present =\
2467    Served_Cells_To_Delete_ItemIEs__value_PR_Served_Cells_To_Delete_Item;
2468    deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
2469
2470    /*pLMN_Identity*/
2471    deleteItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2472    DU_ALLOC(deleteItem->oldNRCGI.pLMN_Identity.buf,deleteItem->oldNRCGI.pLMN_Identity.size);
2473    if(deleteItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2474    {
2475       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2476       return RFAILED;
2477    }
2478    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2479          deleteItem->oldNRCGI.pLMN_Identity.buf);
2480
2481    /*nRCellIdentity*/
2482    deleteItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2483    DU_ALLOC(deleteItem->oldNRCGI.nRCellIdentity.buf,\
2484          deleteItem->oldNRCGI.nRCellIdentity.size);
2485    if(deleteItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2486    {
2487       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2488       return RFAILED;
2489    }
2490    for(arrIdx = 0; arrIdx < deleteItem->oldNRCGI.nRCellIdentity.size-1; arrIdx++)
2491    {
2492       deleteItem->oldNRCGI.nRCellIdentity.buf[arrIdx] = 0;
2493    }
2494    deleteItem->oldNRCGI.nRCellIdentity.buf[4] = 16;
2495    deleteItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
2496    return ROK;
2497 }
2498 /*******************************************************************
2499  *
2500  * @brief Builds ServCellToDeleteList
2501  *
2502  * @details
2503  *
2504  *    Function : buildServCellToDeleteList
2505  *
2506  *    Functionality: Builds the serv cell to delete List
2507  *
2508  * @params[in] Pointer to Served_Cells_To_Delete_List_t *
2509  *
2510  * @return ROK     - success
2511  *         RFAILED - failure
2512  *
2513  *****************************************************************/
2514
2515 uint8_t buildServCellToDeleteList(Served_Cells_To_Delete_List_t *cellsToDelete)
2516 {
2517    uint8_t ieListCnt, arrIdx;
2518
2519    ieListCnt = 1;
2520    cellsToDelete->list.count = ieListCnt;
2521    cellsToDelete->list.size = ieListCnt*sizeof(Served_Cells_To_Delete_ItemIEs_t *);
2522
2523    DU_ALLOC(cellsToDelete->list.array,cellsToDelete->list.size);
2524    if(cellsToDelete->list.array == NULLP)
2525    {
2526       DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2527       return RFAILED;
2528    }
2529
2530    for(arrIdx=0; arrIdx< ieListCnt; arrIdx++)
2531    {
2532       DU_ALLOC(cellsToDelete->list.array[arrIdx],sizeof(Served_Cells_To_Delete_ItemIEs_t));
2533       if(cellsToDelete->list.array[arrIdx] == NULLP)
2534       {
2535          DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2536          return RFAILED;
2537       }
2538    }
2539
2540    arrIdx=0;
2541    if(fillCellToDeleteItem((Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx]) !=ROK)
2542    {
2543       DU_LOG("\nERROR  -->  F1AP: buildServCellToDeleteList(): failed to fill Served_Cells_To_Delete_ItemIEs");
2544       return RFAILED;
2545    }
2546    return ROK;
2547 }
2548
2549 /*******************************************************************
2550  *
2551  * @brief Builds and sends the DUConfigUpdate
2552  *
2553  * @details
2554  *
2555  *    Function : BuildAndSendDUConfigUpdate
2556  *
2557  *    Functionality: Constructs the DU Update message and sends
2558  *                   it to the CU through SCTP.
2559  *
2560  * @params[in] void **buf,Buffer to which encoded pattern is written into
2561  * @params[in] int *size,size of buffer
2562  *
2563  * @return ROK     - success
2564  *         RFAILED - failure
2565  *
2566  * ****************************************************************/
2567 uint8_t BuildAndSendDUConfigUpdate(ServCellAction servCellAction)
2568 {
2569    uint8_t ret =0, ieIdx=0, elementCnt=0;
2570    bool memAlloctionFailure = false;
2571    F1AP_PDU_t                 *f1apDuCfg = NULLP;
2572    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
2573    asn_enc_rval_t encRetVal;     /* Encoder return value */
2574
2575    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2576    ret= RFAILED;
2577
2578    while(true)
2579    {
2580       DU_LOG("\nINFO   -->  F1AP : Building DU config update\n");
2581       /* Allocate the memory for F1DuCfg */
2582       DU_ALLOC(f1apDuCfg, sizeof(F1AP_PDU_t));
2583       if(f1apDuCfg == NULLP)
2584       {
2585          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2586          break;
2587       }
2588
2589       f1apDuCfg->present = F1AP_PDU_PR_initiatingMessage;
2590       DU_ALLOC(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2591       if(f1apDuCfg->choice.initiatingMessage == NULLP)
2592       {
2593          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2594          break;
2595       }
2596
2597       f1apDuCfg->choice.initiatingMessage->procedureCode = \
2598                                                            ProcedureCode_id_gNBDUConfigurationUpdate;
2599       f1apDuCfg->choice.initiatingMessage->criticality = Criticality_reject;
2600       f1apDuCfg->choice.initiatingMessage->value.present = \
2601                                                            InitiatingMessage__value_PR_GNBDUConfigurationUpdate;
2602       duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\
2603                     choice.GNBDUConfigurationUpdate;
2604       elementCnt = 3;
2605       duCfgUpdate->protocolIEs.list.count = elementCnt;
2606       duCfgUpdate->protocolIEs.list.size = \
2607                                            elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t*);
2608
2609       /* Initialize the F1Setup members */
2610       DU_ALLOC(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2611       if(duCfgUpdate->protocolIEs.list.array == NULLP)
2612       {
2613          DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2614          break;
2615       }
2616       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
2617       {
2618          DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx],sizeof(GNBDUConfigurationUpdateIEs_t));
2619          if(duCfgUpdate->protocolIEs.list.array[ieIdx] == NULLP)
2620          {
2621             DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2622             memAlloctionFailure = true;
2623             break;
2624          }
2625       }
2626
2627       if(memAlloctionFailure == true)
2628       {
2629          break;
2630       }
2631       /*TransactionID*/
2632       ieIdx = 0;
2633       duCfgUpdate->protocolIEs.list.array[ieIdx]->id=ProtocolIE_ID_id_TransactionID;
2634       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
2635       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2636       GNBDUConfigurationUpdateIEs__value_PR_TransactionID;
2637       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = TRANS_ID;
2638
2639       ieIdx++;
2640       if(servCellAction == SERV_CELL_TO_MODIFY)
2641       {
2642          /*Served Cell to Modify */
2643          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2644          ProtocolIE_ID_id_Served_Cells_To_Modify_List;
2645          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2646          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2647          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Modify_List;
2648          if(buildServCellToModList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2649                   Served_Cells_To_Modify_List))
2650          {
2651             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToModList");
2652             break;
2653          }
2654       }
2655       else
2656       {
2657          /*Served Cell to Delete */
2658          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2659          ProtocolIE_ID_id_Served_Cells_To_Delete_List;
2660          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2661          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2662          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Delete_List;
2663          if(buildServCellToDeleteList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2664          Served_Cells_To_Delete_List)!=ROK)
2665          {
2666             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToDeleteList");
2667             break;
2668          }
2669
2670       }
2671       // NOTE :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
2672       /*GNB DU ID */
2673       ieIdx++;
2674       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
2675       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
2676       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2677       GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID;
2678       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size = sizeof(uint8_t);
2679       DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2680             duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2681       if(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == NULLP)
2682       {
2683          DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): Memory allocation failed for GNB_DU_ID");
2684          break;
2685       }
2686       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] = duCfgParam.duId;
2687
2688       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
2689
2690       /* Encode the DU Config Update type as APER */
2691       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
2692       encBufSize = 0;
2693       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
2694
2695       /* Checking encode results */
2696       if(encRetVal.encoded == ENCODE_FAIL)
2697       {
2698          DU_LOG("ERROR  -->  F1AP : Could not encode DUConfigUpdate structure (at %s)\n",\
2699                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2700          break;
2701       }
2702       else
2703       {
2704          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DUConfigUpdate\n");
2705          for(ieIdx =0; ieIdx < encBufSize; ieIdx++)
2706          {
2707             printf("%x",encBuf[ieIdx]);
2708          }
2709       }
2710       /* Sending msg */
2711       if(sendF1APMsg() != ROK)
2712       {
2713          DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update failed");
2714          break;
2715       }
2716
2717       ret = ROK;
2718       break;
2719    }
2720
2721    addToReservedF1apPduList(TRANS_ID,f1apDuCfg);
2722    return ret;
2723 }
2724
2725
2726 /*******************************************************************
2727  *
2728  * @brief free the ULRRCMessageTransfer
2729  *
2730  * @details
2731  *
2732  *    Function : FreeULRRCMessageTransfer
2733  *
2734  *    Functionality: Deallocating the memory of variable allocated in
2735  *                      FreeULRRCMessageTransfer
2736  *
2737  * @params[in]
2738  *
2739  * @return ROK     - void
2740  *
2741  ******************************************************************/
2742 void FreeULRRCMessageTransfer( F1AP_PDU_t *f1apMsg)
2743 {
2744    uint8_t idx1;
2745    ULRRCMessageTransfer_t  *ulRRCMsg;
2746
2747    if(f1apMsg != NULLP)
2748    {
2749       if(f1apMsg->choice.initiatingMessage != NULLP)
2750       {
2751          ulRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2752          if(ulRRCMsg->protocolIEs.list.array != NULLP)
2753          {
2754             for(idx1=0;idx1<ulRRCMsg->protocolIEs.list.count;idx1++)
2755             {
2756                if(ulRRCMsg->protocolIEs.list.array[idx1] != NULLP)
2757                {
2758                   if(ulRRCMsg->protocolIEs.list.array[idx1]->value.present ==
2759                         ULRRCMessageTransferIEs__value_PR_RRCContainer)
2760                   {
2761                      DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2762                            ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2763                   }
2764                   DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1],sizeof(ULRRCMessageTransferIEs_t));
2765                }
2766             }
2767             DU_FREE(ulRRCMsg->protocolIEs.list.array,ulRRCMsg->protocolIEs.list.size );
2768          }
2769          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2770       }
2771       DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
2772    }
2773 }
2774 /*******************************************************************
2775  *
2776  * @brief Builds and sends the ULRRCMessageTransfer
2777  *
2778  * @details
2779  *
2780  *    Function : BuildAndSendULRRCMessageTransfer
2781  *
2782  *    Functionality: Constructs the UL RRC Message Transfer and sends
2783  *                   it to the CU through SCTP.
2784  *
2785  * @params[in]
2786  *
2787  * @return ROK     - success
2788  *         RFAILED - failure
2789  *
2790  * ****************************************************************/
2791 uint8_t BuildAndSendULRRCMessageTransfer(DuUeCb  ueCb, uint8_t lcId, \
2792       uint16_t msgLen, uint8_t *rrcMsg)
2793 {
2794    uint8_t   elementCnt =0;
2795    uint8_t   idx1 =0;
2796    uint8_t   idx =0;
2797    F1AP_PDU_t                   *f1apMsg = NULLP;
2798    ULRRCMessageTransfer_t       *ulRRCMsg = NULLP;
2799    asn_enc_rval_t               encRetVal;        /* Encoder return value */
2800    uint8_t ret =RFAILED;
2801
2802    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2803
2804    while(true)
2805    {
2806       DU_LOG("\n INFO   -->  F1AP : Building UL RRC Message Transfer Message\n");
2807
2808       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
2809       if(f1apMsg == NULLP)
2810       {
2811          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2812          break;
2813       }
2814       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
2815       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2816       if(f1apMsg->choice.initiatingMessage == NULLP)
2817       {
2818          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
2819          break;
2820       }
2821       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_ULRRCMessageTransfer;
2822       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
2823       f1apMsg->choice.initiatingMessage->value.present = \
2824                                                          InitiatingMessage__value_PR_ULRRCMessageTransfer;
2825       ulRRCMsg =
2826          &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2827       elementCnt = 4;
2828       ulRRCMsg->protocolIEs.list.count = elementCnt;
2829       ulRRCMsg->protocolIEs.list.size = \
2830                                         elementCnt * sizeof(ULRRCMessageTransferIEs_t *);
2831
2832       /* Initialize the F1Setup members */
2833       DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size);
2834       if(ulRRCMsg->protocolIEs.list.array == NULLP)
2835       {
2836          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
2837          break;
2838       }
2839       for(idx=0; idx<elementCnt; idx++)
2840       {
2841          DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t));
2842          if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP)
2843          {
2844             break;
2845          }
2846       }
2847
2848       idx1 = 0;
2849
2850       /*GNB CU UE F1AP ID*/
2851       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
2852       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2853       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2854                                                               ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
2855       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = ueCb.gnbCuUeF1apId;
2856
2857       /*GNB DU UE F1AP ID*/
2858       idx1++;
2859       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
2860       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2861       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2862                                                               ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
2863       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = ueCb.gnbDuUeF1apId;
2864
2865       /*SRBID*/
2866       idx1++;
2867       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
2868       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2869       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2870                                                               ULRRCMessageTransferIEs__value_PR_SRBID;
2871       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = lcId;
2872
2873       /*RRCContainer*/
2874       idx1++;
2875       ulRRCMsg->protocolIEs.list.array[idx1]->id  = ProtocolIE_ID_id_RRCContainer;
2876       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2877       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2878                                                               ULRRCMessageTransferIEs__value_PR_RRCContainer;
2879       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size = msgLen;
2880       DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2881             ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
2882       if(!ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
2883       {
2884          DU_LOG(" ERROR  -->  F1AP : Memory allocation for BuildAndSendULRRCMessageTransfer failed");
2885          break;
2886       }
2887       memset(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, 0, msgLen);
2888       memcpy(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, \
2889             rrcMsg, ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2890
2891       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2892
2893       /* Encode the F1SetupRequest type as APER */
2894       memset(encBuf, 0, ENC_BUF_MAX_LEN);
2895       encBufSize = 0;
2896       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
2897             encBuf);
2898       /* Encode results */
2899       if(encRetVal.encoded == ENCODE_FAIL)
2900       {
2901          DU_LOG( "\nERROR  -->  F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
2902                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2903          break;
2904       }
2905       else
2906       {
2907          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
2908          for(int i=0; i< encBufSize; i++)
2909          {
2910             printf("%x",encBuf[i]);
2911          }
2912       }
2913
2914       /* Sending  msg  */
2915       if(sendF1APMsg()  !=      ROK)
2916       {
2917          DU_LOG("\nERROR  -->   F1AP : Sending  UL RRC Message Transfer Failed");
2918          break;
2919       }
2920       ret = ROK;
2921       break;
2922    }
2923    FreeULRRCMessageTransfer(f1apMsg);
2924
2925    return ret;
2926 }/* End of BuildAndSendULRRCMessageTransfer*/
2927
2928 /*******************************************************************
2929  *
2930  * @brief Builds tag config
2931  *
2932  * @details
2933  *
2934  *    Function : BuildTagConfig
2935  *
2936  *    Functionality: Builds tag config in MacCellGroupConfig
2937  *
2938  * @params[in] TAG_Config *tag_Config
2939  *
2940  * @return ROK     - success
2941  *         RFAILED - failure
2942  *
2943  * ****************************************************************/
2944 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
2945 {
2946    struct TAG_Config__tag_ToAddModList *tagList;
2947    uint8_t                     idx, elementCnt;
2948
2949    tagConfig->tag_ToReleaseList = NULLP;
2950    tagConfig->tag_ToAddModList = NULLP;
2951    DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
2952    if(!tagConfig->tag_ToAddModList)
2953    {
2954       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2955       return RFAILED;
2956    }
2957
2958    elementCnt = 1; //ODU_VALUE_ONE;
2959    tagList = tagConfig->tag_ToAddModList;
2960    tagList->list.count = elementCnt;
2961    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
2962
2963    tagList->list.array = NULLP;
2964    DU_ALLOC(tagList->list.array, tagList->list.size);
2965    if(!tagList->list.array)
2966    {
2967       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2968       return RFAILED;
2969    }
2970
2971    for(idx=0; idx<tagList->list.count; idx++)
2972    {
2973       tagList->list.array[idx] = NULLP;
2974       DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
2975       if(!tagList->list.array[idx])
2976       {
2977          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2978          return RFAILED;
2979       }
2980    }
2981
2982    idx = 0;
2983    tagList->list.array[idx]->tag_Id = TAG_ID;
2984    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
2985
2986    return ROK;
2987 }
2988
2989 /*******************************************************************
2990  *
2991  * @brief Builds PHR Config
2992  *
2993  * @details
2994  *
2995  *    Function : BuildPhrConfig
2996  *
2997  *    Functionality: Builds phrConfig in MacCellGroupConfig
2998  *
2999  * @params[in] PHR Config *
3000  *
3001  * @return ROK     - success
3002  *         RFAILED - failure
3003  *
3004  * ****************************************************************/
3005 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
3006 {
3007
3008    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
3009    phrConfig->choice.setup = NULLP;
3010    DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
3011    if(!phrConfig->choice.setup)
3012    {
3013       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
3014       return RFAILED;
3015    }
3016
3017    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
3018    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
3019    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
3020    phrConfig->choice.setup->multiplePHR              = false;
3021    phrConfig->choice.setup->dummy                    = false;
3022    phrConfig->choice.setup->phr_Type2OtherCell       = false;
3023    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
3024
3025    return ROK;
3026 }
3027
3028 /*******************************************************************
3029  *
3030  * @brief Builds BSR Config
3031  *
3032  * @details
3033  *
3034  *    Function : BuildBsrConfig
3035  *
3036  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
3037  *
3038  * @params[in] BSR_Config *bsrConfig
3039  *
3040  * @return ROK     - success
3041  *         RFAILED - failure
3042  *
3043  * ****************************************************************/
3044 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
3045 {
3046    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
3047    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
3048    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
3049
3050    return ROK;
3051 }
3052
3053 /*******************************************************************
3054  *
3055  * @brief Builds scheduling request config
3056  *
3057  * @details
3058  *
3059  *    Function : BuildSchedulingReqConfig
3060  *
3061  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
3062  *
3063  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
3064  *
3065  * @return ROK     - success
3066  *         RFAILED - failure
3067  *
3068  * ****************************************************************/
3069 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
3070 {
3071    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
3072    uint8_t                     idx, elementCnt;
3073
3074    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
3075    DU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
3076          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
3077    if(!schedulingRequestConfig->schedulingRequestToAddModList)
3078    {
3079       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3080       return RFAILED;
3081    }
3082
3083    elementCnt = 1; //ODU_VALUE_ONE;
3084    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
3085    schReqList->list.count = elementCnt;
3086    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
3087
3088    schReqList->list.array = NULLP;
3089    DU_ALLOC(schReqList->list.array, schReqList->list.size);
3090    if(!schReqList->list.array)
3091    {
3092       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3093       return RFAILED;
3094    }
3095
3096    for(idx=0;idx<schReqList->list.count; idx++)
3097    {
3098       schReqList->list.array[idx] = NULLP;
3099       DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
3100       if(!schReqList->list.array[idx])
3101       {
3102          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3103          return RFAILED;
3104       }
3105    }
3106
3107    idx = 0;
3108    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
3109
3110    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
3111    DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
3112    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
3113    {
3114       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3115       return RFAILED;
3116    }
3117    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
3118    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
3119    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
3120
3121    return ROK;
3122 }
3123
3124 /*******************************************************************
3125  *
3126  * @brief Builds RLC Config
3127  *
3128  * @details
3129  *
3130  *    Function : BuildRlcConfig
3131  *
3132  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
3133  *
3134  * @params[in] RLC_Config *rlcConfig
3135  *
3136  * @return ROK     - success
3137  *         RFAILED - failure
3138  *
3139  * ****************************************************************/
3140 uint8_t BuildRlcConfig(struct RLC_Config *rlcConfig)
3141 {
3142
3143    rlcConfig->present = RLC_Config_PR_am;
3144
3145    rlcConfig->choice.am = NULLP;
3146    DU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
3147    if(!rlcConfig->choice.am)
3148    {
3149       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3150       return RFAILED;
3151    }
3152
3153    /* UL */
3154    rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
3155    DU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3156    if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
3157    {
3158       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3159       return RFAILED;
3160    }
3161    *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3162    rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
3163    rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
3164    rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
3165    rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
3166
3167    /* DL */
3168    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
3169    DU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3170    if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
3171    {
3172       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3173       return RFAILED;
3174    }
3175    *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3176    rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
3177    rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
3178
3179    return ROK;
3180 }
3181
3182 /*******************************************************************
3183  *
3184  * @brief Builds MAC LC Config
3185  *
3186  * @details
3187  *
3188  *    Function : BuildMacLCConfig
3189  *
3190  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
3191  *
3192  * @params[in] struct LogicalChannelConfig macLcConfig
3193  *
3194  * @return ROK     - success
3195  *         RFAILED - failure
3196  *
3197  * ****************************************************************/
3198 uint8_t BuildMacLCConfig(struct LogicalChannelConfig *macLcConfig)
3199 {
3200
3201    macLcConfig->ul_SpecificParameters = NULLP;
3202    DU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
3203    if(!macLcConfig->ul_SpecificParameters)
3204    {
3205       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3206       return RFAILED;
3207    }
3208
3209    macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
3210    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     PRIORTISIED_BIT_RATE;
3211    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     BUCKET_SIZE_DURATION;
3212    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
3213    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
3214    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
3215    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
3216
3217    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
3218    DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
3219    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
3220    {
3221       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3222       return RFAILED;
3223    }
3224    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
3225
3226    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
3227    DU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
3228    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
3229    {
3230       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3231       return RFAILED;
3232    }
3233    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
3234
3235    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
3236    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
3237    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
3238
3239    return ROK;
3240 }
3241
3242 /*******************************************************************
3243  *
3244  * @brief Builds RLC Bearer to Add/Mod list
3245  *
3246  * @details
3247  *
3248  *    Function :BuildRlcBearerToAddModList
3249  *
3250  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
3251  *
3252  * @params[in] rlc_BearerToAddModList
3253  *
3254  * @return ROK     - success
3255  *         RFAILED - failure
3256  *
3257  * ****************************************************************/
3258 uint8_t BuildRlcBearerToAddModList(struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
3259 {
3260    uint8_t                     idx, elementCnt;
3261
3262    elementCnt = 1;
3263    rlcBearerList->list.count = elementCnt;
3264    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
3265
3266    rlcBearerList->list.array = NULLP;
3267    DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
3268    if(!rlcBearerList->list.array)
3269    {
3270       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3271       return RFAILED;
3272    }
3273
3274    for(idx=0; idx<rlcBearerList->list.count; idx++)
3275    {
3276       rlcBearerList->list.array[idx] = NULLP;
3277       DU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
3278       if(!rlcBearerList->list.array[idx])
3279       {
3280          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3281          return RFAILED;
3282       }
3283    }
3284
3285    idx = 0;
3286    rlcBearerList->list.array[idx]->logicalChannelIdentity = SRB1_LCID;
3287
3288    DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, \
3289       sizeof(struct RLC_BearerConfig__servedRadioBearer));
3290    if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3291    {
3292       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3293       return RFAILED;
3294    }
3295
3296    rlcBearerList->list.array[idx]->servedRadioBearer->present = \
3297       RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
3298    rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = \
3299       SRB1_LCID;
3300
3301    rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3302    rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3303    DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3304    if(!rlcBearerList->list.array[idx]->rlc_Config)
3305    {
3306       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3307       return RFAILED;
3308    }
3309
3310    if(BuildRlcConfig(rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3311    {
3312       DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3313       return RFAILED;
3314    }
3315
3316    rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3317    DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, \
3318       sizeof(struct LogicalChannelConfig));
3319    if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3320    {
3321       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3322       return RFAILED;
3323    }
3324
3325    if(BuildMacLCConfig(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3326    {
3327       DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3328       return RFAILED;
3329    }
3330
3331    return ROK;
3332 }
3333
3334 /*******************************************************************
3335  *
3336  * @brief Build Control resource set to add/modify list
3337  *
3338  * @details
3339  *
3340  *    Function : BuildControlRSetToAddModList
3341  *
3342  *    Functionality: Build Control resource set to add/modify list
3343  *
3344  * @params[in]
3345  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3346  *
3347  * @return ROK     - success
3348  *         RFAILED - failure
3349  *
3350  * ****************************************************************/
3351    uint8_t BuildControlRSetToAddModList
3352 (
3353  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3354  )
3355 {
3356    uint8_t idx;
3357    uint8_t elementCnt;
3358    uint8_t numBytes, bitsUnused;
3359    struct ControlResourceSet *controlRSet;
3360    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3361    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3362
3363
3364    elementCnt = 1;
3365    controlRSetList->list.count = elementCnt;
3366    controlRSetList->list.size = \
3367                                 elementCnt * sizeof(struct ControlResourceSet *);
3368
3369    controlRSetList->list.array = NULLP;
3370    DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3371    if(!controlRSetList->list.array)
3372    {
3373       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3374       return RFAILED;
3375    }
3376
3377    for(idx = 0; idx < elementCnt; idx++)
3378    {
3379       controlRSetList->list.array[idx] = NULLP;
3380       DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3381       if(!controlRSetList->list.array[idx])
3382       {
3383          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3384          return RFAILED;
3385       }
3386    }
3387
3388    idx=0;
3389    controlRSet = controlRSetList->list.array[idx];
3390
3391    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3392
3393    /* size 6 bytes
3394     * 3 LSBs unsued
3395     * Bit string stored ff0000000000
3396     */
3397    numBytes = 6;
3398    bitsUnused = 3;
3399    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3400
3401    controlRSet->frequencyDomainResources.buf = NULLP;
3402    DU_ALLOC(controlRSet->frequencyDomainResources.buf, \
3403          controlRSet->frequencyDomainResources.size);
3404    if(!controlRSet->frequencyDomainResources.buf)
3405    {
3406       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3407       return RFAILED;
3408    }
3409
3410    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3411    coreset0EndPrb = CORESET0_END_PRB;
3412    coreset1StartPrb = coreset0EndPrb + 6;
3413    coreset1NumPrb = CORESET1_NUM_PRB;
3414    /* calculate the PRBs */
3415    fillCoresetFeqDomAllocMap(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3416    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3417    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3418
3419    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3420    controlRSet->cce_REG_MappingType.present = \
3421                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3422
3423    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3424    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3425    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3426    controlRSet->tci_PresentInDCI = NULLP;
3427 #if 0
3428    uint8_t tciStateIdx;
3429
3430    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3431          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3432    if(!controlRset->tci_StatesPDCCH_ToAddList)
3433    {
3434       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3435       return RFAILED;
3436    }
3437
3438    elementCnt = 1;
3439    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3440    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3441    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3442          controlRset->tci_StatesPDCCH_ToAddList->list.size)
3443       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3444       {
3445          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3446          return RFAILED;
3447       }
3448
3449    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3450    {
3451       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3452       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3453       {
3454          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3455          return RFAILED;
3456       }
3457    }
3458
3459    tciStateIdx = 0;
3460    /* TODO */
3461    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3462
3463    DU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3464    if(!controlRset->tci_PresentInDCI)
3465    {
3466       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3467       return RFAILED;
3468    }
3469    /* TODO */
3470    *(controlRset->tci_PresentInDCI);
3471 #endif
3472
3473    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3474    DU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3475    if(!controlRSet->pdcch_DMRS_ScramblingID)
3476    {
3477       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3478       return RFAILED;
3479    }
3480    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3481
3482    return ROK;
3483 } /* End BuildControlRSetToAddModList */
3484
3485 /*******************************************************************
3486  *
3487  * @brief Build search space to add/modify list
3488  *
3489  * @details
3490  *
3491  *    Function : BuildSearchSpcToAddModList
3492  *
3493  *    Functionality: Build search space to add/modify list
3494  *
3495  * @params[in]
3496  * @return ROK     - success
3497  *         RFAILED - failure
3498  *
3499  * ****************************************************************/
3500    uint8_t BuildSearchSpcToAddModList
3501 (
3502  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
3503  )
3504 {
3505    uint8_t idx;
3506    uint8_t numBytes;
3507    uint8_t byteIdx;
3508    uint8_t bitsUnused;
3509    uint8_t elementCnt;
3510    struct SearchSpace *searchSpc;
3511
3512    elementCnt = 1;
3513    searchSpcList->list.count = elementCnt;
3514    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3515
3516    searchSpcList->list.array = NULLP;
3517    DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3518    if(!searchSpcList->list.array)
3519    {
3520       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3521       return RFAILED;
3522    }
3523
3524    for(idx = 0; idx < elementCnt; idx++)
3525    {
3526       searchSpcList->list.array[idx] = NULLP;
3527       DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3528       if(!searchSpcList->list.array[idx])
3529       {
3530          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3531          return RFAILED;
3532       }
3533    }
3534
3535    idx = 0;
3536    searchSpc = searchSpcList->list.array[idx];
3537
3538    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3539
3540    searchSpc->controlResourceSetId = NULLP;
3541    DU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3542    if(!searchSpc->controlResourceSetId)
3543    {
3544       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3545       return RFAILED;
3546    }
3547    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3548
3549    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3550    DU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
3551          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3552    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3553    {
3554       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3555       return RFAILED;
3556    }
3557    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
3558                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3559
3560    searchSpc->duration = NULLP;
3561    searchSpc->monitoringSymbolsWithinSlot = NULLP;
3562    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3563    if(!searchSpc->monitoringSymbolsWithinSlot)
3564    {
3565       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3566       return RFAILED;
3567    }
3568
3569    /* Values taken from reference logs :
3570     * size 2 bytes
3571     * 2 LSBs unsued
3572     * Bit string stores 8000
3573     */
3574    numBytes = 2;
3575    bitsUnused = 2;
3576
3577    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3578    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3579    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
3580          searchSpc->monitoringSymbolsWithinSlot->size);
3581    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3582    {
3583       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3584       return RFAILED;
3585    }
3586
3587    byteIdx = 0;
3588    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
3589                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3590    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3591    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3592
3593    searchSpc->nrofCandidates = NULLP;
3594    DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3595    if(!searchSpc->nrofCandidates)
3596    {
3597       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3598       return RFAILED;
3599    }
3600
3601    searchSpc->nrofCandidates->aggregationLevel1 = \
3602                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3603    searchSpc->nrofCandidates->aggregationLevel2 = \
3604                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3605    searchSpc->nrofCandidates->aggregationLevel4 = \
3606                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3607    searchSpc->nrofCandidates->aggregationLevel8 = \
3608                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3609    searchSpc->nrofCandidates->aggregationLevel16 = \
3610                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3611
3612    searchSpc->searchSpaceType = NULLP;
3613    DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3614    if(!searchSpc->searchSpaceType)
3615    {
3616       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3617       return RFAILED;
3618    }
3619
3620    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3621
3622    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3623    DU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
3624          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3625    if(!searchSpc->searchSpaceType->choice.ue_Specific)
3626    {
3627       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3628       return RFAILED;
3629    }
3630    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
3631                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3632
3633    return ROK;
3634 }/* End BuildSearchSpcToAddModList */
3635
3636 /*******************************************************************
3637  *
3638  * @brief Builds BWP DL dedicated PDCCH config
3639  *
3640  * @details
3641  *
3642  *    Function : BuildBWPDlDedPdcchCfg
3643  *
3644  *    Functionality: Builds BWP DL dedicated PDCCH config
3645  *
3646  * @params[in] struct PDCCH_Config *pdcchCfg
3647  *
3648  * @return ROK     - success
3649  *         RFAILED - failure
3650  *
3651  * ****************************************************************/
3652 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
3653 {
3654    pdcchCfg->controlResourceSetToAddModList = NULLP;
3655    DU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
3656          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3657    if(!pdcchCfg->controlResourceSetToAddModList)
3658    {
3659       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3660       return RFAILED;
3661    }
3662
3663    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
3664    {
3665       return RFAILED;
3666    }
3667
3668    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3669
3670    pdcchCfg->searchSpacesToAddModList = NULLP;
3671    DU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3672          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3673    if(!pdcchCfg->searchSpacesToAddModList)
3674    {
3675       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3676       return RFAILED;
3677    }
3678
3679    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3680    {
3681       return RFAILED;
3682    }
3683
3684    pdcchCfg->searchSpacesToReleaseList = NULLP;
3685    pdcchCfg->downlinkPreemption = NULLP;
3686    pdcchCfg->tpc_PUSCH = NULLP;
3687    pdcchCfg->tpc_PUCCH = NULLP;
3688    pdcchCfg->tpc_SRS = NULLP;
3689
3690    return ROK;
3691 }
3692
3693 /*******************************************************************
3694  *
3695  * @brief Builds DMRS DL PDSCH Mapping type A
3696  *
3697  * @details
3698  *
3699  *    Function : BuildDMRSDLPdschMapTypeA
3700  *
3701  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3702  *
3703  * @params[in]
3704  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3705  * @return ROK     - success
3706  *         RFAILED - failure
3707  *
3708  * ****************************************************************/
3709    uint8_t BuildDMRSDLPdschMapTypeA
3710 (
3711  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3712  )
3713 {
3714    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3715    dmrsDlCfg->choice.setup = NULLP;
3716    DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3717    if(!dmrsDlCfg->choice.setup)
3718    {
3719       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3720       return RFAILED;
3721    }
3722
3723    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3724    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3725    DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3726    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3727    {
3728       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3729       return RFAILED;
3730    }
3731    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3732
3733    dmrsDlCfg->choice.setup->maxLength = NULLP;
3734    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3735    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3736    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3737
3738    return ROK;
3739 }
3740
3741 /*******************************************************************
3742  *
3743  * @brief Builds TCI states to add/modify list
3744  *
3745  * @details
3746  *
3747  *    Function : BuildTCIStatesToAddModList
3748  *
3749  *    Functionality:Builds TCI states to add/modify list
3750  *
3751  * @params[in]
3752  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3753  *
3754  * @return ROK     - success
3755  *         RFAILED - failure
3756  *
3757  * ****************************************************************/
3758 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3759 {
3760    return ROK;
3761 }
3762
3763 /*******************************************************************
3764  *
3765  * @brief Builds PDSCH time domain allocation list
3766  *
3767  * @details
3768  *
3769  *    Function : BuildPdschTimeDomAllocList
3770  *
3771  *    Functionality: Builds PDSCH time domain allocation list
3772  *
3773  * @params[in]
3774  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3775  *
3776  * @return ROK     - success
3777  *         RFAILED - failure
3778  *
3779  * ****************************************************************/
3780    uint8_t BuildPdschTimeDomAllocList
3781 (
3782  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3783  )
3784 {
3785    uint8_t idx;
3786    uint8_t elementCnt;
3787    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3788
3789    timeDomAllocList->present = \
3790                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3791
3792    timeDomAllocList->choice.setup = NULLP;
3793    DU_ALLOC(timeDomAllocList->choice.setup, \
3794          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3795    if(!timeDomAllocList->choice.setup)
3796    {
3797       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3798       return RFAILED;
3799    }
3800
3801    elementCnt = 2;
3802    timeDomAllocList->choice.setup->list.count = elementCnt;
3803    timeDomAllocList->choice.setup->list.size = \
3804                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3805
3806    timeDomAllocList->choice.setup->list.array = NULLP;
3807    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3808          timeDomAllocList->choice.setup->list.size);
3809    if(!timeDomAllocList->choice.setup->list.array)
3810    {
3811       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3812       return RFAILED;
3813    }
3814
3815    for(idx = 0; idx < elementCnt; idx++)
3816    {
3817       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3818       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3819             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3820       if(!timeDomAllocList->choice.setup->list.array[idx])
3821       {
3822          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3823          return RFAILED;
3824       }
3825    }
3826
3827    idx = 0;
3828    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3829    DU_ALLOC(timeDomAlloc->k0, sizeof(long));
3830    if(!timeDomAlloc->k0)
3831    {
3832       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3833       return RFAILED;
3834    }
3835    *(timeDomAlloc->k0) = 0;
3836    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3837    timeDomAlloc->startSymbolAndLength = \
3838                                         calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
3839
3840    idx++;
3841    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3842    DU_ALLOC(timeDomAlloc->k0, sizeof(long));
3843    if(!timeDomAlloc->k0)
3844    {
3845       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3846       return RFAILED;
3847    }
3848    *(timeDomAlloc->k0) = 1;
3849    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3850    timeDomAlloc->startSymbolAndLength = calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
3851
3852    return ROK;
3853 }
3854
3855 /*******************************************************************
3856  *
3857  * @brief Builds PDSCH PRB Bundling type
3858  *
3859  * @details
3860  *
3861  *    Function : BuildPdschPrbBundlingType
3862  *
3863  *    Functionality: Builds PDSCH PRB Bundling type
3864  *
3865  * @params[in]
3866  * struct PDSCH_Config__prb_BundlingType *prbBndlType
3867  *
3868  * @return ROK     - success
3869  *         RFAILED - failure
3870  *
3871  * ****************************************************************/
3872    uint8_t BuildPdschPrbBundlingType
3873 (
3874  struct PDSCH_Config__prb_BundlingType *prbBndlType
3875  )
3876 {
3877    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
3878
3879    prbBndlType->choice.staticBundling = NULLP;
3880    DU_ALLOC(prbBndlType->choice.staticBundling, \
3881          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
3882    if(!prbBndlType->choice.staticBundling)
3883    {
3884       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
3885       return RFAILED;
3886    }
3887    prbBndlType->choice.staticBundling->bundleSize = NULLP;
3888
3889    return ROK;
3890 }
3891
3892 /*******************************************************************
3893  *
3894  * @brief Builds BWP DL dedicated PDSCH config
3895  *
3896  * @details
3897  *
3898  *    Function : BuildBWPDlDedPdschCfg
3899  *
3900  *    Functionality: Builds BWP DL dedicated PDSCH config
3901  *
3902  * @params[in] struct PDSCH_Config *pdschCfg
3903  *
3904  * @return ROK     - success
3905  *         RFAILED - failure
3906  *
3907  * ****************************************************************/
3908 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
3909 {
3910    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
3911
3912    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
3913    DU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
3914          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
3915    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
3916    {
3917       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3918       return RFAILED;
3919    }
3920
3921    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
3922    {
3923       return RFAILED;
3924    }
3925
3926    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
3927    pdschCfg->tci_StatesToAddModList = NULLP;
3928    pdschCfg->tci_StatesToReleaseList = NULLP;
3929    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
3930 #if 0
3931    DU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
3932    if(!pdschCfg->tci_StatesToAddModList)
3933    {
3934       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3935       return RFAILED;
3936    }
3937    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
3938    {
3939       return RFAILED;
3940    }
3941 #endif
3942
3943    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
3944
3945    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
3946    DU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
3947          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
3948    if(!pdschCfg->pdsch_TimeDomainAllocationList)
3949    {
3950       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3951       return RFAILED;
3952    }
3953
3954    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
3955    {
3956       return RFAILED;
3957    }
3958
3959    pdschCfg->pdsch_AggregationFactor = NULLP;
3960    pdschCfg->rateMatchPatternToAddModList = NULLP;
3961    pdschCfg->rateMatchPatternToReleaseList = NULLP;
3962    pdschCfg->rateMatchPatternGroup1 = NULLP;
3963    pdschCfg->rateMatchPatternGroup2 = NULLP;
3964    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
3965    pdschCfg->mcs_Table = NULLP;
3966
3967    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
3968    DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
3969    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
3970    {
3971       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3972       return RFAILED;
3973    }
3974    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
3975
3976    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
3977    {
3978       return RFAILED;
3979    }
3980
3981    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
3982    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
3983    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3984    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3985    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3986    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3987    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
3988
3989    return ROK;
3990 }
3991
3992 /*******************************************************************
3993  *
3994  * @brief Builds intitial DL BWP
3995  * @details
3996  *
3997  *    Function : BuildInitialDlBWP
3998  *
3999  *    Functionality: Builds intitial DL BWP in spCellCfgDed
4000  *
4001  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4002  *
4003  * @return ROK     - success
4004  *         RFAILED - failure
4005  *
4006  * ****************************************************************/
4007 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
4008 {
4009    dlBwp->pdcch_Config = NULLP;
4010    DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
4011    if(!dlBwp->pdcch_Config)
4012    {
4013       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4014       return RFAILED;
4015    }
4016    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
4017
4018    dlBwp->pdcch_Config->choice.setup = NULLP;
4019    DU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
4020    if(!dlBwp->pdcch_Config->choice.setup)
4021    {
4022       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4023       return RFAILED;
4024    }
4025    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
4026    {
4027       return RFAILED;
4028    }
4029
4030    dlBwp->pdsch_Config = NULLP;
4031    DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
4032    if(!dlBwp->pdsch_Config)
4033    {
4034       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4035       return RFAILED;
4036    }
4037    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
4038
4039    dlBwp->pdsch_Config->choice.setup = NULLP;
4040    DU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
4041    if(!dlBwp->pdsch_Config->choice.setup)
4042    {
4043       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4044       return RFAILED;
4045    }
4046
4047    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
4048    {
4049       return RFAILED;
4050    }
4051
4052    dlBwp->sps_Config = NULLP;
4053    dlBwp->radioLinkMonitoringConfig = NULLP;
4054    return ROK;
4055 }
4056
4057 /*******************************************************************
4058  *
4059  * @brief Builds DMRS UL Pusch Mapping type A
4060  *
4061  * @details
4062  *
4063  *    Function : BuildDMRSULPuschMapTypeA
4064  *
4065  *    Functionality: Builds DMRS UL Pusch Mapping type A
4066  *
4067  * @params[in]
4068  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4069  * @return ROK     - success
4070  *         RFAILED - failure
4071  *
4072  * ****************************************************************/
4073    uint8_t BuildDMRSULPuschMapTypeA
4074 (
4075  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4076  )
4077 {
4078    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
4079    dmrsUlCfg->choice.setup= NULLP;
4080    DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
4081    if(!dmrsUlCfg->choice.setup)
4082    {
4083       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4084       return RFAILED;
4085    }
4086
4087    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
4088    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
4089    DU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
4090    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4091    {
4092       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4093       return RFAILED;
4094    }
4095    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
4096
4097    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
4098    dmrsUlCfg->choice.setup->maxLength = NULLP;
4099    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
4100    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
4101          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4102    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4103    {
4104       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4105       return RFAILED;
4106    }
4107
4108    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
4109    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4110          sizeof(long));
4111    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
4112    {
4113       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4114       return RFAILED;
4115    }
4116    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
4117
4118    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
4119    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
4120    return ROK;
4121 }
4122
4123 /*******************************************************************
4124  *
4125  * @brief Build PUSCH time domain allocation list
4126  *
4127  * @details
4128  *
4129  *    Function : BuildPuschTimeDomAllocList
4130  *
4131  *    Functionality: Build PUSCH time domain allocation list
4132  *
4133  * @params[in]
4134  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4135  *
4136  * @return ROK     - success
4137  *         RFAILED - failure
4138  *
4139  * ****************************************************************/
4140    uint8_t BuildPuschTimeDomAllocList
4141 (
4142  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4143  )
4144 {
4145    uint8_t idx;
4146    uint8_t elementCnt;
4147    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
4148
4149    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
4150    timeDomAllocList->choice.setup = NULLP;
4151    DU_ALLOC(timeDomAllocList->choice.setup, \
4152          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4153    if(!timeDomAllocList->choice.setup)
4154    {
4155       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4156       return RFAILED;
4157    }
4158
4159    elementCnt = 2;
4160    timeDomAllocList->choice.setup->list.count = elementCnt;
4161    timeDomAllocList->choice.setup->list.size = \
4162                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
4163    timeDomAllocList->choice.setup->list.array = NULLP;
4164    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
4165          timeDomAllocList->choice.setup->list.size);
4166    if(!timeDomAllocList->choice.setup->list.array)
4167    {
4168       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4169       return RFAILED;
4170    }
4171
4172    for(idx = 0; idx < elementCnt; idx++)
4173    {
4174       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4175       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
4176             sizeof(PUSCH_TimeDomainResourceAllocation_t));
4177       if(!timeDomAllocList->choice.setup->list.array[idx])
4178       {
4179          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4180          return RFAILED;
4181       }
4182    }
4183
4184    idx = 0;
4185    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4186    DU_ALLOC(timeDomAlloc->k2, sizeof(long));
4187    if(!timeDomAlloc->k2)
4188    {
4189       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4190       return RFAILED;
4191    }
4192    *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
4193    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4194    timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
4195
4196    idx++;
4197    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4198    DU_ALLOC(timeDomAlloc->k2, sizeof(long));
4199    if(!timeDomAlloc->k2)
4200    {
4201       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4202       return RFAILED;
4203    }
4204    *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
4205    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4206    timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
4207
4208    return ROK;
4209 }
4210
4211 /*******************************************************************
4212  *
4213  * @brief Builds BWP UL dedicated PUSCH Config
4214  *
4215  * @details
4216  *
4217  *    Function : BuildBWPUlDedPuschCfg
4218  *
4219  *    Functionality:
4220  *      Builds BWP UL dedicated PUSCH Config
4221  *
4222  * @params[in] : PUSCH_Config_t *puschCfg
4223  *
4224  * @return ROK     - success
4225  *         RFAILED - failure
4226  *
4227  * ****************************************************************/
4228 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
4229 {
4230    puschCfg->dataScramblingIdentityPUSCH = NULLP;
4231    DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4232    if(!puschCfg->dataScramblingIdentityPUSCH)
4233    {
4234       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4235       return RFAILED;
4236    }
4237    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
4238
4239    puschCfg->txConfig = NULLP;
4240    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4241    DU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4242          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4243    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4244    {
4245       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4246       return RFAILED;
4247    }
4248
4249    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4250    {
4251       return RFAILED;
4252    }
4253
4254    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4255    puschCfg->pusch_PowerControl = NULLP;
4256    puschCfg->frequencyHopping = NULLP;
4257    puschCfg->frequencyHoppingOffsetLists = NULLP;
4258    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4259
4260    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4261    DU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
4262          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4263    if(!puschCfg->pusch_TimeDomainAllocationList)
4264    {
4265       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4266       return RFAILED;
4267    }
4268
4269    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
4270    {
4271       return RFAILED;
4272    }
4273
4274    puschCfg->pusch_AggregationFactor = NULLP;
4275    puschCfg->mcs_Table = NULLP;
4276    puschCfg->mcs_TableTransformPrecoder = NULLP;
4277    puschCfg->transformPrecoder = NULLP;
4278    DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4279    if(!puschCfg->transformPrecoder)
4280    {
4281       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4282       return RFAILED;
4283    }
4284    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4285
4286    puschCfg->codebookSubset = NULLP;
4287    puschCfg->maxRank = NULLP;
4288    puschCfg->rbg_Size = NULLP;
4289    puschCfg->uci_OnPUSCH = NULLP;
4290    puschCfg->tp_pi2BPSK = NULLP;
4291
4292    return ROK;
4293 }
4294
4295 /*******************************************************************
4296  *
4297  * @brief Builds BWP UL dedicated PUCCH Config
4298  *
4299  * @details
4300  *
4301  *    Function : BuildBWPUlDedPucchCfg
4302  *
4303  *    Functionality:
4304  *      Builds BWP UL dedicated PUCCH Config
4305  *
4306  * @params[in] : PUCCH_Config_t *pucchCfg
4307  *
4308  * @return ROK     - success
4309  *         RFAILED - failure
4310  *
4311  * ****************************************************************/
4312 uint8_t BuildBWPUlDedPucchCfg(PUCCH_Config_t *pucchCfg)
4313 {
4314    uint8_t arrIdx, elementCnt;
4315
4316    DU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
4317    if(pucchCfg->dl_DataToUL_ACK == NULLP)
4318    {
4319       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4320       return RFAILED;
4321    }
4322
4323    elementCnt = 2;
4324    pucchCfg->dl_DataToUL_ACK->list.count = elementCnt;
4325    pucchCfg->dl_DataToUL_ACK->list.size = elementCnt * sizeof(long *);
4326    DU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
4327    if(pucchCfg->dl_DataToUL_ACK->list.array == NULLP)
4328    {
4329       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4330       return RFAILED;
4331    }
4332
4333    for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
4334    {
4335       DU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
4336       if(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx] == NULLP)
4337       {
4338           DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4339           return RFAILED;
4340       }
4341    }
4342
4343    arrIdx = 0;
4344    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx++]) = 1;
4345    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx]) = 2;
4346    return ROK;
4347 }
4348
4349 /*******************************************************************
4350  *
4351  * @brief Fills SRS resource to add/modify list
4352  *
4353  * @details
4354  *
4355  *    Function : BuildSrsRsrcAddModList
4356  *
4357  *    Functionality: Fills SRS resource to add/modify list
4358  *
4359  * @params[in]
4360  * @return ROK     - success
4361  *         RFAILED - failure
4362  *
4363  * ****************************************************************/
4364 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
4365 {
4366    uint8_t   elementCnt;
4367    uint8_t   rsrcIdx;
4368
4369    elementCnt = 1;
4370    resourceList->list.count = elementCnt;
4371    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
4372    resourceList->list.array = NULLP;
4373    DU_ALLOC(resourceList->list.array, resourceList->list.size);
4374    if(!resourceList->list.array)
4375    {
4376       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4377       return RFAILED;
4378    }
4379
4380    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4381    {
4382       DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4383       if(!resourceList->list.array[rsrcIdx])
4384       {
4385          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4386          return RFAILED;
4387       }
4388    }
4389
4390    rsrcIdx = 0;
4391    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
4392    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
4393    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
4394
4395    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
4396    DU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
4397          sizeof(struct SRS_Resource__transmissionComb__n2));
4398    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
4399    {
4400       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4401       return RFAILED;
4402    }
4403    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
4404       = SRS_COMB_OFFSET_N2;
4405    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
4406       = SRS_CYCLIC_SHIFT_N2;
4407
4408    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
4409                                                                       PUSCH_START_SYMBOL;
4410    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
4411                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
4412    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
4413                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
4414
4415    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
4416    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
4417    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
4418    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
4419    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
4420    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
4421                                                                SRS_Resource__groupOrSequenceHopping_neither;
4422
4423    /* Setting resource type to aperiodic for intergration purposes */
4424    resourceList->list.array[rsrcIdx]->resourceType.present = \
4425                                                              SRS_Resource__resourceType_PR_aperiodic;
4426    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
4427    DU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
4428          sizeof(struct SRS_Resource__resourceType__aperiodic));
4429    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
4430    {
4431       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4432       return RFAILED;
4433    }
4434    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
4435
4436    return ROK;
4437 }
4438
4439 /*******************************************************************
4440  *
4441  * @brief Build SRS resource set Add/mod list
4442  *
4443  * @details
4444  *
4445  *    Function : BuildSrsRsrcSetAddModList
4446  *
4447  *    Functionality: Build SRS resource set Add/mod list
4448  *
4449  * @params[in]
4450  * @return ROK     - success
4451  *         RFAILED - failure
4452  *
4453  * ****************************************************************/
4454    uint8_t BuildSrsRsrcSetAddModList
4455 (
4456  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
4457  )
4458 {
4459    uint8_t  elementCnt;
4460    uint8_t  rSetIdx;
4461    uint8_t  rsrcIdx;
4462    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
4463
4464    elementCnt = 1;
4465    rsrcSetList->list.count = elementCnt;
4466    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
4467    rsrcSetList->list.array = NULLP;
4468    DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
4469    if(!rsrcSetList->list.array)
4470    {
4471       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4472       return RFAILED;
4473    }
4474
4475    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4476    {
4477       DU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4478       if(!rsrcSetList->list.array[rSetIdx])
4479       {
4480          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4481          return RFAILED;
4482       }
4483    }
4484
4485    rSetIdx = 0;
4486    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
4487
4488    /* Fill Resource Id list in resource set */
4489    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
4490    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4491          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4492    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4493    {
4494       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4495       return RFAILED;
4496    }
4497
4498    elementCnt = 1;
4499    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4500    rsrcIdList->list.count = elementCnt;
4501    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
4502    rsrcIdList->list.array = NULLP;
4503    DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
4504    if(!rsrcIdList->list.array)
4505    {
4506       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4507       return RFAILED;
4508    }
4509
4510    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4511    {
4512       DU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4513       if(!rsrcIdList->list.array[rsrcIdx])
4514       {
4515          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4516          return RFAILED;
4517       }
4518    }
4519
4520    rsrcIdx = 0;
4521    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
4522
4523    /* Fill resource type */
4524    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
4525                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
4526
4527    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
4528    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4529          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4530    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
4531    {
4532       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4533       return RFAILED;
4534    }
4535    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
4536       = APERIODIC_SRS_RESRC_TRIGGER;
4537
4538    /* TODO : Fill values for below IEs as expected by Viavi */
4539    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
4540    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
4541
4542
4543    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
4544    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
4545    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
4546    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
4547    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
4548
4549    return ROK;
4550 }
4551
4552 /*******************************************************************
4553  *
4554  * @brief Builds BWP UL dedicated SRS Config
4555  *
4556  * @details
4557  *
4558  *    Function : BuildBWPUlDedSrsCfg
4559  *
4560  *    Functionality: Builds BWP UL dedicated SRS Config
4561  *
4562  * @params[in] SRS Config
4563  * @return ROK     - success
4564  *         RFAILED - failure
4565  *
4566  * ****************************************************************/
4567 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
4568 {
4569    srsCfg->srs_ResourceSetToReleaseList = NULLP;
4570    srsCfg->srs_ResourceSetToAddModList = NULLP;
4571    DU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
4572          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4573    if(!srsCfg->srs_ResourceSetToAddModList)
4574    {
4575       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4576       return RFAILED;
4577    }
4578    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
4579    {
4580       return RFAILED;
4581    }
4582
4583    srsCfg->srs_ResourceToReleaseList = NULLP;
4584
4585    /* Resource to Add/Modify list */
4586    srsCfg->srs_ResourceToAddModList = NULLP;
4587    DU_ALLOC(srsCfg->srs_ResourceToAddModList, \
4588          sizeof(struct SRS_Config__srs_ResourceToAddModList));
4589    if(!srsCfg->srs_ResourceToAddModList)
4590    {
4591       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4592       return RFAILED;
4593    }
4594
4595    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
4596    {
4597       return RFAILED;
4598    }
4599
4600    srsCfg->tpc_Accumulation = NULLP;
4601
4602    return ROK;
4603 }
4604
4605
4606
4607 /*******************************************************************
4608  *
4609  * @brief Builds Pusch Serving cell Config
4610  *
4611  * @details
4612  *
4613  *    Function : BuildPuschSrvCellCfg
4614  *
4615  *    Functionality: Builds Pusch Serving cell Config
4616  *
4617  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
4618  *
4619  * @return ROK     - success
4620  *         RFAILED - failure
4621  *
4622  * ****************************************************************/
4623 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
4624 {
4625    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
4626    puschCfg->choice.setup = NULLP;
4627    DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4628    if(!puschCfg->choice.setup)
4629    {
4630       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4631       return RFAILED;
4632    }
4633
4634    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4635    puschCfg->choice.setup->rateMatching = NULLP;
4636    puschCfg->choice.setup->xOverhead = NULLP;
4637    puschCfg->choice.setup->ext1 = NULLP;
4638    DU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
4639    if(!puschCfg->choice.setup->ext1)
4640    {
4641       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4642       return RFAILED;
4643    }
4644
4645    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
4646    DU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
4647    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
4648    {
4649       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4650       return RFAILED;
4651    }
4652    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
4653
4654    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
4655    DU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
4656    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
4657    {
4658       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4659       return RFAILED;
4660    }
4661    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
4662    return ROK;
4663 }
4664
4665 /*******************************************************************
4666  *
4667  * @brief Builds inital UL BWP
4668  *
4669  * @details
4670  *
4671  *    Function : BuildInitialUlBWP
4672  *
4673  *    Functionality: Builds initial UL BWP
4674  *
4675  * @params[in] BWP_UplinkDedicated_t *ulBwp
4676  * @return ROK     - success
4677  *         RFAILED - failure
4678  *
4679  * ****************************************************************/
4680 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4681 {
4682    ulBwp->pucch_Config = NULLP;
4683    DU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
4684    if(!ulBwp->pucch_Config)
4685    {
4686       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4687       return RFAILED;
4688    }
4689
4690    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
4691    ulBwp->pucch_Config->choice.setup = NULLP;
4692    DU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
4693    if(!ulBwp->pucch_Config->choice.setup)
4694    {
4695       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4696       return RFAILED;
4697    }
4698
4699    if(BuildBWPUlDedPucchCfg(ulBwp->pucch_Config->choice.setup) != ROK)
4700    {
4701       return RFAILED;
4702    }
4703
4704    /* Fill BWP UL dedicated PUSCH config */
4705    ulBwp->pusch_Config = NULLP;
4706    DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4707    if(!ulBwp->pusch_Config)
4708    {
4709       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4710       return RFAILED;
4711    }
4712
4713    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
4714    ulBwp->pusch_Config->choice.setup = NULLP;
4715    DU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4716    if(!ulBwp->pusch_Config->choice.setup)
4717    {
4718       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4719       return RFAILED;
4720    }
4721
4722    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
4723    {
4724       return RFAILED;
4725    }
4726
4727    ulBwp->configuredGrantConfig = NULLP;
4728
4729    /* Fill BPW UL dedicated SRS config */
4730    ulBwp->srs_Config = NULLP;
4731    DU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4732    if(!ulBwp->srs_Config)
4733    {
4734       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4735       return RFAILED;
4736    }
4737
4738    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
4739    ulBwp->srs_Config->choice.setup = NULLP;
4740    DU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4741    if(!ulBwp->srs_Config->choice.setup)
4742    {
4743       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4744       return RFAILED;
4745    }
4746
4747    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
4748    {
4749       return RFAILED;
4750    }
4751
4752    ulBwp->beamFailureRecoveryConfig = NULLP;
4753
4754    return ROK;
4755 }
4756
4757 /*******************************************************************
4758  *
4759  * @brief Builds UL config
4760  * @details
4761  *
4762  *    Function : BuildUlCfg
4763  *
4764  *    Functionality: Builds UL config in spCellCfgDed
4765  *
4766  * @params[in] UplinkConfig_t *ulCfg
4767  *
4768  * @return ROK     - success
4769  *         RFAILED - failure
4770  *
4771  * ****************************************************************/
4772 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
4773 {
4774    ulCfg->initialUplinkBWP = NULLP;
4775    DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4776    if(!ulCfg->initialUplinkBWP)
4777    {
4778       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4779       return RFAILED;
4780    }
4781
4782    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
4783    {
4784       return RFAILED;
4785    }
4786
4787    ulCfg->uplinkBWP_ToReleaseList = NULLP;
4788    ulCfg->uplinkBWP_ToAddModList = NULLP;
4789    ulCfg->firstActiveUplinkBWP_Id = NULLP;
4790    DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4791    if(!ulCfg->firstActiveUplinkBWP_Id)
4792    {
4793       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4794       return RFAILED;
4795    }
4796    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
4797
4798    ulCfg->pusch_ServingCellConfig = NULLP;
4799    DU_ALLOC(ulCfg->pusch_ServingCellConfig, \
4800          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4801    if(!ulCfg->pusch_ServingCellConfig)
4802    {
4803       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4804       return RFAILED;
4805    }
4806
4807    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
4808    {
4809       return RFAILED;
4810    }
4811
4812    ulCfg->carrierSwitching = NULLP;
4813    ulCfg->ext1 = NULLP;
4814    return ROK;
4815 }
4816
4817 /*******************************************************************
4818  *
4819  * @brief Builds PDSCH serving cell config
4820  * @details
4821  *
4822  *    Function : BuildPdschSrvCellCfg
4823  *
4824  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
4825  *
4826  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
4827  *
4828  * @return ROK     - success
4829  *         RFAILED - failure
4830  *
4831  * ****************************************************************/
4832 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
4833 {
4834    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
4835    pdschCfg->choice.setup = NULLP;
4836    DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
4837    if(!pdschCfg->choice.setup)
4838    {
4839       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4840       return RFAILED;
4841    }
4842
4843    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4844    pdschCfg->choice.setup->xOverhead = NULLP;
4845    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
4846    DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
4847    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
4848    {
4849       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4850       return RFAILED;
4851    }
4852    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
4853    pdschCfg->choice.setup->pucch_Cell = NULLP;
4854    pdschCfg->choice.setup->ext1 = NULLP;
4855
4856    return ROK;
4857 }
4858
4859 /*******************************************************************
4860  *
4861  * @brief Builds CSI Meas config
4862  * @details
4863  *
4864  *    Function : BuildCsiMeasCfg
4865  *
4866  *    Functionality: Builds CSI Meas config in spCellCfgDed
4867  *
4868  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
4869  *
4870  * @return ROK     - success
4871  *         RFAILED - failure
4872  *
4873  * ****************************************************************/
4874 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
4875 {
4876
4877    return ROK;
4878 }
4879
4880 /*******************************************************************
4881  *
4882  * @brief Builds Spcell config dedicated
4883  * @details
4884  *
4885  *    Function : BuildSpCellCfgDed
4886  *
4887  *    Functionality: Builds sp cell config dedicated in spCellCfg
4888  *
4889  * @params[in] ServingCellConfig_t srvCellCfg
4890  *
4891  * @return ROK     - success
4892  *         RFAILED - failure
4893  *
4894  * ****************************************************************/
4895 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
4896 {
4897    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
4898    DU_ALLOC(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
4899    if(!srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
4900    {
4901       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4902       return RFAILED;
4903    }
4904
4905    srvCellCfg->initialDownlinkBWP = NULLP;
4906    DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
4907    if(!srvCellCfg->initialDownlinkBWP)
4908    {
4909       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4910       return RFAILED;
4911    }
4912
4913    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
4914    {
4915       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
4916       return RFAILED;
4917    }
4918    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
4919    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
4920
4921    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
4922    DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
4923    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
4924    {
4925       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4926       return RFAILED;
4927    }
4928    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4929
4930    srvCellCfg->bwp_InactivityTimer = NULLP;
4931
4932    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
4933    DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
4934    if(!srvCellCfg->defaultDownlinkBWP_Id)
4935    {
4936       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4937       return RFAILED;
4938    }
4939    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4940
4941    srvCellCfg->uplinkConfig = NULLP;
4942    DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
4943    if(!srvCellCfg->uplinkConfig)
4944    {
4945       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4946       return RFAILED;
4947    }
4948
4949    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
4950    {
4951       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
4952       return RFAILED;
4953    }
4954    srvCellCfg->supplementaryUplink = NULLP;
4955    srvCellCfg->pdcch_ServingCellConfig = NULLP;
4956
4957    srvCellCfg->pdsch_ServingCellConfig = NULLP;
4958    DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
4959    if(!srvCellCfg->pdsch_ServingCellConfig)
4960    {
4961       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4962       return RFAILED;
4963    }
4964
4965    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
4966    {
4967       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
4968       return RFAILED;
4969    }
4970
4971    srvCellCfg->csi_MeasConfig = NULLP;
4972 #if 0
4973    DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
4974       if(!srvCellCfg->csi_MeasConfig)
4975       {
4976          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4977          return RFAILED;
4978       }
4979
4980    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
4981    {
4982       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
4983       return RFAILED;
4984    }
4985 #endif
4986    srvCellCfg->sCellDeactivationTimer = NULLP;
4987    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
4988    srvCellCfg->tag_Id = TAG_ID;
4989    srvCellCfg->dummy = NULLP;
4990    srvCellCfg->pathlossReferenceLinking = NULLP;
4991    srvCellCfg->servingCellMO = NULLP;
4992    srvCellCfg->ext1 = NULLP;
4993
4994    return ROK;
4995 }
4996 /*******************************************************************
4997  *
4998  * @brief Builds Spcell config
4999  *
5000  * @details
5001  *
5002  *    Function : BuildSpCellCfg
5003  *
5004  *    Functionality: Builds sp cell config in DuToCuRrcContainer
5005  *
5006  * @params[in] SpCellConfig_t spCellCfg
5007  *
5008  * @return ROK     - success
5009  *         RFAILED - failure
5010  *
5011  * ****************************************************************/
5012 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
5013 {
5014
5015    spCellCfg->servCellIndex = NULLP;
5016    DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
5017    if(!spCellCfg->servCellIndex)
5018    {
5019       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5020       return RFAILED;
5021    }
5022    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
5023
5024    spCellCfg->reconfigurationWithSync = NULLP;
5025    spCellCfg->rlf_TimersAndConstants = NULLP;
5026    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
5027    DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5028    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
5029    {
5030       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5031       return RFAILED;
5032    }
5033    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
5034
5035    spCellCfg->spCellConfigDedicated = NULLP;
5036    DU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5037    if(!spCellCfg->spCellConfigDedicated)
5038    {
5039       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5040       return RFAILED;
5041    }
5042    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
5043    {
5044       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
5045       return RFAILED;
5046    }
5047    return ROK;
5048 }
5049 /*******************************************************************
5050  *
5051  * @brief Builds Phy cell group config
5052  *
5053  * @details
5054  *
5055  *    Function : BuildPhyCellGrpCfg
5056  *
5057  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
5058  *
5059  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
5060  *
5061  * @return ROK     - success
5062  *         RFAILED - failure
5063  *
5064  * ****************************************************************/
5065 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
5066 {
5067    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
5068    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
5069
5070    phyCellGrpCfg->p_NR_FR1 = NULLP;
5071    DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5072    if(!phyCellGrpCfg->p_NR_FR1)
5073    {
5074       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
5075       return RFAILED;
5076    }
5077    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
5078    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
5079    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
5080    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
5081    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
5082    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
5083    phyCellGrpCfg->cs_RNTI = NULLP;
5084    phyCellGrpCfg->ext1 = NULLP;
5085    phyCellGrpCfg->ext2 = NULLP;
5086
5087    return ROK;
5088 }
5089 /*******************************************************************
5090  *
5091  * @brief Builds Mac cell group config
5092  *
5093  * @details
5094  *
5095  *    Function : BuildMacCellGrpCfg
5096  *
5097  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
5098  *
5099  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
5100  *
5101  * @return ROK     - success
5102  *         RFAILED - failure
5103  *
5104  * ****************************************************************/
5105 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
5106 {
5107    macCellGrpCfg->drx_Config = NULLP;
5108    macCellGrpCfg->schedulingRequestConfig = NULLP;
5109    DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5110    if(!macCellGrpCfg->schedulingRequestConfig)
5111    {
5112       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5113       return RFAILED;
5114    }
5115
5116    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
5117    {
5118       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
5119       return RFAILED;
5120    }
5121
5122    macCellGrpCfg->bsr_Config = NULLP;
5123    DU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5124    if(!macCellGrpCfg->bsr_Config)
5125    {
5126       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5127       return RFAILED;
5128    }
5129
5130    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
5131    {
5132       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
5133       return RFAILED;
5134    }
5135
5136    macCellGrpCfg->tag_Config = NULLP;
5137    DU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
5138    if(!macCellGrpCfg->tag_Config)
5139    {
5140       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5141       return RFAILED;
5142    }
5143
5144    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
5145    {
5146       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
5147       return RFAILED;
5148    }
5149
5150    macCellGrpCfg->phr_Config = NULLP;
5151    DU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
5152    if(!macCellGrpCfg->phr_Config)
5153    {
5154       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5155       return RFAILED;
5156    }
5157
5158    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
5159    {
5160       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
5161       return RFAILED;
5162    }
5163
5164    macCellGrpCfg->skipUplinkTxDynamic = false;
5165    macCellGrpCfg->ext1 = NULLP;
5166
5167    return ROK;
5168 }
5169 /*******************************************************************
5170  *
5171  * @brief Frees memeory allocated for SearchSpcToAddModList
5172  *
5173  * @details
5174  *
5175  *    Function : FreeSearchSpcToAddModList
5176  *
5177  *    Functionality: Deallocating memory of SearchSpcToAddModList
5178  *
5179  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
5180  *
5181  * @return void
5182  *
5183  4221 * ****************************************************************/
5184 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
5185 {
5186    uint8_t idx1=0;
5187    uint8_t idx2=0;
5188    struct  SearchSpace *searchSpc=NULLP;
5189
5190    if(searchSpcList->list.array)
5191    {
5192       if(searchSpcList->list.array[idx2])
5193       {
5194          searchSpc = searchSpcList->list.array[idx2];
5195          if(searchSpc->controlResourceSetId)
5196          {
5197             if(searchSpc->monitoringSlotPeriodicityAndOffset)
5198             {
5199                if(searchSpc->monitoringSymbolsWithinSlot)
5200                {
5201                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
5202                   {
5203                      if(searchSpc->nrofCandidates)
5204                      {
5205                         if(searchSpc->searchSpaceType)
5206                         {
5207                            DU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
5208                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
5209                            DU_FREE(searchSpc->searchSpaceType, sizeof(struct
5210                                     SearchSpace__searchSpaceType));
5211                         }
5212                         DU_FREE(searchSpc->nrofCandidates,
5213                               sizeof(struct SearchSpace__nrofCandidates));
5214                      }
5215                      DU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
5216                            searchSpc->monitoringSymbolsWithinSlot->size);
5217                   }
5218                   DU_FREE(searchSpc->monitoringSymbolsWithinSlot,
5219                         sizeof(BIT_STRING_t));
5220                }
5221                DU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
5222                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
5223             }
5224             DU_FREE(searchSpc->controlResourceSetId,
5225                   sizeof(ControlResourceSetId_t));
5226          }
5227       }
5228       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
5229       {
5230          DU_FREE(searchSpcList->list.array[idx1],
5231                sizeof(struct SearchSpace));
5232       }
5233       DU_FREE(searchSpcList->list.array,searchSpcList->list.size);
5234    }
5235 }
5236 /*******************************************************************
5237  *
5238  * @brief Frees memory allocated for PdschTimeDomAllocList
5239  *
5240  * @details
5241  *
5242  *    Function : FreePdschTimeDomAllocList
5243  *
5244  *    Functionality: Deallocating memory of PdschTimeDomAllocList
5245  *
5246  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
5247  *
5248  * @return void
5249  *
5250  * ****************************************************************/
5251 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
5252 {
5253    uint8_t idx1=0;
5254
5255    if(timeDomAllocList->choice.setup)
5256    {
5257       if(timeDomAllocList->choice.setup->list.array)
5258       {
5259          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
5260          {
5261             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1]->k0, sizeof(long));
5262             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
5263                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
5264          }
5265          DU_FREE(timeDomAllocList->choice.setup->list.array, \
5266                timeDomAllocList->choice.setup->list.size);
5267       }
5268       DU_FREE(timeDomAllocList->choice.setup,\
5269             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
5270    }
5271 }
5272 /*******************************************************************
5273  *
5274  * @brief Frees memory allocated for PuschTimeDomAllocList
5275  *
5276  *@details
5277  *
5278  *    Function : FreePuschTimeDomAllocList
5279  *
5280  *    Functionality: Deallocating memory of PuschTimeDomAllocList
5281  *
5282  * @params[in] PUSCH_Config_t *puschCfg
5283  *
5284  * @return void
5285  *
5286  * ****************************************************************/
5287 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
5288 {
5289    uint8_t rsrcListIdx=0;
5290    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
5291
5292    if(puschCfg->pusch_TimeDomainAllocationList)
5293    {
5294       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
5295       if(timeDomAllocList_t->choice.setup)
5296       {
5297          if(timeDomAllocList_t->choice.setup->list.array)
5298          {
5299             for(rsrcListIdx = 0; rsrcListIdx<timeDomAllocList_t->choice.setup->list.count; rsrcListIdx++)
5300             {
5301                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx]->k2, sizeof(long));
5302                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx],\
5303                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
5304             }
5305             DU_FREE(timeDomAllocList_t->choice.setup->list.array, \
5306                   timeDomAllocList_t->choice.setup->list.size);
5307          }
5308          DU_FREE(timeDomAllocList_t->choice.setup, \
5309                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
5310       }
5311       DU_FREE(puschCfg->transformPrecoder, sizeof(long));
5312       DU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
5313             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
5314    }
5315
5316 }
5317 /*******************************************************************
5318  *
5319  * @brief Frees memory allocated for InitialUlBWP
5320  *
5321  * @details
5322  *
5323  *    Function : FreeInitialUlBWP
5324  *
5325  *    Functionality: Deallocating memory of InitialUlBWP
5326  *
5327  * @params[in] BWP_UplinkDedicated_t *ulBwp
5328  *
5329  * @return void
5330  *
5331  * ****************************************************************/
5332 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5333 {
5334    uint8_t  rSetIdx, rsrcIdx, k1Idx;
5335    SRS_Config_t   *srsCfg = NULLP;
5336    PUSCH_Config_t *puschCfg = NULLP;
5337    PUCCH_Config_t *pucchCfg = NULLP;
5338    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
5339    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
5340    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
5341    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
5342
5343    if(ulBwp->pucch_Config)
5344    {
5345       if(ulBwp->pucch_Config->choice.setup)
5346       {
5347           pucchCfg = ulBwp->pucch_Config->choice.setup;
5348           if(pucchCfg->dl_DataToUL_ACK)
5349           {
5350              if(pucchCfg->dl_DataToUL_ACK->list.array)
5351              {
5352                 for(k1Idx = 0; k1Idx < pucchCfg->dl_DataToUL_ACK->list.count; k1Idx++)
5353                 {
5354                    DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[k1Idx], sizeof(long));
5355                 }
5356                 DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
5357              }
5358              DU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
5359           }
5360           DU_FREE(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
5361       }
5362       DU_FREE(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
5363    }
5364
5365    if(ulBwp->pusch_Config)
5366    {
5367       if(ulBwp->pusch_Config->choice.setup)
5368       {
5369          puschCfg=ulBwp->pusch_Config->choice.setup;
5370          if(puschCfg->dataScramblingIdentityPUSCH)
5371          {
5372             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
5373             {
5374                FreePuschTimeDomAllocList(puschCfg);
5375                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
5376                if(dmrsUlCfg->choice.setup)
5377                {
5378                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
5379                   {
5380                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
5381                      {
5382                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
5383                               sizeof(long));
5384                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
5385                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
5386                      }
5387                      DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
5388                            sizeof(long));
5389                   }
5390                   DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
5391                }
5392                DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
5393                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
5394             }
5395             DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
5396          }
5397          DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5398       }
5399       DU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5400
5401       /* Free SRS-Config */
5402       if(ulBwp->srs_Config)
5403       {
5404          if(ulBwp->srs_Config->choice.setup)
5405          {
5406             srsCfg = ulBwp->srs_Config->choice.setup;
5407
5408             /* Free Resource Set to add/mod list */
5409             if(srsCfg->srs_ResourceSetToAddModList)
5410             {
5411                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
5412                if(rsrcSetList->list.array)
5413                {
5414                   rSetIdx = 0;
5415
5416                   /* Free SRS resource Id list in this SRS resource set */
5417                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5418                   {
5419                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5420
5421                      if(rsrcIdList->list.array)
5422                      {
5423                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5424                         {
5425                            DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5426                         }
5427                         DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
5428                      }
5429                      DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5430                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5431                   }
5432
5433                   /* Free resource type info for this SRS resource set */
5434                   DU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5435                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5436
5437                   /* Free memory for each resource set */
5438                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5439                   {
5440                      DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5441                   }
5442                   DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
5443                }
5444                DU_FREE(srsCfg->srs_ResourceSetToAddModList, \
5445                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5446             }
5447
5448             /* Free resource to add/modd list */
5449             if(srsCfg->srs_ResourceToAddModList)
5450             {
5451                resourceList = srsCfg->srs_ResourceToAddModList;
5452                if(resourceList->list.array)
5453                {
5454                   rsrcIdx = 0;
5455                   DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
5456                         sizeof(struct SRS_Resource__transmissionComb__n2));
5457                   DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
5458                         sizeof(struct SRS_Resource__resourceType__aperiodic));
5459
5460                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5461                   {
5462                      DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5463                   }
5464                   DU_FREE(resourceList->list.array, resourceList->list.size);
5465                }
5466                DU_FREE(srsCfg->srs_ResourceToAddModList, \
5467                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
5468             }
5469
5470             DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5471          }
5472          DU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5473       }
5474    }
5475 }
5476 /*******************************************************************
5477  *
5478  * @brief Frees memory allocated for initialUplinkBWP
5479  *
5480  * @details
5481  *
5482  *    Function : FreeinitialUplinkBWP
5483  *
5484  *    Functionality: Deallocating memory of initialUplinkBWP
5485  *
5486  * @params[in] UplinkConfig_t *ulCfg
5487  *
5488  * @return void
5489  *
5490  *
5491  * ****************************************************************/
5492 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
5493 {
5494    BWP_UplinkDedicated_t *ulBwp=NULLP;
5495    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
5496
5497    if(ulCfg->initialUplinkBWP)
5498    {
5499       ulBwp=ulCfg->initialUplinkBWP;
5500       if(ulCfg->firstActiveUplinkBWP_Id)
5501       {
5502          if(ulCfg->pusch_ServingCellConfig)
5503          {
5504             puschCfg=ulCfg->pusch_ServingCellConfig;
5505             if(puschCfg->choice.setup)
5506             {
5507                if(puschCfg->choice.setup->ext1)
5508                {
5509                   DU_FREE(puschCfg->choice.setup->ext1->\
5510                         processingType2Enabled,sizeof(BOOLEAN_t));
5511                   DU_FREE(puschCfg->choice.setup->ext1->\
5512                         maxMIMO_Layers,sizeof(long));
5513                   DU_FREE(puschCfg->choice.setup->ext1, \
5514                         sizeof(struct PUSCH_ServingCellConfig__ext1));
5515                }
5516                DU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5517             }
5518             DU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5519          }
5520          DU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5521       }
5522       FreeInitialUlBWP(ulBwp);
5523       DU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5524    }
5525 }
5526 /*******************************************************************
5527  *
5528  * @brief Frees emmory allocated for BWPDlDedPdschCfg
5529  *
5530  * @details
5531  *
5532  *    Function : FreeBWPDlDedPdschCfg
5533  *
5534  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
5535  *
5536  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5537  *
5538  * @return void
5539  *
5540  *
5541  * ****************************************************************/
5542 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
5543 {
5544    struct PDSCH_Config *pdschCfg=NULLP;
5545    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
5546    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
5547    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
5548
5549    if(dlBwp->pdsch_Config->choice.setup)
5550    {
5551       pdschCfg=dlBwp->pdsch_Config->choice.setup;
5552       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
5553       {
5554          if(pdschCfg->pdsch_TimeDomainAllocationList)
5555          {
5556             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
5557             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
5558             {
5559                prbBndlType=&pdschCfg->prb_BundlingType;
5560                DU_FREE(prbBndlType->choice.staticBundling,\
5561                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
5562                DU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
5563             }
5564             FreePdschTimeDomAllocList(timeDomAllocList);
5565             DU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
5566                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
5567          }
5568          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
5569          if(dmrsDlCfg->choice.setup)
5570          {
5571             DU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
5572                   sizeof(long));
5573             DU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
5574          }
5575          DU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
5576                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
5577       }
5578       DU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
5579    }
5580 }
5581 /*******************************************************************
5582  *
5583  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
5584  *
5585  * @details
5586  *
5587  *    Function : FreeBWPDlDedPdcchCfg
5588  *
5589  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
5590  *
5591  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5592  *
5593  * @return void
5594  *
5595  *
5596  * ****************************************************************/
5597 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
5598 {
5599    uint8_t idx1=0;
5600    uint8_t idx2=0;
5601    struct PDCCH_Config *pdcchCfg=NULLP;
5602    struct ControlResourceSet *controlRSet=NULLP;
5603    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
5604
5605    if(dlBwp->pdcch_Config->choice.setup)
5606    {
5607       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
5608       if(pdcchCfg->controlResourceSetToAddModList)
5609       {
5610          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
5611          if(controlRSetList->list.array)
5612          {
5613             controlRSet = controlRSetList->list.array[idx2];
5614             if(controlRSet)
5615             {
5616                if(controlRSet->frequencyDomainResources.buf)
5617                {
5618                   if(controlRSet->pdcch_DMRS_ScramblingID)
5619                   {
5620                      if(pdcchCfg->searchSpacesToAddModList)
5621                      {
5622                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
5623                         DU_FREE(pdcchCfg->searchSpacesToAddModList, \
5624                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
5625                      }
5626                      DU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
5627                   }
5628                   DU_FREE(controlRSet->frequencyDomainResources.buf, \
5629                         controlRSet->frequencyDomainResources.size);
5630                }
5631             }
5632             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
5633             {
5634                DU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
5635             }
5636             DU_FREE(controlRSetList->list.array, controlRSetList->list.size);
5637          }
5638          DU_FREE(pdcchCfg->controlResourceSetToAddModList, \
5639                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
5640       }
5641       DU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
5642    }
5643 }
5644
5645 /*******************************************************************
5646  *
5647  * @brief Frees emmory allocated for DUToCURRCContainer
5648  *
5649  * @details
5650  *
5651  *    Function : FreeMemDuToCuRrcCont
5652  *
5653  *    Functionality: Deallocating memory of DuToCuRrcContainer
5654  *
5655  * @params[in] DuToCuRRCContainer, DuToCuRRCContainer
5656  *
5657  * @return ROK     - success
5658  *         RFAILED - failure
5659  *
5660  * ****************************************************************/
5661 uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg)
5662 {
5663    uint8_t idx=0;
5664    SpCellConfig_t *spCellCfg=NULLP;
5665    ServingCellConfig_t *srvCellCfg=NULLP;
5666    BWP_DownlinkDedicated_t *dlBwp=NULLP;
5667    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
5668    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
5669    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
5670    struct RLC_Config *rlcConfig=NULLP;
5671    struct LogicalChannelConfig *macLcConfig=NULLP;
5672    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
5673    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
5674    struct TAG_Config *tagConfig=NULLP;
5675    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
5676    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
5677    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
5678
5679    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
5680    if(rlcBearerList)
5681    {
5682       if(rlcBearerList->list.array)
5683       {
5684          for(idx=0; idx<rlcBearerList->list.count; idx++)
5685          {
5686             if(rlcBearerList->list.array[idx])
5687             {
5688                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
5689                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
5690                if(rlcConfig)
5691                {
5692                   if(rlcConfig->choice.am)
5693                   {
5694                      DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5695                      DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5696                      DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
5697                   }
5698                   DU_FREE(rlcConfig, sizeof(struct RLC_Config));
5699                }
5700                DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
5701                if(macLcConfig)
5702                {
5703                   if(macLcConfig->ul_SpecificParameters)
5704                   {
5705                      DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
5706                      DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
5707                      DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
5708                   }
5709                   DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
5710                }
5711                DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
5712             }
5713          }
5714          DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
5715       }
5716       DU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5717    }
5718
5719    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
5720    if(macCellGrpCfg)
5721    {
5722       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
5723       if(schedulingRequestConfig)
5724       {
5725          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
5726          if(schReqList)
5727          {
5728             if(schReqList->list.array)
5729             {
5730                for(idx=0;idx<schReqList->list.count; idx++)
5731                {
5732                   if(schReqList->list.array[idx])
5733                   {
5734                      DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
5735                      DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
5736                   }
5737                }
5738                DU_FREE(schReqList->list.array, schReqList->list.size);
5739             }
5740             DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
5741                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
5742             DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5743       }
5744       if(macCellGrpCfg->bsr_Config)
5745       {
5746          DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5747       }
5748       tagConfig = macCellGrpCfg->tag_Config;
5749       if(tagConfig)
5750       {
5751          tagList = tagConfig->tag_ToAddModList;
5752          if(tagList)
5753          {
5754             if(tagList->list.array)
5755             {
5756                for(idx=0; idx<tagList->list.count; idx++)
5757                {
5758                   DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
5759                }
5760                DU_FREE(tagList->list.array, tagList->list.size);
5761             }
5762             DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
5763          }
5764          DU_FREE(tagConfig, sizeof(struct TAG_Config));
5765       }
5766
5767       phrConfig = macCellGrpCfg->phr_Config;
5768       if(phrConfig)
5769       {
5770          DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
5771          DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
5772       }
5773
5774       DU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
5775    }
5776
5777    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
5778    if(phyCellGrpCfg)
5779    {
5780       DU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5781       DU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
5782    }
5783
5784    spCellCfg = cellGrpCfg->spCellConfig;
5785    if(spCellCfg)
5786    {
5787       if(spCellCfg->servCellIndex)
5788       {
5789          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
5790          {
5791             if(spCellCfg->spCellConfigDedicated)
5792             {
5793                srvCellCfg = spCellCfg->spCellConfigDedicated;
5794                if(srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
5795                {
5796                   if(srvCellCfg->initialDownlinkBWP)
5797                   {
5798                      dlBwp = srvCellCfg->initialDownlinkBWP;
5799                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
5800                      {
5801                         if(srvCellCfg->defaultDownlinkBWP_Id)
5802                         {
5803                            if(srvCellCfg->uplinkConfig)
5804                            {
5805                               if(srvCellCfg->pdsch_ServingCellConfig)
5806                               {
5807                                  pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
5808                                  if(pdschCfg->choice.setup)
5809                                  {
5810                                     DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
5811                                     DU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5812                                  }
5813                                  DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
5814                                           ServingCellConfig__pdsch_ServingCellConfig));
5815                               }
5816                               FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
5817                               DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
5818                            }
5819                            DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
5820                         }
5821                         DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
5822                      }
5823                      if(dlBwp->pdcch_Config)
5824                      {
5825                         if(dlBwp->pdsch_Config)
5826                         {
5827                            FreeBWPDlDedPdschCfg(dlBwp);
5828                            DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
5829                         }
5830                         FreeBWPDlDedPdcchCfg(dlBwp);
5831                         DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
5832                      }
5833                      DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
5834                   }
5835                   DU_FREE(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
5836                }
5837                DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5838             }
5839             DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5840          }
5841          DU_FREE(spCellCfg->servCellIndex, sizeof(long));
5842       }
5843       DU_FREE(spCellCfg,sizeof(SpCellConfig_t));
5844    }
5845    return ROK;
5846 }
5847 /*******************************************************************
5848  *
5849  * @brief Builds DU To CU RRC Container
5850  *
5851  * @details
5852  *
5853  *    Function : BuildDuToCuRrcContainer
5854  *
5855  *    Functionality: Builds DuToCuRrcContainer
5856  *
5857  * @params[in] idx, index in F1AP msg
5858  *             DuToCuRRCContainer, DuToCuRRCContainer
5859  *
5860  * @return ROK     - success
5861  *         RFAILED - failure
5862  *
5863  * ****************************************************************/
5864 uint8_t BuildDuToCuRrcContainer(DUtoCURRCContainer_t *duToCuRrcContainer)
5865 {
5866    uint8_t  ret = ROK;
5867    CellGroupConfigRrc_t  cellGrpCfg;
5868    asn_enc_rval_t        encRetVal;
5869    memset(&cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
5870    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
5871
5872    while(true)
5873    {
5874       cellGrpCfg.cellGroupId = CELL_GRP_ID;
5875
5876       cellGrpCfg.rlc_BearerToAddModList = NULLP;
5877       DU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5878       if(!cellGrpCfg.rlc_BearerToAddModList)
5879       {
5880          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5881          ret = RFAILED;
5882          break;
5883       }
5884       if(BuildRlcBearerToAddModList(cellGrpCfg.rlc_BearerToAddModList) != ROK)
5885       {
5886          DU_LOG("\nERROR  -->  F1AP : BuildRlcBearerToAddModList failed");
5887          ret = RFAILED;
5888          break;
5889       }
5890
5891       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
5892       cellGrpCfg.mac_CellGroupConfig = NULLP;
5893       DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
5894       if(!cellGrpCfg.mac_CellGroupConfig)
5895       {
5896          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5897          ret = RFAILED;
5898          break;
5899       }
5900       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
5901       {
5902          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
5903          ret = RFAILED;
5904          break;
5905       }
5906
5907       cellGrpCfg.physicalCellGroupConfig = NULLP;
5908       DU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
5909       if(!cellGrpCfg.physicalCellGroupConfig)
5910       {
5911          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5912          ret = RFAILED;
5913          break;
5914       }
5915       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
5916       {
5917          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
5918          ret = RFAILED;
5919          break;
5920       }
5921
5922       cellGrpCfg.spCellConfig = NULLP;
5923       DU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
5924       if(!cellGrpCfg.spCellConfig)
5925       {
5926          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5927          ret = RFAILED;
5928          break;
5929       }
5930       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
5931       {
5932          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
5933          ret = RFAILED;
5934          break;
5935       }
5936
5937       cellGrpCfg.sCellToAddModList = NULLP;
5938       cellGrpCfg.sCellToReleaseList = NULLP;
5939       cellGrpCfg.ext1 = NULLP;
5940
5941       /* encode cellGrpCfg into duToCuRrcContainer */
5942       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
5943       memset(encBuf, 0, ENC_BUF_MAX_LEN);
5944       encBufSize = 0;
5945       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
5946       /* Encode results */
5947       if(encRetVal.encoded == ENCODE_FAIL)
5948       {
5949          DU_LOG( "\nERROR  --> F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
5950                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5951          ret = RFAILED;
5952          break;
5953       }
5954       else
5955       {
5956          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
5957          for(int i=0; i< encBufSize; i++)
5958          {
5959             printf("%x",encBuf[i]);
5960          }
5961       }
5962
5963       duToCuRrcContainer->size = encBufSize;
5964       DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
5965       if(!duToCuRrcContainer->buf)
5966       {
5967          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
5968          ret = RFAILED;
5969          break;
5970       }
5971       if(ret == ROK)
5972       {
5973          memcpy(duToCuRrcContainer->buf, encBuf, duToCuRrcContainer->size);
5974       }
5975       break;
5976    }
5977    FreeMemDuToCuRrcCont(&cellGrpCfg);
5978    return ret;
5979 }
5980
5981 /*******************************************************************
5982  *
5983  * @brief Free memory allocated in InitialULRRCMessage
5984  *
5985  * @details
5986  *
5987  *    Function : freeInitUlRrcMsgTransfer
5988  *
5989  *    Functionality: Free memory allocated in InitialULRRCMessage
5990  *
5991  * @params[in]F1AP_PDU_t  *f1apMsg)
5992  *
5993  * @return ROK     - success
5994  *         RFAILED - failure
5995  *
5996  * ****************************************************************/
5997
5998 uint8_t freeInitUlRrcMsgTransfer(F1AP_PDU_t  *f1apMsg)
5999 {
6000    uint8_t ieIdx, arrIdx;
6001    InitialULRRCMessageTransfer_t *initULRRCMsg=NULLP;
6002
6003    if(f1apMsg)
6004    {
6005       if(f1apMsg->choice.initiatingMessage)
6006       {
6007          initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.\
6008             choice.InitialULRRCMessageTransfer;
6009          if(initULRRCMsg->protocolIEs.list.array)
6010          {
6011             for(ieIdx = 0; ieIdx < initULRRCMsg->protocolIEs.list.count; ieIdx++)
6012             {
6013                switch(initULRRCMsg->protocolIEs.list.array[ieIdx]->id)
6014                {
6015                   case ProtocolIE_ID_id_NRCGI:
6016                   {
6017                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf)
6018                      {
6019                         if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf)
6020                         {
6021                            DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf,\
6022                            initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.size);
6023                         }
6024                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf,\
6025                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.size);
6026                      }
6027                      break;
6028                   }
6029                   case ProtocolIE_ID_id_RRCContainer:
6030                   {
6031                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
6032                      {
6033                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,\
6034                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
6035                      }
6036                      break;
6037                   }
6038                   case ProtocolIE_ID_id_DUtoCURRCContainer:
6039                   {
6040                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf)
6041                      {
6042                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf,
6043                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.size);
6044                      }
6045                      break;
6046                   }
6047                   default:
6048                      break;
6049                }
6050              }
6051              for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
6052              {
6053                 if(initULRRCMsg->protocolIEs.list.array[arrIdx])
6054                 {
6055                    DU_FREE(initULRRCMsg->protocolIEs.list.array[arrIdx],\
6056                       sizeof(InitialULRRCMessageTransferIEs_t));
6057                 }
6058              }
6059              DU_FREE(initULRRCMsg->protocolIEs.list.array, initULRRCMsg->protocolIEs.list.size);
6060           }
6061          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
6062       }
6063       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
6064    }
6065    else
6066    {
6067       DU_LOG("\nERROR  -->  DU_APP : Recevied F1ap Pdu is null at freeInitUlRrcMsgTransfer()");
6068       return RFAILED;
6069    }
6070    return ROK;
6071 }
6072
6073 /*******************************************************************
6074  *
6075  * @brief Builds and sends the InitialULRRCMessage
6076  *
6077  * @details
6078  *
6079  *    Function : BuildAndSendInitialRrcMsgTransfer
6080  *
6081  *    Functionality: Constructs the Initial UL RRC Message Transfer and sends
6082  *                   it to the CU through SCTP.
6083  *
6084  * @params[in]
6085  *
6086  * @return ROK     - success
6087  *         RFAILED - failure
6088  *
6089  * ****************************************************************/
6090 uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti,
6091       uint16_t rrcContSize, uint8_t *rrcContainer)
6092 {
6093    uint8_t   ret;
6094    uint8_t   elementCnt;
6095    uint8_t   ieIdx;
6096    asn_enc_rval_t  encRetVal;
6097    F1AP_PDU_t  *f1apMsg = NULLP;
6098    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
6099    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
6100
6101    while(true)
6102    {
6103       DU_LOG("\n INFO   -->  F1AP : Building RRC Setup Request\n");
6104       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
6105       if(f1apMsg == NULLP)
6106       {
6107          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
6108          break;
6109       }
6110       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
6111       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
6112       if(f1apMsg->choice.initiatingMessage == NULLP)
6113       {
6114          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
6115          break;
6116       }
6117       f1apMsg->choice.initiatingMessage->procedureCode =\
6118                                                         ProcedureCode_id_InitialULRRCMessageTransfer;
6119       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
6120       f1apMsg->choice.initiatingMessage->value.present = \
6121                                                          InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
6122       initULRRCMsg =\
6123                     &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
6124       elementCnt = 5;
6125       initULRRCMsg->protocolIEs.list.count = elementCnt;
6126       initULRRCMsg->protocolIEs.list.size = \
6127                                             elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *);
6128       /* Initialize the F1Setup members */
6129       DU_ALLOC(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
6130       if(initULRRCMsg->protocolIEs.list.array == NULLP)
6131       {
6132          DU_LOG(" ERROR  -->  F1AP : Memory allocation for\
6133                RRCSetupRequestMessageTransferIEs failed");
6134          break;
6135       }
6136       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
6137       {
6138          DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx],\
6139                sizeof(InitialULRRCMessageTransferIEs_t));
6140          if(initULRRCMsg->protocolIEs.list.array[ieIdx] == NULLP)
6141          {
6142             break;
6143          }
6144       }
6145       ieIdx = 0;
6146       /*GNB DU UE F1AP ID*/
6147       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6148                                                         ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
6149       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  = Criticality_reject;
6150       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
6151                                                                   InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
6152       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
6153
6154
6155       /*NRCGI*/
6156       ieIdx++;
6157       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6158                                                         ProtocolIE_ID_id_NRCGI;
6159       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  =Criticality_reject;
6160       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
6161                                                                   InitialULRRCMessageTransferIEs__value_PR_NRCGI;
6162
6163       ret =\
6164            BuildNrcgi(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
6165       if(ret!=ROK)
6166       {
6167          break;
6168       }
6169
6170       /*CRNTI*/
6171       ieIdx++;
6172       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6173                                                         ProtocolIE_ID_id_C_RNTI;
6174       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6175       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6176                                                                  InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
6177       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.C_RNTI = crnti;
6178
6179       /*RRCContainer*/
6180       ieIdx++;
6181       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6182                                                         ProtocolIE_ID_id_RRCContainer;
6183       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6184       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6185                                                                  InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
6186
6187       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = rrcContSize;
6188       DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
6189             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size)
6190       if(!initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
6191       {
6192          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
6193          break;
6194
6195       }
6196       memcpy(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, rrcContainer,
6197             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
6198
6199
6200       /*DUtoCURRCContainer*/
6201       ieIdx++;
6202       initULRRCMsg->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCContainer;
6203       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6204       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6205                                                                  InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
6206
6207       ret = BuildDuToCuRrcContainer(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer);
6208       if(ret != ROK)
6209       {
6210          break;
6211       }
6212
6213       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
6214
6215       /* Encode the F1SetupRequest type as APER */
6216       memset(encBuf, 0, ENC_BUF_MAX_LEN);
6217       encBufSize = 0;
6218       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
6219       /* Encode results */
6220       if(encRetVal.encoded == ENCODE_FAIL)
6221       {
6222          DU_LOG( "\nERROR  --> F1AP : Could not encode Initial UL RRC Message Transfer\
6223                structure (at %s)\n",encRetVal.failed_type ? \
6224                encRetVal.failed_type->name : "unknown");
6225          ret = RFAILED;
6226          break;
6227       }
6228       else
6229       {
6230
6231          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for Initial UL RRC\
6232                Message transfer\n");
6233          for(int i=0; i< encBufSize; i++)
6234          {
6235             printf("%x",encBuf[i]);
6236          }
6237       }
6238       /* Sending  msg  */
6239       if(sendF1APMsg() != ROK)
6240       {
6241          DU_LOG("\nERROR  -->  F1AP : Sending Initial UL RRC Message Transfer Failed");
6242          ret = RFAILED;
6243          break;
6244       }
6245       break;
6246    }
6247    freeInitUlRrcMsgTransfer(f1apMsg);
6248    return ret;
6249 }/* End of BuildAndSendInitialRrcMsgTransfer*/
6250
6251 /*****  UE SETUP REQUEST *****/
6252
6253 /*******************************************************************
6254  *
6255  * @brief Free Qos And Snssai Drb Info
6256  *
6257  * @details
6258  *
6259  *    Function : freeDrbQosAndSnssaiInfo
6260  *
6261  *    Functionality: Free Qos And Snssai Drb Info
6262  *
6263  * @params[in] LcCfg *lcCfg,
6264  * @return void
6265  *
6266  * ****************************************************************/
6267 void freeDrbQosAndSnssaiInfo(LcCfg *lcCfg)
6268 {
6269    if(lcCfg->snssai)
6270    {
6271       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6272    }
6273    if(lcCfg->drbQos)
6274    {
6275       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
6276    }
6277 }
6278
6279 /******************************************************************
6280 *
6281 * @brief Function to delete the RLC Lc cfg from UE APP DB
6282 *
6283 * @details
6284 *
6285 *  Function : freeRlcLcCfg
6286 *
6287 *  Functionality: Function to delete the RLC Lc cfg from UE APP DB
6288 *
6289 *
6290  *****************************************************************/
6291
6292 void freeRlcLcCfg(RlcBearerCfg *lcCfg)
6293 {
6294    switch(lcCfg->rlcMode)
6295    {
6296       case RLC_AM :
6297          {
6298             if(lcCfg->u.amCfg)
6299             {
6300                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.amCfg, sizeof(AmBearerCfg));
6301             }
6302             break;
6303          }
6304       case RLC_UM_BI_DIRECTIONAL :
6305          {
6306             if(lcCfg->u.umBiDirCfg)
6307             {
6308                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
6309             }
6310             break;
6311          }
6312       case RLC_UM_UNI_DIRECTIONAL_UL :
6313          {
6314             if(lcCfg->u.umUniDirUlCfg)
6315             {
6316                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
6317             }
6318             break;
6319
6320          }
6321       case RLC_UM_UNI_DIRECTIONAL_DL :
6322          {
6323             if(lcCfg->u.umUniDirDlCfg)
6324             {
6325                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
6326             }
6327             break;
6328          }
6329       default:
6330          DU_LOG("\nERROR  -->  DU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
6331          break;
6332    }
6333    DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6334 }
6335
6336 /*******************************************************************
6337  *
6338  * @brief Function to free MacLcCfg
6339  *
6340  * @details
6341  *
6342  *    Function : freeMacLcCfg
6343  *
6344  *    Functionality: Function to free MacLcCfg
6345  *
6346  * @params[in] LcCfg *lcCfg,
6347  * @return void
6348  *
6349  * ****************************************************************/
6350
6351 void  freeMacLcCfg(LcCfg *lcCfg)
6352 {
6353     /* Deleting DRBQOS */
6354    if(lcCfg->drbQos)
6355    {
6356       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
6357    }
6358    /* Deleting SNSSAI */
6359    if(lcCfg->snssai)
6360    {
6361       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6362    }
6363 }
6364 /*******************************************************************
6365  *
6366  * @brief Free UE NR Capability received in UE Context setup request
6367  *
6368  * @details
6369  *
6370  *    Function : freeAperDecodeUeNrCapability
6371  *
6372  *    Functionality:
6373  *       Free UE NR Capability received in UE Context setup request
6374  *
6375  * @params[in]
6376  * @return ROK     - success
6377  *         RFAILED - failure
6378  *
6379  * ****************************************************************/
6380 void freeAperDecodeUeNrCapability(void *ueNrCapability)
6381 {
6382    uint8_t arrIdx =0;
6383    FeatureSets_t *featureSets =NULLP;
6384    UE_NR_Capability_t *ueNrCap = (UE_NR_Capability_t *)ueNrCapability;
6385
6386    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
6387    {
6388       for(arrIdx = 0; arrIdx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; arrIdx++)
6389       {
6390          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx])
6391             free(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx]);
6392       }
6393       free(ueNrCap->rf_Parameters.supportedBandListNR.list.array);
6394    }
6395
6396    if(ueNrCap->featureSets)
6397    {
6398       featureSets = ueNrCap->featureSets;
6399       if(featureSets->featureSetsDownlinkPerCC)
6400       {
6401          if(featureSets->featureSetsDownlinkPerCC->list.array)
6402          {
6403             for(arrIdx = 0; arrIdx < featureSets->featureSetsDownlinkPerCC->list.count; arrIdx++)
6404             {
6405                if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx])
6406                {
6407                   if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL)
6408                      free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL);
6409                   free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]);
6410                }
6411             }
6412             free(featureSets->featureSetsDownlinkPerCC->list.array);
6413          }
6414          free(featureSets->featureSetsDownlinkPerCC);
6415       }
6416       if(featureSets->featureSetsUplinkPerCC)
6417       {
6418          if(featureSets->featureSetsUplinkPerCC->list.array)
6419          {
6420             for(arrIdx = 0; arrIdx < featureSets->featureSetsUplinkPerCC->list.count; arrIdx++)
6421             {
6422                if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx])
6423                {
6424                   if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL)
6425                      free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL);
6426                   free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]);
6427                }
6428             }
6429             free(featureSets->featureSetsUplinkPerCC->list.array);
6430          }
6431          free(featureSets->featureSetsUplinkPerCC);
6432       }
6433       free(ueNrCap->featureSets);
6434    }
6435 }
6436
6437 /*******************************************************************
6438 *
6439 * @brief Function to free PdcchSearchSpcToAddModList
6440          where memory allocated by aper_decoder
6441 *
6442 * @details
6443 *
6444 *    Function : freeAperDecodePdcchSearchSpcToAddModList
6445 *
6446 *    Functionality: Function to free PdcchSearchSpcToAddModList
6447 *
6448 * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
6449 * @return void
6450 *
6451 * ****************************************************************/
6452
6453 void freeAperDecodePdcchSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
6454 {
6455    uint8_t searchSpcArrIdx=0;
6456    uint8_t searchSpcArrIdx1=0;
6457    struct  SearchSpace *searchSpc=NULLP;
6458
6459
6460    if(searchSpcList->list.array)
6461    {
6462       if(searchSpcList->list.array[searchSpcArrIdx1])
6463       {
6464          searchSpc = searchSpcList->list.array[searchSpcArrIdx1];
6465          if(searchSpc->controlResourceSetId)
6466          {
6467             if(searchSpc->monitoringSlotPeriodicityAndOffset)
6468             {
6469                if(searchSpc->monitoringSymbolsWithinSlot)
6470                {
6471                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
6472                   {
6473                      if(searchSpc->nrofCandidates)
6474                      {
6475                         if(searchSpc->searchSpaceType)
6476                         {
6477                            free(searchSpc->searchSpaceType->choice.ue_Specific);
6478                            free(searchSpc->searchSpaceType);
6479                         }
6480                         free(searchSpc->nrofCandidates);
6481                      }
6482                      free(searchSpc->monitoringSymbolsWithinSlot->buf);
6483                   }
6484                   free(searchSpc->monitoringSymbolsWithinSlot);
6485                }
6486                free(searchSpc->monitoringSlotPeriodicityAndOffset);
6487             }
6488             free(searchSpc->controlResourceSetId);
6489          }
6490       }
6491       for(searchSpcArrIdx = 0; searchSpcArrIdx < searchSpcList->list.count; searchSpcArrIdx++)
6492       {
6493          free(searchSpcList->list.array[searchSpcArrIdx]);
6494       }
6495       free(searchSpcList->list.array);
6496    }
6497 }
6498 /*******************************************************************
6499 *
6500 * @brief Function for free part for the memory allocated by aper_decoder
6501 *
6502 * @details
6503 *
6504 *    Function : freeAperDecodeBWPDlDedPdcchConfig
6505 *
6506 *    Functionality: Function to free BWPDlDedPdcchConfig
6507 *
6508 * @params[in]
6509 * @return void
6510 *
6511 * ****************************************************************/
6512
6513
6514 void freeAperDecodeBWPDlDedPdcchConfig(BWP_DownlinkDedicated_t *dlBwp)
6515 {
6516    uint8_t arrIdx1=0;
6517    uint8_t arrIdx2=0;
6518    struct PDCCH_Config *pdcchCfg=NULLP;
6519    struct ControlResourceSet *controlRSet=NULLP;
6520    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
6521
6522    if(dlBwp->pdcch_Config->choice.setup)
6523    {
6524       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
6525       if(pdcchCfg->controlResourceSetToAddModList)
6526       {
6527          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
6528          if(controlRSetList->list.array)
6529          {
6530             controlRSet = controlRSetList->list.array[arrIdx2];
6531             if(controlRSet)
6532             {
6533                if(controlRSet->frequencyDomainResources.buf)
6534                {
6535                   if(controlRSet->pdcch_DMRS_ScramblingID)
6536                   {
6537                      if(pdcchCfg->searchSpacesToAddModList)
6538                      {
6539                         freeAperDecodePdcchSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
6540                         free(pdcchCfg->searchSpacesToAddModList);
6541                      }
6542                      free(controlRSet->pdcch_DMRS_ScramblingID);
6543                   }
6544                   free(controlRSet->frequencyDomainResources.buf);
6545                }
6546             }
6547             for(arrIdx1 = 0; arrIdx1 <controlRSetList->list.count; arrIdx1++)
6548             {
6549                free(controlRSetList->list.array[arrIdx1]);
6550             }
6551             free(controlRSetList->list.array);
6552          }
6553          free(pdcchCfg->controlResourceSetToAddModList);
6554       }
6555       free(dlBwp->pdcch_Config->choice.setup);
6556    }
6557 }
6558 /*******************************************************************
6559 *
6560 * @brief Function to free PdschTimeDomAllocationList
6561 *     where the memory allocated by aper_decoder
6562 *
6563 * @details
6564 *
6565 *    Function : freeAperDecodePdschTimeDomAllocationList
6566 *
6567 *    Functionality: Function to free PdschTimeDomAllocationList
6568 *
6569 * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
6570 * @return void
6571 *
6572 * ****************************************************************/
6573
6574
6575 void freeAperDecodePdschTimeDomAllocationList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
6576 {
6577    uint8_t arrIdx=0;
6578
6579    if(timeDomAllocList->choice.setup)
6580    {
6581       if(timeDomAllocList->choice.setup->list.array)
6582       {
6583          for(arrIdx = 0; arrIdx <timeDomAllocList->choice.setup->list.count ; arrIdx++)
6584          {
6585             free(timeDomAllocList->choice.setup->list.array[arrIdx]);
6586          }
6587          free(timeDomAllocList->choice.setup->list.array);
6588       }
6589       free(timeDomAllocList->choice.setup);
6590    }
6591 }
6592
6593 /*******************************************************************
6594 *
6595 * @brief Function to free BWPDlDedPdschConfig
6596 *        where the memory allocated by aper_decoder
6597 *
6598 * @details
6599 *
6600 *    Function : freeAperDecodeBWPDlDedPdschConfig
6601 *
6602 *    Functionality: Function to free BWPDlDedPdschConfig
6603 *
6604 * @params[in] BWP_DownlinkDedicated_t *dlBwp
6605 * @return void
6606 *
6607 * ****************************************************************/
6608
6609
6610 void freeAperDecodeBWPDlDedPdschConfig(BWP_DownlinkDedicated_t *dlBwp)
6611 {
6612    struct PDSCH_Config *pdschCfg=NULLP;
6613    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
6614    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
6615    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
6616
6617    if(dlBwp->pdsch_Config->choice.setup)
6618    {
6619       pdschCfg=dlBwp->pdsch_Config->choice.setup;
6620       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
6621       {
6622          if(pdschCfg->pdsch_TimeDomainAllocationList)
6623          {
6624             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
6625             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
6626             {
6627                prbBndlType=&pdschCfg->prb_BundlingType;
6628                free(prbBndlType->choice.staticBundling);
6629                free(pdschCfg->maxNrofCodeWordsScheduledByDCI);
6630             }
6631             freeAperDecodePdschTimeDomAllocationList(timeDomAllocList);
6632             free(pdschCfg->pdsch_TimeDomainAllocationList);
6633          }
6634          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
6635          if(dmrsDlCfg->choice.setup)
6636          {
6637             free(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition);
6638             free(dmrsDlCfg->choice.setup);
6639          }
6640          free(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA);
6641       }
6642       free(dlBwp->pdsch_Config->choice.setup);
6643    }
6644 }
6645 /*******************************************************************
6646 *
6647 * @brief Function to free PuschTimeDomAllocListCfg
6648                  where the memory allocated by aper_decoder
6649 *
6650 * @details
6651 *
6652 *    Function : freeAperDecodePuschTimeDomAllocListCfg
6653 *
6654 *    Functionality: Function to free PuschTimeDomAllocListCfg
6655 *
6656 * @params[in] PUSCH_Config_t *puschCfg
6657 * @return void
6658 *
6659 * ****************************************************************/
6660
6661
6662 void freeAperDecodePuschTimeDomAllocListCfg(PUSCH_Config_t *puschCfg)
6663 {
6664    uint8_t arrIdx=0;
6665    uint8_t arrIdx1=0;
6666    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
6667
6668    if(puschCfg->pusch_TimeDomainAllocationList)
6669    {
6670       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
6671       if(timeDomAllocList_t->choice.setup)
6672       {
6673          if(timeDomAllocList_t->choice.setup->list.array)
6674          {
6675             free(timeDomAllocList_t->choice.setup->list.array[arrIdx1]->k2);
6676             for(arrIdx = 0; arrIdx<timeDomAllocList_t->choice.setup->list.count; arrIdx++)
6677             {
6678                free(timeDomAllocList_t->choice.setup->list.array[arrIdx]);
6679             }
6680             free(timeDomAllocList_t->choice.setup->list.array);
6681          }
6682          free(timeDomAllocList_t->choice.setup);
6683       }
6684       free(puschCfg->transformPrecoder);
6685       free(puschCfg->pusch_TimeDomainAllocationList);
6686    }
6687 }
6688 /*******************************************************************
6689 *
6690 * @brief Function to free InitialUlBWPConfig where memory allocated by aper_decoder
6691 *
6692 * @details
6693 *
6694 *    Function : freeAperDecodeInitialUlBWPConfig
6695 *
6696 *    Functionality: Function to free InitialUlBWPConfig
6697 *
6698 * @params[in]  BWP_UplinkDedicated_t *ulBwp
6699 * @return void
6700 *
6701 * ****************************************************************/
6702
6703
6704 void freeAperDecodeInitialUlBWPConfig(BWP_UplinkDedicated_t *ulBwp)
6705 {
6706    uint8_t  rSetIdx =0;
6707    uint8_t  rsrcIdx =0;
6708    SRS_Config_t   *srsCfg = NULLP;
6709    PUSCH_Config_t *puschCfg = NULLP;
6710    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
6711    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
6712    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
6713    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
6714
6715    if(ulBwp->pusch_Config)
6716    {
6717       if(ulBwp->pusch_Config->choice.setup)
6718       {
6719          puschCfg=ulBwp->pusch_Config->choice.setup;
6720          if(puschCfg->dataScramblingIdentityPUSCH)
6721          {
6722             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
6723             {
6724                freeAperDecodePuschTimeDomAllocListCfg(puschCfg);
6725                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
6726                if(dmrsUlCfg->choice.setup)
6727                {
6728                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
6729                   {
6730                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
6731                      {
6732                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0);
6733                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled);
6734                      }
6735                      free(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition);
6736                   }
6737                   free(dmrsUlCfg->choice.setup);
6738                }
6739                free(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA);
6740             }
6741             free(puschCfg->dataScramblingIdentityPUSCH);
6742          }
6743          free(ulBwp->pusch_Config->choice.setup);
6744       }
6745       free(ulBwp->pusch_Config);
6746
6747       /* Free SRS-Config */
6748       if(ulBwp->srs_Config)
6749       {
6750          if(ulBwp->srs_Config->choice.setup)
6751          {
6752             srsCfg = ulBwp->srs_Config->choice.setup;
6753
6754             /* Free Resource Set to add/mod list */
6755             if(srsCfg->srs_ResourceSetToAddModList)
6756             {
6757                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
6758                if(rsrcSetList->list.array)
6759                {
6760                   rSetIdx = 0;
6761
6762                   /* Free SRS resource Id list in this SRS resource set */
6763                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
6764                   {
6765                      rsrcIdList =
6766                         rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
6767
6768                      if(rsrcIdList->list.array)
6769                      {
6770                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count;
6771                               rsrcIdx++)
6772                         {
6773                            free(rsrcIdList->list.array[rsrcIdx]);
6774                         }
6775                         free(rsrcIdList->list.array);
6776                      }
6777                      free(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList);
6778                   }
6779
6780                   /* Free resource type info for this SRS resource set */
6781
6782                   free(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic);
6783
6784                   /* Free memory for each resource set */
6785                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
6786                   {
6787                      free(rsrcSetList->list.array[rSetIdx]);
6788                   }
6789                   free(rsrcSetList->list.array);
6790                }
6791                free(srsCfg->srs_ResourceSetToAddModList);
6792             }
6793
6794             /* Free resource to add/modd list */
6795             if(srsCfg->srs_ResourceToAddModList)
6796             {
6797                resourceList = srsCfg->srs_ResourceToAddModList;
6798                if(resourceList->list.array)
6799                {
6800                   rsrcIdx = 0;
6801
6802                   free(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2);
6803                   free(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic);
6804
6805                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
6806                   {
6807                      free(resourceList->list.array[rsrcIdx]);
6808                   }
6809                   free(resourceList->list.array);
6810                }
6811                free(srsCfg->srs_ResourceToAddModList);
6812             }
6813
6814             free(ulBwp->srs_Config->choice.setup);
6815          }
6816          free(ulBwp->srs_Config);
6817       }
6818    }
6819 }
6820 /*******************************************************************
6821 *
6822 * @brief Function to free initialUplinkBWPConfig where memory allocated by aper_decoder
6823 *
6824 * @details
6825 *
6826 *    Function : freeAperDecodeinitialUplinkBWPConfig
6827 *
6828 *    Functionality: Function to free initialUplinkBWPConfig
6829 *
6830 * @params[in] UplinkConfig_t *ulCfg
6831 * @return void
6832 *
6833 * ****************************************************************/
6834
6835
6836 void freeAperDecodeinitialUplinkBWPConfig(UplinkConfig_t *ulCfg)
6837 {
6838    BWP_UplinkDedicated_t *ulBwp=NULLP;
6839    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
6840
6841    if(ulCfg->initialUplinkBWP)
6842    {
6843       ulBwp=ulCfg->initialUplinkBWP;
6844       if(ulCfg->firstActiveUplinkBWP_Id)
6845       {
6846          if(ulCfg->pusch_ServingCellConfig)
6847          {
6848             puschCfg=ulCfg->pusch_ServingCellConfig;
6849             if(puschCfg->choice.setup)
6850             {
6851                if(puschCfg->choice.setup->ext1)
6852                {
6853                   free(puschCfg->choice.setup->ext1->processingType2Enabled);
6854                   free(puschCfg->choice.setup->ext1->maxMIMO_Layers);
6855                   free(puschCfg->choice.setup->ext1);
6856                }
6857                free(puschCfg->choice.setup);
6858             }
6859             free(ulCfg->pusch_ServingCellConfig);
6860          }
6861          free(ulCfg->firstActiveUplinkBWP_Id);
6862       }
6863       freeAperDecodeInitialUlBWPConfig(ulBwp);
6864       free(ulCfg->initialUplinkBWP);
6865    }
6866 }
6867
6868 /*******************************************************************
6869  *
6870  * @brief Function to free DuUeCfg
6871  *
6872  * @details
6873  *
6874  *    Function : freeDuUeCfg
6875  *
6876  *    Functionality: Function to free DuUeCfg
6877  *
6878  * @params[in] DuUeCfg *ueCfg
6879  * @return void
6880  *
6881  * ****************************************************************/
6882 void freeDuUeCfg(DuUeCfg *ueCfg)
6883 {
6884    uint8_t lcIdx = 0;
6885    uint8_t arrIdx = 0;
6886    SpCellConfig_t *spCellCfg = NULLP;
6887    ServingCellConfig_t *srvCellCfg = NULLP;
6888    BWP_DownlinkDedicated_t *dlBwp = NULLP;
6889    MAC_CellGroupConfig_t *macCellGrpCfg = NULLP;
6890    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
6891    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList = NULLP;
6892    struct RLC_Config *rlcConfig = NULLP;
6893    struct LogicalChannelConfig *macLcConfig = NULLP;
6894    struct SchedulingRequestConfig *schedulingRequestConfig = NULLP;
6895    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList = NULLP;
6896    struct TAG_Config *tagConfig = NULLP;
6897    struct TAG_Config__tag_ToAddModList *tagList = NULLP;
6898    struct MAC_CellGroupConfig__phr_Config *phrConfig = NULLP;
6899    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg = NULLP;
6900    CellGroupConfigRrc_t *cellGrpCfg = ueCfg->cellGrpCfg;
6901
6902    if(ueCfg->ueNrCapability)
6903    {
6904       freeAperDecodeUeNrCapability(ueCfg->ueNrCapability);
6905       DU_FREE(ueCfg->ueNrCapability, sizeof(UE_NR_Capability_t));
6906       ueCfg->ueNrCapability = NULLP;
6907    }
6908
6909    if(ueCfg->cellGrpCfg)
6910    {
6911
6912       rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6913       if(rlcBearerList)
6914       {
6915          if(rlcBearerList->list.array)
6916          {
6917             for(arrIdx=0; arrIdx<rlcBearerList->list.count; arrIdx++)
6918             {
6919                if(rlcBearerList->list.array[arrIdx])
6920                {
6921                   rlcConfig   = rlcBearerList->list.array[arrIdx]->rlc_Config;
6922                   macLcConfig = rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig;
6923
6924                   if(rlcBearerList->list.array[arrIdx]->servedRadioBearer)
6925                   {
6926                      free(rlcBearerList->list.array[arrIdx]->servedRadioBearer);
6927                   }
6928                   if(rlcConfig)
6929                   {
6930                      if(rlcConfig->choice.am)
6931                      {
6932                         free(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength);
6933                         free(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength);
6934                         free(rlcConfig->choice.am);
6935                      }
6936                      free(rlcBearerList->list.array[arrIdx]->rlc_Config);
6937                   }
6938                   if(macLcConfig)
6939                   {
6940                      if(macLcConfig->ul_SpecificParameters)
6941                      {
6942                         free(macLcConfig->ul_SpecificParameters->schedulingRequestID);
6943                         free(macLcConfig->ul_SpecificParameters->logicalChannelGroup);
6944                         free(macLcConfig->ul_SpecificParameters);
6945                      }
6946                      free(rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig);
6947                   }
6948                   free(rlcBearerList->list.array[arrIdx]);
6949                }
6950             }
6951             free(rlcBearerList->list.array);
6952          }
6953          free(cellGrpCfg->rlc_BearerToAddModList);
6954       }
6955
6956       macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
6957       if(macCellGrpCfg)
6958       {
6959          schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
6960          if(schedulingRequestConfig)
6961          {
6962             schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
6963             if(schReqList)
6964             {
6965                if(schReqList->list.array)
6966                {
6967                   for(arrIdx=0;arrIdx<schReqList->list.count; arrIdx++)
6968                   {
6969                      if(schReqList->list.array[arrIdx])
6970                      {
6971                         free(schReqList->list.array[arrIdx]->sr_ProhibitTimer);
6972                         free(schReqList->list.array[arrIdx]);
6973                      }
6974                   }
6975                   free(schReqList->list.array);
6976                }
6977                free(schedulingRequestConfig->schedulingRequestToAddModList);
6978             }
6979             free(macCellGrpCfg->schedulingRequestConfig);
6980          }
6981          if(macCellGrpCfg->bsr_Config)
6982          {
6983             free(macCellGrpCfg->bsr_Config);
6984          }
6985          tagConfig = macCellGrpCfg->tag_Config;
6986          if(tagConfig)
6987          {
6988             tagList = tagConfig->tag_ToAddModList;
6989             if(tagList)
6990             {
6991                if(tagList->list.array)
6992                {
6993                   for(arrIdx=0; arrIdx<tagList->list.count; arrIdx++)
6994                   {
6995                      free(tagList->list.array[arrIdx]);
6996                   }
6997                   free(tagList->list.array);
6998                }
6999                free(tagConfig->tag_ToAddModList);
7000             }
7001             free(tagConfig);
7002          }
7003
7004          phrConfig = macCellGrpCfg->phr_Config;
7005          if(phrConfig)
7006          {
7007             free(phrConfig->choice.setup);
7008             free(phrConfig);
7009          }
7010
7011          free(macCellGrpCfg);
7012       }
7013
7014       phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
7015       if(phyCellGrpCfg)
7016       {
7017          free(phyCellGrpCfg->p_NR_FR1);
7018          free(phyCellGrpCfg);
7019       }
7020
7021       spCellCfg = cellGrpCfg->spCellConfig;
7022       if(spCellCfg)
7023       {
7024          if(spCellCfg->servCellIndex)
7025          {
7026             if(spCellCfg->rlmInSyncOutOfSyncThreshold)
7027             {
7028                if(spCellCfg->spCellConfigDedicated)
7029                {
7030                   srvCellCfg = spCellCfg->spCellConfigDedicated;
7031                   if(srvCellCfg->initialDownlinkBWP)
7032                   {
7033                      dlBwp = srvCellCfg->initialDownlinkBWP;
7034                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
7035                      {
7036                         if(srvCellCfg->defaultDownlinkBWP_Id)
7037                         {
7038                            if(srvCellCfg->uplinkConfig)
7039                            {
7040
7041                               if(srvCellCfg->pdsch_ServingCellConfig)
7042                               {
7043                                  pdschCfg=
7044                                     srvCellCfg->pdsch_ServingCellConfig;
7045                                  if(pdschCfg->choice.setup)
7046                                  {
7047
7048                                     free(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH);
7049                                     free(pdschCfg->choice.setup);
7050                                  }
7051
7052                                  free(srvCellCfg->pdsch_ServingCellConfig);
7053                               }
7054
7055                               freeAperDecodeinitialUplinkBWPConfig(srvCellCfg->uplinkConfig);
7056                               free(srvCellCfg->uplinkConfig);
7057                            }
7058                            free(srvCellCfg->defaultDownlinkBWP_Id);
7059                         }
7060
7061                         free(srvCellCfg->firstActiveDownlinkBWP_Id);
7062                      }
7063                      if(dlBwp->pdcch_Config)
7064                      {
7065                         if(dlBwp->pdsch_Config)
7066                         {
7067                            freeAperDecodeBWPDlDedPdschConfig(dlBwp);
7068                            free(dlBwp->pdsch_Config);
7069                         }
7070                         freeAperDecodeBWPDlDedPdcchConfig(dlBwp);
7071                         free(dlBwp->pdcch_Config);
7072                      }
7073                      free(srvCellCfg->initialDownlinkBWP);
7074                   }
7075
7076                   free(spCellCfg->spCellConfigDedicated);
7077                }
7078                free(spCellCfg->rlmInSyncOutOfSyncThreshold);
7079             }
7080             free(spCellCfg->servCellIndex);
7081          }
7082          free(spCellCfg);
7083       }
7084       DU_FREE(ueCfg->cellGrpCfg, sizeof(CellGroupConfigRrc_t));
7085       ueCfg->cellGrpCfg = NULLP;
7086    }
7087    if(ueCfg->ambrCfg)
7088    {
7089       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->ambrCfg, sizeof(AmbrCfg));
7090    }
7091    for(lcIdx = 0; lcIdx < ueCfg->numRlcLcs; lcIdx++)
7092    {
7093       freeRlcLcCfg(&ueCfg->rlcLcCfg[lcIdx]);
7094    }
7095    for(lcIdx = 0; lcIdx < ueCfg->numMacLcs; lcIdx++)
7096    {
7097       freeMacLcCfg(&ueCfg->macLcCfg[lcIdx]);
7098    }
7099    for(lcIdx = 0; lcIdx < ueCfg->numDrb; lcIdx++)
7100    {
7101       DU_FREE(ueCfg->upTnlInfo[lcIdx].tnlCfg1, sizeof(GtpTnlCfg));
7102    }
7103 }
7104
7105 /*******************************************************************
7106  *
7107  * @brief Function to free UecontextSetupDb
7108  *
7109  * @details
7110  *
7111  *    Function : freeF1UeDb
7112  *
7113  *    Functionality: Function to free UecontextSetupDb
7114  *
7115  * @params[in] UecontextSetupDb *
7116  * @return void
7117  *
7118  * ****************************************************************/
7119
7120 void freeF1UeDb(F1UeContextSetupDb *f1UeDb)
7121 {
7122
7123    if(f1UeDb->dlRrcMsg)
7124    {
7125       if(f1UeDb->dlRrcMsg->rrcMsgPdu)
7126       {
7127         //DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,\
7128                f1UeDb->dlRrcMsg->rrcMsgPdu, f1UeDb->dlRrcMsg->rrcMsgSize);
7129       }
7130       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
7131    }
7132    freeDuUeCfg(&f1UeDb->duUeCfg);
7133    memset(f1UeDb, 0, sizeof(F1UeContextSetupDb));
7134    DU_FREE(f1UeDb, sizeof(F1UeContextSetupDb));
7135 }
7136
7137 /*******************************************************************
7138  *
7139  * @brief Function to build Am cfg Info
7140  *
7141  * @details
7142  *
7143  *    Function : extractRlcAmCfg
7144  *
7145  *    Functionality: Function to build Am cfg Info
7146  *
7147  * @params[in] AmBearerCfg *
7148  *             void *
7149  *
7150  * @return ROK/RFAILED
7151  *
7152  * ****************************************************************/
7153
7154 void extractRlcAmCfg(AmBearerCfg *amCfgToSet, struct RLC_Config__am *rlcAmCfg)
7155 {
7156    if(rlcAmCfg)
7157    {
7158       /* UL AM */
7159       if(rlcAmCfg->dl_AM_RLC.sn_FieldLength)
7160       {
7161          amCfgToSet->ulAmCfg.snLenUl = *(rlcAmCfg->dl_AM_RLC.sn_FieldLength);
7162          /*TODO: Check the timer value when sent by real CU */
7163          amCfgToSet->ulAmCfg.reAssemTmr = rlcAmCfg->dl_AM_RLC.t_Reassembly;
7164          amCfgToSet->ulAmCfg.statProhTmr = rlcAmCfg->dl_AM_RLC.t_StatusProhibit;
7165       }
7166
7167       /* DL AM */
7168       if(rlcAmCfg->ul_AM_RLC.sn_FieldLength)
7169       {
7170          amCfgToSet->dlAmCfg.snLenDl = *(rlcAmCfg->ul_AM_RLC.sn_FieldLength);
7171          amCfgToSet->dlAmCfg.pollRetxTmr = rlcAmCfg->ul_AM_RLC.t_PollRetransmit;
7172          amCfgToSet->dlAmCfg.pollPdu   = rlcAmCfg->ul_AM_RLC.pollPDU;
7173          amCfgToSet->dlAmCfg.pollByte  = rlcAmCfg->ul_AM_RLC.pollByte;
7174          amCfgToSet->dlAmCfg.maxRetxTh = rlcAmCfg->ul_AM_RLC.maxRetxThreshold;
7175       }
7176    }
7177 }
7178
7179 /*******************************************************************
7180  *
7181  * @brief Function to build Um Bi Info
7182  *
7183  * @details
7184  *
7185  *    Function : extractRlcUmBiCfg
7186  *
7187  *    Functionality: Function to build Um Bi Info
7188  *
7189  * @params[in] UmBiDirBearerCfg *
7190  *             void *
7191  *
7192  * @return ROK/RFAILED
7193  *
7194  * ****************************************************************/
7195
7196 void extractRlcUmBiCfg(UmBiDirBearerCfg *umBiCfgToSet, struct RLC_Config__um_Bi_Directional *rlcBiCfg)
7197 {
7198    if(rlcBiCfg)
7199    {
7200       /* UL UM BI DIR Cfg */
7201       if(rlcBiCfg->dl_UM_RLC.sn_FieldLength)
7202       {
7203          umBiCfgToSet->ulUmCfg.snLenUlUm  = *(rlcBiCfg->dl_UM_RLC.sn_FieldLength);
7204          umBiCfgToSet->ulUmCfg.reAssemTmr = rlcBiCfg->dl_UM_RLC.t_Reassembly;
7205       }
7206
7207       /* DL UM BI DIR Cfg */
7208       if(rlcBiCfg->ul_UM_RLC.sn_FieldLength)
7209          umBiCfgToSet->dlUmCfg.snLenDlUm  = *(rlcBiCfg->ul_UM_RLC.sn_FieldLength);
7210    }
7211 }
7212
7213 /*******************************************************************
7214  *
7215  * @brief Function to build Um Ul Info
7216  *
7217  * @details
7218  *
7219  *    Function : extractRlcUmUlCfg
7220  *
7221  *    Functionality: Function to build Um Ul Info
7222  *
7223  * @params[in] UmUniDirUlBearerCfg *
7224  *             void *
7225  *
7226  * @return ROK/RFAILED
7227  *
7228  * ****************************************************************/
7229
7230 void extractRlcUmUlCfg(UmUniDirUlBearerCfg *umUlCfgToSet, struct RLC_Config__um_Uni_Directional_DL *umUlCfg)
7231 {
7232    if(umUlCfg)
7233    {
7234       if(umUlCfg->dl_UM_RLC.sn_FieldLength)
7235       {
7236          umUlCfgToSet->ulUmCfg.snLenUlUm  = *(umUlCfg->dl_UM_RLC.sn_FieldLength);
7237          umUlCfgToSet->ulUmCfg.reAssemTmr = umUlCfg->dl_UM_RLC.t_Reassembly;
7238       }
7239    }
7240 }
7241
7242 /*******************************************************************
7243  *
7244  * @brief Function to build Um Uni Dl Info
7245  *
7246  * @details
7247  *
7248  *    Function : extractRlcUmDlCfg
7249  *
7250  *    Functionality: Function to build Um Uni Dl Info
7251  *
7252  * @params[in] UmUniDirDlBearerCfg *
7253  *             void *
7254  *
7255  * @return ROK/RFAILED
7256  *
7257  * ****************************************************************/
7258 void extractRlcUmDlCfg(UmUniDirDlBearerCfg *umDlCfgToSet, struct RLC_Config__um_Uni_Directional_UL *umDlCfg)
7259 {
7260    if(umDlCfg)
7261    {
7262       if(umDlCfg->ul_UM_RLC.sn_FieldLength)
7263          umDlCfgToSet->dlUmCfg.snLenDlUm  = *(umDlCfg->ul_UM_RLC.sn_FieldLength);
7264    }
7265 }
7266
7267 /*******************************************************************
7268  *
7269  * @brief Function to extractRlcModeCfg
7270  *
7271  * @details
7272  *
7273  *    Function : extractRlcModeCfg
7274  *
7275  *    Functionality: Function to extractRlcModeCfg
7276  *
7277  * @params[in] RLC_Config_t *
7278  *             RlcBearerCfg *
7279  *             void  *
7280  * @return ROK/RFAILED
7281  *
7282  * ****************************************************************/
7283 void extractRlcModeCfg(uint8_t rlcMode, RlcBearerCfg *rlcDbCfg, RLC_Config_t *lcCfg)
7284 {
7285    if(lcCfg)
7286    {
7287       switch(rlcMode)
7288       {
7289          case RLC_AM :
7290             {
7291                if(lcCfg->choice.am)
7292                {
7293                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.amCfg, sizeof(AmBearerCfg));
7294                   if(rlcDbCfg->u.amCfg)
7295                      extractRlcAmCfg(rlcDbCfg->u.amCfg, lcCfg->choice.am);
7296                }
7297                break;
7298             }
7299          case RLC_UM_BI_DIRECTIONAL :
7300             {
7301                if(lcCfg->choice.um_Bi_Directional)
7302                {
7303                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
7304                   if(rlcDbCfg->u.umBiDirCfg)
7305                      extractRlcUmBiCfg(rlcDbCfg->u.umBiDirCfg, lcCfg->choice.um_Bi_Directional);
7306                }
7307                break;
7308             }
7309          case RLC_UM_UNI_DIRECTIONAL_UL :
7310             {
7311                if(lcCfg->choice.um_Uni_Directional_DL)
7312                {
7313                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
7314                   if(rlcDbCfg->u.umUniDirUlCfg)
7315                      extractRlcUmUlCfg(rlcDbCfg->u.umUniDirUlCfg, lcCfg->choice.um_Uni_Directional_DL);
7316                }
7317                break;
7318             }
7319          case RLC_UM_UNI_DIRECTIONAL_DL :
7320             {
7321                if(lcCfg->choice.um_Uni_Directional_UL)
7322                {
7323                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
7324                   if(rlcDbCfg->u.umUniDirDlCfg)
7325                      extractRlcUmDlCfg(rlcDbCfg->u.umUniDirDlCfg, lcCfg->choice.um_Uni_Directional_UL);
7326                }
7327                break;
7328             }
7329          default:
7330             DU_LOG("\nERROR  -->  DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
7331             break;
7332       }
7333    }
7334 }
7335
7336 /*******************************************************************
7337  *
7338  * @brief Function to extract extractUlLcCfg
7339  *
7340  * @details
7341  *
7342  *    Function : extractUlLcCfg
7343  *
7344  *    Functionality: Function to extract extractUlLcCfg
7345  *
7346  * @params[in] UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg
7347  * @return void
7348  *
7349  * ****************************************************************/
7350
7351 void extractUlLcCfg(UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg)
7352 {
7353    if(ulLcCfg)
7354    {
7355       if(ulLcCfg->ul_SpecificParameters)
7356       {
7357          f1UlLcCfg->priority = \
7358             ulLcCfg->ul_SpecificParameters->priority;
7359       if(ulLcCfg->ul_SpecificParameters->logicalChannelGroup)
7360       {
7361          f1UlLcCfg->lcGroup = \
7362            *(ulLcCfg->ul_SpecificParameters->logicalChannelGroup);
7363       }
7364       if(ulLcCfg->ul_SpecificParameters->schedulingRequestID)
7365       {
7366          f1UlLcCfg->schReqId = \
7367            *(ulLcCfg->ul_SpecificParameters->schedulingRequestID);
7368       }
7369       f1UlLcCfg->pbr = \
7370          ulLcCfg->ul_SpecificParameters->prioritisedBitRate;
7371       f1UlLcCfg->bsd = \
7372          ulLcCfg->ul_SpecificParameters->bucketSizeDuration;
7373       }
7374    }
7375 }
7376
7377 /*******************************************************************
7378 *
7379 * @brief Function to extract Snssai Cfg Info from CU
7380 *
7381 * @details
7382 *
7383 *    Function : extractDrbSnssaiCfg
7384 *
7385 *    Functionality: Function to extract Drb Snssai Cfg Info from CU
7386 *
7387 * @params[in] DRB_Information_t *drbInfo, Snssai  *snssai
7388 * @return ROK/RFAILED
7389 *
7390 * ****************************************************************/
7391
7392 uint8_t extractDrbSnssaiCfg(SNSSAI_t *RecvSnssai, Snssai **snssaiToBeShared)
7393 {
7394    if(!(*snssaiToBeShared))
7395    {
7396       DU_ALLOC_SHRABL_BUF((*snssaiToBeShared), sizeof(Snssai));
7397       if(snssaiToBeShared == NULLP)
7398       {
7399          DU_LOG("\nERROR  -->  DUAPP : extractDrbSnssaiCfg(): Memory failed at allocating for SNSSAI ");
7400          return RFAILED;
7401       }
7402    }
7403    if(RecvSnssai)
7404    {
7405       memcpy(&(*snssaiToBeShared)->sst, RecvSnssai->sST.buf, RecvSnssai->sST.size);
7406       if(RecvSnssai->sD)
7407       {
7408          memcpy((*snssaiToBeShared)->sd, RecvSnssai->sD->buf,  RecvSnssai->sD->size);
7409       }
7410       else
7411       {
7412          DU_LOG("\nERROR  -->  DUAPP : extractDrbSnssaiCfg(): Received Null pointer of Snssai->SD");
7413          return RFAILED;
7414       }
7415    }
7416    return ROK;
7417 }
7418
7419 /*******************************************************************
7420  *
7421  * @brief Function to procRlcLcCfg
7422  *
7423  * @details
7424  *
7425  *    Function : procRlcLcCfg
7426  *
7427  *    Functionality: Function to procRlcLcCfg
7428  *
7429  * @params[in] rbId, lcId, rbType, rlcMod
7430  *             RLC_Config_t *, RlcBearerCfg * ,
7431  * @return void
7432  *
7433  * ****************************************************************/
7434
7435 void procRlcLcCfg(uint8_t rbId, uint8_t lcId, uint8_t rbType, uint8_t rlcMode,\
7436    uint8_t configType, RLC_Config_t *f1RlcCfg, RlcBearerCfg *lcCfg, QoSInformation_t *qoSInformation)
7437 {
7438    DRB_Information_t *drbInfo;
7439
7440    lcCfg->rbId   = rbId;
7441    lcCfg->configType = configType;
7442
7443    if(rbType == RB_TYPE_SRB)
7444    {
7445       lcCfg->rbType = RB_TYPE_SRB;
7446       lcCfg->lcId   = rbId;
7447       lcCfg->lcType = LCH_DCCH;
7448       lcCfg->rlcMode = RLC_AM;
7449    }
7450    else if(rbType == RB_TYPE_DRB)
7451    {
7452       lcCfg->rbType = RB_TYPE_DRB;
7453       lcCfg->lcId   = lcId;
7454       lcCfg->lcType = LCH_DTCH;
7455       lcCfg->rlcMode = rlcMode;
7456    }
7457    if(f1RlcCfg) /* rlc mode config recived */
7458    {
7459       extractRlcModeCfg(lcCfg->rlcMode, lcCfg, f1RlcCfg);
7460    }
7461    if(qoSInformation != NULLP)
7462    {
7463       if(qoSInformation->present == QoSInformation_PR_choice_extension)
7464       {
7465          if(qoSInformation->choice.choice_extension->value.present ==\
7466                QoSInformation_ExtIEs__value_PR_DRB_Information)
7467          {
7468             drbInfo = &qoSInformation->choice.choice_extension->value.choice.DRB_Information;
7469             if(extractDrbSnssaiCfg(&drbInfo->sNSSAI, &lcCfg->snssai) != ROK)
7470             {
7471                DU_LOG("\nERROR  -->  DUAPP: Unable to extract Snssai information at procRlcLcCfg()");
7472                return RFAILED;
7473             }
7474          }
7475       }
7476    }
7477 }
7478
7479 /*******************************************************************
7480  *
7481  * @brief Fills DrbQos Info received by CU
7482  *
7483  * @details
7484  *
7485  *    Function : extractQosInfo
7486  *
7487  *    Functionality: Fills DrbQos Info received  by CU
7488  *
7489  * @params[in] DrbQosInfo *qosToAdd,
7490  *             QoSFlowLevelQoSParameters_t *qosFlowCfg
7491  * @return void
7492  *
7493  * ****************************************************************/
7494
7495 void extractQosInfo(DrbQosInfo *qosToAdd, QoSFlowLevelQoSParameters_t *qosFlowCfg)
7496 {
7497    uint8_t qosCntIdx = 0;
7498    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
7499
7500    qosToAdd->fiveQiType = qosFlowCfg->qoS_Characteristics.present;
7501    qosToAdd->u.nonDyn5Qi.fiveQi     =\
7502                                      qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
7503    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow)
7504    {
7505       qosToAdd->u.nonDyn5Qi.avgWindow = \
7506                                         *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
7507    }
7508    qosToAdd->u.nonDyn5Qi.maxDataBurstVol = \
7509                                            *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
7510    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel)
7511    {
7512       qosToAdd->u.nonDyn5Qi.priorLevel = \
7513                                          *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel);
7514    }
7515    qosToAdd->ngRanRetPri.priorityLevel = \
7516                                          qosFlowCfg->nGRANallocationRetentionPriority.priorityLevel;
7517    qosToAdd->ngRanRetPri.preEmptionCap = \
7518                                          qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionCapability;
7519    qosToAdd->ngRanRetPri.preEmptionVul = \
7520                                          qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionVulnerability;
7521    if(qosFlowCfg->gBR_QoS_Flow_Information)
7522    {
7523       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateDl, \
7524             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.buf, \
7525             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.size);
7526       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateUl, \
7527             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.buf, \
7528             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.size);
7529       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateDl,\
7530             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.buf, \
7531             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.size);
7532       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateUl,\
7533             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.buf, \
7534             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.size);
7535    }
7536    /*Extracting PDU_SESSION_ID*/
7537    qosIeExt = (ProtocolExtensionContainer_4624P74_t *)qosFlowCfg->iE_Extensions;
7538    if(qosIeExt)
7539    {
7540       for(qosCntIdx = 0; qosCntIdx < qosIeExt->list.count; qosCntIdx++)
7541       {
7542          if(qosIeExt->list.array[qosCntIdx]->extensionValue.present == \
7543                QoSFlowLevelQoSParameters_ExtIEs__extensionValue_PR_PDUSessionID)
7544          {
7545             qosToAdd->pduSessionId = qosIeExt->list.array[qosCntIdx]->extensionValue.choice.PDUSessionID;
7546             DU_LOG("\nDEBUG -->  DU_F1AP : extractQosInfo: PDU SessionID:%d",qosToAdd->pduSessionId);
7547          }
7548       }
7549    }
7550    qosToAdd->ulPduSessAggMaxBitRate = 0;
7551 }
7552
7553 /*******************************************************************
7554  *
7555  * @brief Function to extract GTP Tunnel Info from CU
7556  *
7557  * @details
7558  *
7559  *    Function : extractUpTnlInfo
7560  *
7561  *    Functionality: Function to extract GTP Tunnel Info from CU
7562  *
7563  * @params[in] F1AP message
7564  * @return ROK/RFAILED
7565  *
7566  * ****************************************************************/
7567
7568 uint8_t extractUpTnlInfo(uint8_t drbId, uint8_t configType,\
7569    ULUPTNLInformation_ToBeSetup_List_t *tnlInfo, UpTnlCfg *upTnlInfo)
7570 {
7571    uint8_t tnlIdx;
7572    uint32_t ipv4_du = 0;
7573    GTPTunnel_t *gtpTunnel = NULLP;
7574
7575    upTnlInfo->drbId = drbId;
7576    upTnlInfo->configType = configType;
7577 #ifdef O1_ENABLE
7578    cmInetAddr((S8*)g_cfg.DU_IPV4_Addr, &ipv4_du);
7579 #else
7580    cmInetAddr((char *)DU_IP_V4_ADDR, &ipv4_du);
7581 #endif
7582
7583    for(tnlIdx=0; tnlIdx < tnlInfo->list.count; tnlIdx++)
7584    {
7585       if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
7586       {
7587          if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel)
7588          {
7589             gtpTunnel = tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel;
7590             DU_ALLOC(upTnlInfo->tnlCfg1, sizeof(GtpTnlCfg));
7591             if(upTnlInfo->tnlCfg1 == NULLP)
7592             {
7593                DU_LOG("\nERROR  -->  F1AP : extractUpTnlInfo: Failed to allocate mmeory for tunnel cfg 1");
7594                return RFAILED;
7595             }
7596             bitStringToInt(&gtpTunnel->transportLayerAddress, &upTnlInfo->tnlCfg1->ulTnlAddress);
7597             upTnlInfo->tnlCfg1->dlTnlAddress = ipv4_du;
7598             if(gtpTunnel->gTP_TEID.size > 0)
7599             {
7600                teIdStringToInt(gtpTunnel->gTP_TEID.buf, &upTnlInfo->tnlCfg1->teId);
7601             }
7602          }
7603          break;
7604       }
7605    }
7606    return ROK;
7607 }
7608
7609 /*******************************************************************
7610 *
7611 * @brief Function to extract Drb Qos Cfg Info from CU
7612 *
7613 * @details
7614 *
7615 *    Function : extractDrbQosCfg
7616 *
7617 *    Functionality: Function to extract Drb Qos Cfg Info from CU
7618 *
7619 * @params[in] DRB_Information_t *drbInfo, LcCfg *macLcToAdd
7620 * @return ROK/RFAILED
7621 *
7622 * ****************************************************************/
7623
7624 uint8_t extractDrbQosCfg(DRB_Information_t *drbInfo, LcCfg *macLcToAdd )
7625 {
7626    if(!macLcToAdd->drbQos)
7627    {
7628       DU_ALLOC_SHRABL_BUF(macLcToAdd->drbQos, sizeof(DrbQosInfo));
7629       if(macLcToAdd->drbQos == NULLP)
7630       {
7631          DU_LOG("\nERROR  -->  DUAPP:Memory failed at allocating DrbQos at extractDrbQosCfg()");
7632          return RFAILED;
7633       }
7634
7635    }
7636    if(drbInfo->dRB_QoS.qoS_Characteristics.present == QoS_Characteristics_PR_non_Dynamic_5QI)
7637    {
7638       extractQosInfo(macLcToAdd->drbQos, &drbInfo->dRB_QoS);
7639       macLcToAdd->dlLcCfg.lcp = macLcToAdd->drbQos->ngRanRetPri.priorityLevel;
7640    }
7641    if(extractDrbSnssaiCfg(&drbInfo->sNSSAI, &macLcToAdd->snssai) != ROK)
7642    {
7643       DU_LOG("\nERROR  -->  DUAPP: Unable to extract Snssai information  at extractDrbQosCfg()");
7644       return RFAILED;
7645    }
7646    return ROK;
7647 }
7648 /*******************************************************************
7649  *
7650  * @brief Function to extract DRB info received from CU
7651  *
7652  * @details
7653  *
7654  *    Function : extractDrbCfg
7655  *
7656  *    Functionality: Function to extract DRB info received from CU
7657  *
7658  * @params[in] F1AP message
7659  * @return void
7660  *
7661  * ****************************************************************/
7662 uint8_t extractDrbCfg(DRBs_ToBeSetup_Item_t *drbItem, DRBs_ToBeSetupMod_Item_t *drbSetupModItem,\
7663 DRBs_ToBeModified_Item_t *drbModItem,  LcCfg *macLcToAdd, UpTnlCfg *upTnlInfo)
7664 {
7665    DRB_Information_t *drbInfo = NULLP;
7666
7667    if(drbItem != NULLP)
7668    {
7669       if(extractUpTnlInfo(drbItem->dRBID, CONFIG_ADD, &drbItem->uLUPTNLInformation_ToBeSetup_List, upTnlInfo) != ROK)
7670       {
7671          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7672          return RFAILED;
7673       }
7674       if(drbItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7675       {
7676          if(drbItem->qoSInformation.choice.choice_extension->value.present == QoSInformation_ExtIEs__value_PR_DRB_Information)
7677          {
7678             drbInfo = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7679             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7680             {
7681                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7682                return RFAILED;
7683             }
7684          }
7685       }
7686    }
7687    else if(drbSetupModItem != NULLP)
7688    {
7689       if(extractUpTnlInfo(drbSetupModItem->dRBID, CONFIG_ADD, &drbSetupModItem->uLUPTNLInformation_ToBeSetup_List,\
7690       upTnlInfo) != ROK)
7691       {
7692          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7693          return RFAILED;
7694       }
7695       if(drbSetupModItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7696       {
7697          if(drbSetupModItem->qoSInformation.choice.choice_extension->value.present ==\
7698          QoSInformation_ExtIEs__value_PR_DRB_Information)
7699          {
7700             drbInfo = &drbSetupModItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7701             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7702             {
7703                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7704                return RFAILED;
7705             }
7706
7707          }
7708       }
7709    }
7710    else if(drbModItem != NULLP)
7711    {
7712       if(extractUpTnlInfo(drbModItem->dRBID, CONFIG_MOD, &drbModItem->uLUPTNLInformation_ToBeSetup_List,\
7713       upTnlInfo) != ROK)
7714       {
7715          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7716          return RFAILED;
7717       }
7718       if(drbModItem->qoSInformation != NULLP)
7719       {
7720          if(drbModItem->qoSInformation->present == QoSInformation_PR_choice_extension)
7721          {
7722             if(drbModItem->qoSInformation->choice.choice_extension->value.present ==\
7723                   QoSInformation_ExtIEs__value_PR_DRB_Information)
7724             {
7725                drbInfo = &drbModItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information;
7726                if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7727                {
7728                   DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7729                   return RFAILED;
7730                }
7731
7732             }
7733          }
7734       }
7735    }
7736    return ROK;
7737 }
7738
7739 /*******************************************************************
7740  *
7741  * @brief Function to extract RB info received from CU
7742  *
7743  * @details
7744  *
7745  *    Function : extractMacRbCfg
7746  *
7747  *    Functionality: Function to extract RB info received from CU
7748  *
7749  * @params[in] F1AP message
7750  * @return ROK/RFAILED
7751  *
7752  * ****************************************************************/
7753
7754 uint8_t extractMacRbCfg(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbCfg,\
7755 DRBs_ToBeSetupMod_Item_t *drbSetupModCfg,  DRBs_ToBeModified_Item_t *drbModCfg, LogicalChannelConfig_t *ulLcCfg, LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7756 {
7757    if(drbCfg != NULLP)
7758    {
7759       if(extractDrbCfg(drbCfg, NULL, NULL, lcCfg, upTnlInfo) != ROK)
7760       {
7761          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7762          return RFAILED;
7763       }
7764    }
7765    else if(drbSetupModCfg != NULLP)
7766    {
7767       if(extractDrbCfg(NULL, drbSetupModCfg, NULL, lcCfg, upTnlInfo) != ROK)
7768       {
7769          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7770          return RFAILED;
7771       }
7772    }
7773    else if(drbModCfg != NULLP)
7774    {
7775       if(extractDrbCfg(NULL, NULL, drbModCfg, lcCfg, upTnlInfo) != ROK)
7776       {
7777          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7778          return RFAILED;
7779       }
7780    }
7781    else
7782    {
7783       lcCfg->drbQos = NULLP;
7784       lcCfg->snssai = NULLP;
7785       if(lcCfg->lcId == SRB2_LCID)
7786          lcCfg->dlLcCfg.lcp = LC_PRIORITY_3;
7787       else
7788          lcCfg->dlLcCfg.lcp = LC_PRIORITY_1;
7789    }
7790    if(ulLcCfg)
7791    {
7792       lcCfg->ulLcCfgPres = true;
7793       extractUlLcCfg(&lcCfg->ulLcCfg, ulLcCfg);
7794    }
7795    else
7796       lcCfg->ulLcCfgPres = false;
7797    return ROK;
7798 }
7799
7800 /*******************************************************************
7801  *
7802  * @brief Function processing LC config info received from CU
7803  *
7804  * @details
7805  *
7806  *    Function : procMacLcCfg
7807  *
7808  *    Functionality: Function processing LC config info received from CU
7809  *
7810  * @params[in] F1AP message
7811  * @return ROK/RFAILED
7812  *
7813  * ****************************************************************/
7814
7815 uint8_t procMacLcCfg(uint8_t lcId, uint8_t rbType, uint8_t configType, DRBs_ToBeSetup_Item_t *drbItem,\
7816 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, LogicalChannelConfig_t *ulLcCfg,\
7817 LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7818 {
7819    uint8_t ret = ROK;
7820
7821    lcCfg->lcId = lcId;
7822    lcCfg->configType = configType;
7823    if(rbType == RB_TYPE_SRB)
7824    {
7825       ret = extractMacRbCfg(lcId, NULL, NULL, NULL, ulLcCfg, lcCfg, NULL);
7826    }
7827    else if(rbType == RB_TYPE_DRB)
7828    {
7829       if(drbItem != NULL)
7830         ret = extractMacRbCfg(lcId, drbItem, NULL, NULL, ulLcCfg, lcCfg, upTnlInfo);
7831       else if(drbSetupModItem != NULL)
7832         ret = extractMacRbCfg(lcId, NULL, drbSetupModItem, NULL, ulLcCfg, lcCfg, upTnlInfo);
7833       else if(drbModItem != NULL)
7834         ret = extractMacRbCfg(lcId, NULL, NULL, drbModItem, ulLcCfg, lcCfg, upTnlInfo);
7835    }
7836    return ret;
7837 }
7838
7839 /*******************************************************************
7840  *
7841  * @brief Function to extract Rlc cfg To Add/Mod in CellGrp Info
7842  *
7843  * @details
7844  *
7845  *    Function : extractRlcCfgToAddMod
7846  *
7847  *    Functionality: Function to extract Rlc cfg To Add/Mod in CellGrp Info
7848  *
7849  * @params[in] CellGroupConfigRrc__rlc_BearerTo pointer
7850  *             DuUeCfg Pointer
7851  * @return ROK/RFAILED
7852  *
7853  * ****************************************************************/
7854
7855 uint8_t extractRlcCfgToAddMod(struct CellGroupConfigRrc__rlc_BearerToAddModList *lcCfg, DuUeCfg *ueCfgDb)
7856 {
7857   uint8_t idx, rbId, lcId, rlcMode, rbType;
7858   RLC_Config_t *f1RlcCfg = NULLP;
7859   LogicalChannelConfig_t *macUlLcCfg = NULLP;
7860
7861   for(idx = 0; idx < lcCfg->list.count; idx++)
7862   {
7863      lcId = lcCfg->list.array[idx]->logicalChannelIdentity;
7864      if(lcCfg->list.array[idx]->servedRadioBearer)
7865      {
7866         /* RadioBearer for SRB/DRB */
7867         if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7868         RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
7869         {
7870            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.srb_Identity;
7871            rbType = RB_TYPE_SRB;
7872         }
7873         else if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7874         RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
7875         {
7876            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.drb_Identity;
7877            rbType = RB_TYPE_DRB;
7878         }
7879         else
7880         {
7881            DU_LOG("\nERROR  -->  No components present in Bearer config to ADD/MOD");
7882            return RFAILED;
7883         }
7884         /* MAC UL LC Config */
7885         if(lcCfg->list.array[idx]->mac_LogicalChannelConfig)
7886         {
7887            macUlLcCfg = lcCfg->list.array[idx]->mac_LogicalChannelConfig;
7888         }
7889      }
7890      else
7891      {
7892         DU_LOG("\nERROR  -->  DUAPP: Received RadioBearer config is NULL");
7893         return RFAILED;
7894      }
7895      /* RLC Mode Config */
7896      if(lcCfg->list.array[idx]->rlc_Config)
7897      {
7898         rlcMode  = lcCfg->list.array[idx]->rlc_Config->present;
7899         f1RlcCfg = lcCfg->list.array[idx]->rlc_Config;
7900      }
7901
7902      /* Filling RLC/MAC Config*/
7903      memset(&ueCfgDb->macLcCfg[idx], 0, sizeof(LcCfg));
7904      memset(&ueCfgDb->rlcLcCfg[idx], 0, sizeof(RlcBearerCfg));
7905      procRlcLcCfg(rbId, lcId, rbType, rlcMode, CONFIG_UNKNOWN, f1RlcCfg, &(ueCfgDb->rlcLcCfg[idx]), NULLP);
7906      if(procMacLcCfg(lcId, rbType, CONFIG_UNKNOWN, NULL, NULL, NULL, macUlLcCfg, &ueCfgDb->macLcCfg[idx], NULL) != ROK)
7907      {
7908         DU_LOG("\nERROR  -->  DU APP : Failed while filling MAC LC config at extractRlcCfgToAddMod()");
7909         return RFAILED;
7910      }
7911      (ueCfgDb->numRlcLcs)++;
7912      (ueCfgDb->numMacLcs)++;
7913          DU_LOG("\nDEBUG  -> DUAPP: extractRlcCfgToAddMod:RBType:%d, DrbID: %d,lcId:%d, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
7914                             rbType, rbId, lcId, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
7915   }
7916   //TODO: To send the failure cause in UeContextSetupRsp
7917   return ROK;
7918 }
7919
7920 /*******************************************************************
7921  *
7922  * @brief DeAlloc pdsch serv cell config info
7923  *
7924  * @details
7925  *
7926  *    Function : freeMacPdschServCellInfo
7927  *
7928  *    Functionality: DeAlloc pdsch serv cell config info
7929  *
7930  * @params[in] PdschServCellCfg pointer
7931  * @return void
7932  *
7933  * ****************************************************************/
7934
7935 void freeMacPdschServCellInfo(PdschServCellCfg *pdsch)
7936 {
7937    if(pdsch->xOverhead)
7938    {
7939       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->xOverhead, sizeof(PdschXOverhead));
7940    }
7941    if(pdsch->codeBlkGrpFlushInd)
7942    {
7943       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->codeBlkGrpFlushInd, sizeof(bool));
7944    }
7945    if(pdsch->maxCodeBlkGrpPerTb)
7946    {
7947       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
7948    }
7949    if(pdsch->maxMimoLayers)
7950    {
7951       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxMimoLayers, sizeof(uint8_t));
7952    }
7953 }
7954
7955 /*******************************************************************
7956  *
7957  * @brief Free Serving cell Info
7958  *
7959  * @details
7960  *
7961  *    Function : freeMacServingCellInfo
7962  *
7963  *    Functionality: Free Serving cell Info
7964  *
7965  * @params[in] ServCellCfgInfo *srvCellCfg
7966  * @return void
7967  *
7968  * ****************************************************************/
7969 void freeMacServingCellInfo(ServCellCfgInfo *srvCellCfg)
7970 {
7971    uint8_t timeDomRsrcIdx;
7972
7973    if(srvCellCfg->initDlBwp.pdschPresent)
7974    {
7975       for(timeDomRsrcIdx = 0; timeDomRsrcIdx < srvCellCfg->initDlBwp.pdschCfg.numTimeDomRsrcAlloc; timeDomRsrcIdx++)
7976       {
7977          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, \
7978             srvCellCfg->initDlBwp.pdschCfg.timeDomRsrcAllociList[timeDomRsrcIdx].k0, sizeof(uint8_t));
7979       }
7980    }
7981
7982    freeMacPdschServCellInfo(&srvCellCfg->pdschServCellCfg);
7983    if(srvCellCfg->bwpInactivityTmr)
7984    {
7985       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
7986    }
7987
7988    if(srvCellCfg->initUlBwp.pucchPresent)
7989    {
7990       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->initUlBwp.pucchCfg.dlDataToUlAck, sizeof(PucchDlDataToUlAck));
7991    }
7992 }
7993
7994 /*******************************************************************
7995  *
7996  * @brief Free cell Grp Cfg Info
7997  *
7998  * @details
7999  *
8000  *    Function : freeUeReCfgCellGrpInfo
8001  *
8002  *    Functionality: Free cell Grp Cfg Info
8003  *
8004  * @params[in] MacUeCfg*  duUeCfg
8005  * @return void
8006  *
8007  * ****************************************************************/
8008
8009 void freeUeReCfgCellGrpInfo(MacUeCfg *macUeCfg)
8010 {
8011    freeMacServingCellInfo(&macUeCfg->spCellCfg.servCellCfg);
8012 }
8013
8014 /*******************************************************************
8015  *
8016  * @brief Fills Reconfig SchReqReConfig
8017  *
8018  * @details
8019  *
8020  *    Function : extractSchReqReConfig
8021  *
8022  *    Functionality: Fills Reconfig SchReqReConfig
8023  *
8024  * @params[in] SchedulingRequestConfig_t *cuSchedReq
8025  *             SchedReqCfg*  macSchedReq
8026  * @return void
8027  *
8028  * ****************************************************************/
8029 void extractSchReqReConfig(SchedulingRequestConfig_t *cuSchedReq, SchedReqCfg *macSchedReq)
8030 {
8031    uint8_t schReqIdx = 0;
8032    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqListToAdd = NULLP;
8033    struct SchedulingRequestConfig__schedulingRequestToReleaseList *schReqListToRel = NULLP;
8034
8035    if(cuSchedReq->schedulingRequestToAddModList)
8036    {
8037       schReqListToAdd = cuSchedReq->schedulingRequestToAddModList;
8038       if(schReqListToAdd->list.count)
8039       {
8040          macSchedReq->addModListCount = schReqListToAdd->list.count;
8041          for(schReqIdx = 0; schReqIdx < schReqListToAdd->list.count; schReqIdx++)
8042          {
8043             macSchedReq->addModList[schReqIdx].schedReqId = \
8044                schReqListToAdd->list.array[schReqIdx]->schedulingRequestId;
8045             macSchedReq->addModList[schReqIdx].srProhibitTmr = \
8046                *(schReqListToAdd->list.array[schReqIdx]->sr_ProhibitTimer);
8047             macSchedReq->addModList[schReqIdx].srTransMax    =\
8048                schReqListToAdd->list.array[schReqIdx]->sr_TransMax;
8049          }
8050       }
8051    }
8052    /* Scheduling Req To release */
8053    if(cuSchedReq->schedulingRequestToReleaseList)
8054    {
8055       schReqListToRel = cuSchedReq->schedulingRequestToReleaseList;
8056       if(schReqListToRel->list.count)
8057       {
8058          macSchedReq->relListCount = schReqListToRel->list.count;
8059          for(schReqIdx = 0; schReqIdx < schReqListToRel->list.count; schReqIdx++)
8060          {
8061             macSchedReq->relList[schReqIdx] = \
8062                *schReqListToRel->list.array[schReqIdx];
8063          }
8064       }
8065    }
8066 }
8067
8068 /*******************************************************************
8069  *
8070  * @brief Fills TagReconfig
8071  *
8072  * @details
8073  *
8074  *    Function : extractTagReconfig
8075  *
8076  *    Functionality: Fills extractTagReconfig
8077  *
8078  * @params[in] TAG_Config_t *cuTagCfg
8079  *             TagCfg *macTagCfg
8080  * @return void
8081  *
8082  * ****************************************************************/
8083
8084 void extractTagReconfig(TAG_Config_t *cuTagCfg, TagCfg *macTagCfg)
8085 {
8086   uint8_t tagIdx = 0;
8087   struct TAG_Config__tag_ToAddModList  *tagListToAddMod = NULLP;
8088   struct TAG_Config__tag_ToReleaseList *tagListToRel = NULLP;
8089
8090   /* Tag config to AddMod */
8091   if(cuTagCfg->tag_ToAddModList)
8092   {
8093      tagListToAddMod = cuTagCfg->tag_ToAddModList;
8094      if(tagListToAddMod->list.count)
8095      {
8096         macTagCfg->addModListCount = tagListToAddMod->list.count;
8097         for(tagIdx = 0; tagIdx < tagListToAddMod->list.count; tagIdx++)
8098         {
8099            macTagCfg->addModList[tagIdx].tagId =\
8100               tagListToAddMod->list.array[tagIdx]->tag_Id;
8101            macTagCfg->addModList[tagIdx].timeAlignTimer = \
8102
8103               tagListToAddMod->list.array[tagIdx]->timeAlignmentTimer;
8104         }
8105      }
8106   }
8107   /* Tag config to release */
8108   if(cuTagCfg->tag_ToReleaseList)
8109   {
8110      tagListToRel = cuTagCfg->tag_ToReleaseList;
8111      if(tagListToRel->list.count)
8112      {
8113         macTagCfg->relListCount = tagListToRel->list.count;
8114         for(tagIdx = 0; tagIdx < tagListToRel->list.count; tagIdx++)
8115         {
8116            macTagCfg->relList[tagIdx] = *tagListToRel->list.array[tagIdx];
8117         }
8118      }
8119   }
8120 }
8121
8122 /*******************************************************************
8123  *
8124  * @brief Fills PdcchCfg received by CU
8125  *
8126  * @details
8127  *
8128  *    Function : extractPdcchCfg
8129  *
8130  *    Functionality: Fills PdcchCfg received  by CU
8131  *
8132  * @params[in] PDCCH_Config_t *cuPdcchCfg,
8133  *             PdcchConfig *duPdcchCfg
8134  * @return void
8135  *
8136  * ****************************************************************/
8137
8138 void extractPdcchCfg(PDCCH_Config_t *cuPdcchCfg, PdcchConfig *macPdcchCfg)
8139 {
8140    uint8_t cRsetIdx = 0;
8141    uint8_t srchSpcIdx = 0;
8142
8143    struct PDCCH_Config__controlResourceSetToAddModList *cRsetToAddModList = NULLP;
8144    struct PDCCH_Config__controlResourceSetToReleaseList *cRsetToRelList = NULLP;
8145    struct PDCCH_Config__searchSpacesToAddModList *srchSpcToAddModList = NULLP;
8146    struct PDCCH_Config__searchSpacesToReleaseList *srchSpcToRelList = NULLP;
8147
8148
8149    /* Control Resource Set To Add/Mod List */
8150    if(cuPdcchCfg->controlResourceSetToAddModList)
8151    {
8152       cRsetToAddModList = cuPdcchCfg->controlResourceSetToAddModList;
8153       if(cRsetToAddModList->list.count)
8154       {
8155          macPdcchCfg->numCRsetToAddMod = cRsetToAddModList->list.count;
8156          for(cRsetIdx = 0; cRsetIdx < cRsetToAddModList->list.count; cRsetIdx++)
8157          {
8158             macPdcchCfg->cRSetToAddModList[cRsetIdx].cRSetId = \
8159                cRsetToAddModList->list.array[cRsetIdx]->controlResourceSetId;
8160             //freqDomRsrcBitStringToInt(&cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources,\
8161                   macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc);
8162             memcpy(macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc, \
8163                cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources.buf,
8164                cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources.size);
8165
8166             macPdcchCfg->cRSetToAddModList[cRsetIdx].duration = \
8167                 cRsetToAddModList->list.array[cRsetIdx]->duration;
8168
8169             macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType = \
8170                cRsetToAddModList->list.array[cRsetIdx]->cce_REG_MappingType.present;
8171             if(macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType == CCE_REG_MAPPINGTYPE_PR_INTERLEAVED)
8172             {
8173                //TODO: handle the case for Interleaved
8174             }
8175             macPdcchCfg->cRSetToAddModList[cRsetIdx].precoderGranularity = \
8176                 cRsetToAddModList->list.array[cRsetIdx]->precoderGranularity;
8177             if(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID)
8178             {
8179                macPdcchCfg->cRSetToAddModList[cRsetIdx].dmrsScramblingId= \
8180                   *(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID);
8181             }
8182          }
8183       }
8184    }
8185    /* Control Resource Set To Release List */
8186    if(cuPdcchCfg->controlResourceSetToReleaseList)
8187    {
8188       cRsetToRelList = cuPdcchCfg->controlResourceSetToReleaseList;
8189       if(cRsetToRelList->list.count)
8190       {
8191          macPdcchCfg->numCRsetToRel = cRsetToRelList->list.count;
8192          for(cRsetIdx = 0; cRsetIdx < cRsetToRelList->list.count; cRsetIdx++)
8193          {
8194             macPdcchCfg->cRSetToRelList[cRsetIdx] = *(cRsetToRelList->list.array[cRsetIdx]);
8195          }
8196       }
8197    }
8198
8199    /* Search space To Add/Mod List */
8200    if(cuPdcchCfg->searchSpacesToAddModList)
8201    {
8202       srchSpcToAddModList = cuPdcchCfg->searchSpacesToAddModList;
8203       if(srchSpcToAddModList->list.count)
8204       {
8205          macPdcchCfg->numSearchSpcToAddMod = srchSpcToAddModList->list.count;
8206          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToAddModList->list.count; srchSpcIdx++)
8207          {
8208             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceId =\
8209                                                                           srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceId;
8210             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].cRSetId =\
8211                                                                     *(srchSpcToAddModList->list.array[srchSpcIdx]->controlResourceSetId);
8212             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset)
8213             {
8214                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset =\
8215                                                                                          srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset->present;
8216             }
8217             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot)
8218             {
8219                bitStringToInt(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot,\
8220                      macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSymbolsWithinSlot);
8221             }
8222             if(srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates)
8223             {
8224                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel1 = \
8225                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel1;
8226                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel2 = \
8227                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel2;
8228                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel4 = \
8229                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel4;
8230
8231                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel8 = \
8232                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel8;
8233
8234                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel16 = \
8235                                                                                         srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel16;
8236             }
8237             if(srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType)
8238             {
8239                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType =\
8240                                                                                srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->present;
8241                if(macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType == SEARCHSPACETYPE_PR_UE_SPECIFIC)
8242                {
8243                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].ueSpecificDciFormat =\
8244                                                                                       srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->choice.ue_Specific->dci_Formats;
8245                }
8246
8247             }
8248          }
8249       }
8250    }
8251    /* Search space To Rel List */
8252    if(cuPdcchCfg->searchSpacesToReleaseList)
8253    {
8254       srchSpcToRelList = cuPdcchCfg->searchSpacesToReleaseList;
8255       if(srchSpcToRelList->list.count)
8256       {
8257          macPdcchCfg->numSearchSpcToRel = srchSpcToRelList->list.count;
8258          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToRelList->list.count; srchSpcIdx++)
8259          {
8260             macPdcchCfg->searchSpcToRelList[srchSpcIdx] =\
8261                                                          *(srchSpcToRelList->list.array[srchSpcIdx]);
8262          }
8263       }
8264    }
8265 }
8266
8267 /*******************************************************************
8268  *
8269  * @brief Fills PdschCfg received by CU
8270  *
8271  * @details
8272  *
8273  *    Function : extractPdschCfg
8274  *
8275  *    Functionality: Fills PdschCfg received  by CU
8276  *
8277  * @params[in] PDSCH_Config_t *cuPdschCfg = Information which is send by CU,
8278  *                   which we have stored in F1UeContextSetupDb,
8279  *             PdschConfig *macPdschCfg = Used to Store the information which
8280  *                   needs to send in other layer, as well as this can be the variable
8281  *                   which stores the information in DuCb,
8282  *             PdschConfig *storedPdschCfg =  Null in case of sending the
8283  *                   information to other layer else it will have stored pdsch
8284  *                   configuration in copyOfmacUeCfg.
8285  * @return void
8286  *
8287  * ****************************************************************/
8288
8289 void extractPdschCfg(PDSCH_Config_t *cuPdschCfg, PdschConfig *macPdschCfg, PdschConfig *storedPdschCfg)
8290 {
8291    uint8_t timeDomIdx;
8292    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAlloc = NULLP;
8293
8294    if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
8295    {
8296       if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->present == \
8297             PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup)
8298       {
8299          if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup)
8300          {
8301             macPdschCfg->dmrsDlCfgForPdschMapTypeA.addPos = \
8302                *(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_AdditionalPosition);
8303          }
8304       }
8305    }
8306    macPdschCfg->resourceAllocType = cuPdschCfg->resourceAllocation;
8307    if(cuPdschCfg->pdsch_TimeDomainAllocationList)
8308    {
8309       timeDomAlloc = cuPdschCfg->pdsch_TimeDomainAllocationList;
8310       if(timeDomAlloc->present ==\
8311             PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup)
8312       {
8313          if(timeDomAlloc->choice.setup)
8314          {
8315             macPdschCfg->numTimeDomRsrcAlloc  = timeDomAlloc->choice.setup->list.count;
8316             for(timeDomIdx = 0; timeDomIdx < timeDomAlloc->choice.setup->list.count; timeDomIdx++)
8317             {
8318                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 = NULLP;
8319                if(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0)
8320                {
8321                   if(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 == NULL)
8322                   {
8323                      if(storedPdschCfg)
8324                      {
8325                         if(storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
8326                         {
8327                            macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 =\
8328                            storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0;
8329                         }
8330                         else
8331                         {
8332                            DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
8333                         }
8334                      }
8335                      else
8336                      {
8337                         DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
8338                      }
8339                      if(!macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
8340                      {
8341                         DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for k0 at extractPdschCfg()");
8342                         return RFAILED;
8343                      }
8344                   }
8345                   *(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0) = \
8346                   *(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0);
8347                }
8348                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
8349                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
8350                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
8351                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8352             }
8353          }
8354       }
8355    }
8356    macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
8357    if(cuPdschCfg->maxNrofCodeWordsScheduledByDCI)
8358       macPdschCfg->numCodeWordsSchByDci = *(cuPdschCfg->maxNrofCodeWordsScheduledByDCI);
8359    if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_staticBundling)
8360    {
8361       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
8362       if(cuPdschCfg->prb_BundlingType.choice.staticBundling)
8363       {
8364          if(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize)
8365          {
8366             macPdschCfg->bundlingInfo.StaticBundling.size = \
8367                *(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize);
8368          }
8369       }
8370    }
8371    else if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_dynamicBundling)
8372    {
8373       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
8374    }
8375
8376 }
8377
8378 /*******************************************************************
8379  *
8380  * @brief Fills PdschServingCellCfg received by CU
8381  *
8382  * @details
8383  *
8384  *    Function : extractPdschServingCellCfg
8385  *
8386  *    Functionality: Fills PdschCfg received  by CU
8387  *
8388  * @params[in] PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg,
8389  *             PdschServCellCfg *macUePdschSrvCellCfg
8390  * @return ROK/RFAILED
8391  *
8392  * ****************************************************************/
8393
8394 uint8_t extractPdschServingCellCfg(PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg, PdschServCellCfg *macUePdschSrvCellCfg)
8395 {
8396    if(cuPdschSrvCellCfg->codeBlockGroupTransmission)
8397    {
8398       if(cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup)
8399       {
8400          if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
8401          {
8402             *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
8403                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
8404          }
8405          else
8406          {
8407             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
8408             if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
8409             {
8410                *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
8411                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
8412             }
8413             else
8414             {
8415                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
8416                return RFAILED;
8417             }
8418          }
8419          if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
8420          {
8421             *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
8422                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
8423          }
8424          else
8425          {
8426             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->codeBlkGrpFlushInd , sizeof(bool));
8427             if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
8428             {
8429                *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
8430                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
8431             }
8432             else
8433             {
8434                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
8435                return RFAILED;
8436             }
8437          }
8438       }
8439    }
8440    if(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH)
8441    {
8442       macUePdschSrvCellCfg->numHarqProcForPdsch = *(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH);
8443    }
8444    if(cuPdschSrvCellCfg->ext1)
8445    {
8446       if(cuPdschSrvCellCfg->ext1->maxMIMO_Layers)
8447       {
8448         if(macUePdschSrvCellCfg->maxMimoLayers)
8449         {
8450            *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
8451         }
8452         else
8453         {
8454            DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxMimoLayers, sizeof(uint8_t));
8455            if(macUePdschSrvCellCfg->maxMimoLayers)
8456            {
8457               *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
8458            }
8459            else
8460            {
8461               DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
8462               return RFAILED;
8463            }
8464         }
8465       }
8466    }
8467    if(cuPdschSrvCellCfg->xOverhead)
8468    {
8469       if(macUePdschSrvCellCfg->xOverhead)
8470       {
8471          *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
8472       }
8473       else
8474       {
8475          DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->xOverhead, sizeof(PdschXOverhead));
8476          if(macUePdschSrvCellCfg->xOverhead)
8477          {
8478             *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
8479          }
8480          else
8481          {
8482             DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
8483             return RFAILED;
8484          }
8485       }
8486    }
8487    return ROK;
8488 }
8489
8490 /*******************************************************************
8491  *
8492  * @brief Fills PuschCfg received by CU
8493  *
8494  * @details
8495  *
8496  *    Function : extractPuschCfg
8497  *
8498  *    Functionality: Fills PuschCfg received  by CU
8499  *
8500  * @params[in] BWP_UplinkDedicated__pusch_Config *cuPuschCfg,
8501  *             PuschCfg *macPuschCfg
8502  * @return void
8503  *
8504  * ****************************************************************/
8505
8506 void extractPuschCfg(struct BWP_UplinkDedicated__pusch_Config *cuPuschCfg, PuschCfg *macPuschCfg)
8507 {
8508    uint8_t timeDomIdx = 0;
8509    DMRS_UplinkConfig_t *dmrsUlCfg = NULLP;
8510    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList = NULLP;
8511
8512    if(cuPuschCfg->present == BWP_UplinkDedicated__pusch_Config_PR_setup)
8513    {
8514       if(cuPuschCfg->choice.setup)
8515       {
8516          if(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH)
8517          {
8518              macPuschCfg->dataScramblingId = \
8519                 *(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH);
8520          }
8521          if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA)
8522          {
8523             if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->present == PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup)
8524             {
8525                if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup)
8526                {
8527                   dmrsUlCfg = (cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup);
8528                   if(dmrsUlCfg->dmrs_AdditionalPosition)
8529                   {
8530                      macPuschCfg->dmrsUlCfgForPuschMapTypeA.addPos =\
8531                         *(dmrsUlCfg->dmrs_AdditionalPosition);
8532                   }
8533                   if(dmrsUlCfg->transformPrecodingDisabled)
8534                   {
8535                      if(dmrsUlCfg->transformPrecodingDisabled->scramblingID0)
8536                      {
8537                         macPuschCfg->dmrsUlCfgForPuschMapTypeA.transPrecodDisabled.scramblingId0 = \
8538                            *(dmrsUlCfg->transformPrecodingDisabled->scramblingID0);
8539                      }
8540                   }
8541                }
8542             }
8543          }
8544          /*Res Alloc Type for UL */
8545          if(cuPuschCfg->choice.setup->resourceAllocation)
8546          {
8547             macPuschCfg->resourceAllocType = \
8548                cuPuschCfg->choice.setup->resourceAllocation;
8549          }
8550          if(cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList)
8551          {
8552             timeDomAllocList = cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList;
8553             if(timeDomAllocList->present == PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup)
8554             {
8555                if(timeDomAllocList->choice.setup)
8556                {
8557                   macPuschCfg->numTimeDomRsrcAlloc = timeDomAllocList->choice.setup->list.count;
8558                   for(timeDomIdx = 0; timeDomIdx <timeDomAllocList->choice.setup->list.count; timeDomIdx++)
8559                   {
8560                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].k2 = \
8561                         *(timeDomAllocList->choice.setup->list.array[timeDomIdx]->k2);
8562                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].mappingType = \
8563                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->mappingType;
8564                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbolAndLength = \
8565                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8566                   }
8567                }
8568             }
8569          }
8570          if(cuPuschCfg->choice.setup->transformPrecoder)
8571             macPuschCfg->transformPrecoder = *(cuPuschCfg->choice.setup->transformPrecoder);
8572       }
8573    }
8574 }
8575
8576 /*******************************************************************
8577  *
8578  * @brief Function to fill pucch Power Control
8579  *
8580  * @details
8581  *
8582  *    Function : extractPucchPowerControl
8583  *
8584  *    Functionality: Function to fill pucch Power Control
8585  *
8586  * @params[in] PucchPowerControl *pwrCtrl,
8587  *             struct PUCCH_PowerControl *cuPwrCtrlCfg
8588  * @return void
8589  *
8590  * ****************************************************************/
8591
8592 void extractPucchPowerControl(PucchPowerControl *pwrCtrl, struct PUCCH_PowerControl *cuPwrCtrlCfg)
8593 {
8594    uint8_t arrIdx;
8595
8596    if(cuPwrCtrlCfg->deltaF_PUCCH_f0)
8597       pwrCtrl->deltaF_Format0 = *cuPwrCtrlCfg->deltaF_PUCCH_f0;
8598    if(cuPwrCtrlCfg->deltaF_PUCCH_f1)
8599       pwrCtrl->deltaF_Format1 = *cuPwrCtrlCfg->deltaF_PUCCH_f1;
8600    if(cuPwrCtrlCfg->deltaF_PUCCH_f2)
8601       pwrCtrl->deltaF_Format2 = *cuPwrCtrlCfg->deltaF_PUCCH_f2;
8602    if(cuPwrCtrlCfg->deltaF_PUCCH_f3)
8603       pwrCtrl->deltaF_Format3 = *cuPwrCtrlCfg->deltaF_PUCCH_f3;
8604    if(cuPwrCtrlCfg->deltaF_PUCCH_f4)
8605       pwrCtrl->deltaF_Format4 = *cuPwrCtrlCfg->deltaF_PUCCH_f4;
8606    if(cuPwrCtrlCfg->p0_Set)
8607    {
8608       pwrCtrl->p0SetCount = cuPwrCtrlCfg->p0_Set->list.count;
8609       for(arrIdx=0; arrIdx < pwrCtrl->p0SetCount; arrIdx++)
8610       {
8611          pwrCtrl->p0Set[arrIdx].p0PucchId =\
8612             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Id;
8613          pwrCtrl->p0Set[arrIdx].p0PucchVal =\
8614             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Value;
8615       }
8616    }
8617    if(cuPwrCtrlCfg->pathlossReferenceRSs)
8618    {
8619       pwrCtrl->pathLossRefRSListCount = cuPwrCtrlCfg->pathlossReferenceRSs->list.count;
8620       for(arrIdx = 0; arrIdx < pwrCtrl->pathLossRefRSListCount; arrIdx++)
8621       {
8622          pwrCtrl->pathLossRefRSList[arrIdx].pathLossRefRSId =\
8623             cuPwrCtrlCfg->pathlossReferenceRSs->list.array[arrIdx]->pucch_PathlossReferenceRS_Id;
8624       }
8625    }
8626 }
8627
8628  /*******************************************************************
8629  *
8630  * @brief Function to extractResrcSetToAddModList sent by CU
8631  *
8632  * @details
8633  *
8634  *    Function : extractResrcSetToAddModList
8635  *
8636  *    Functionality: Fucntion to extractResrcSetToAddModList
8637  *
8638  * @params[in] PucchResrcSetCfg pointer,
8639  *             struct PUCCH_Config__resourceSetToAddModList pointer
8640  * @return void
8641  *
8642  * ****************************************************************/
8643
8644 void extractResrcSetToAddModList(PucchResrcSetCfg *macRsrcSetList, struct PUCCH_Config__resourceSetToAddModList *cuRsrcSetList)
8645 {
8646    uint8_t arrIdx, rsrcListIdx;
8647
8648    macRsrcSetList->resrcSetToAddModListCount = cuRsrcSetList->list.count;
8649    for(arrIdx = 0; arrIdx < macRsrcSetList->resrcSetToAddModListCount; arrIdx++)
8650    {
8651       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcSetId     =\
8652          cuRsrcSetList->list.array[arrIdx]->pucch_ResourceSetId;
8653       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount =\
8654          cuRsrcSetList->list.array[arrIdx]->resourceList.list.count;
8655       for(rsrcListIdx = 0; rsrcListIdx < macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount; rsrcListIdx++)
8656       {
8657          macRsrcSetList->resrcSetToAddModList[arrIdx].resrcList[rsrcListIdx] =\
8658             *cuRsrcSetList->list.array[arrIdx]->resourceList.list.array[rsrcListIdx];
8659       }
8660       macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize =\
8661          *cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1;
8662    }
8663 }/* End of extractResrcSetToAddModList */
8664
8665 /*******************************************************************
8666  *
8667  * @brief Fills extractResrcToAddModList sent by CU
8668  *
8669  * @details
8670  *
8671  *    Function : extractResrcToAddModList
8672  *
8673  *    Functionality: Fills extractResrcToAddModList
8674  *
8675  * @params[in] PucchResrcCfg pointer,
8676  *             struct PUCCH_Config__resourceToAddModList pointer
8677  * @return ROk/RFAILED
8678  *
8679  * ****************************************************************/
8680
8681 uint8_t extractResrcToAddModList(PucchResrcCfg *macResrcList, struct PUCCH_Config__resourceToAddModList *cuResrcList)
8682 {
8683    uint8_t arrIdx;
8684
8685    macResrcList->resrcToAddModListCount = cuResrcList->list.count;
8686    for(arrIdx = 0; arrIdx < macResrcList->resrcToAddModListCount; arrIdx++)
8687    {
8688       macResrcList->resrcToAddModList[arrIdx].resrcId      =\
8689         cuResrcList->list.array[arrIdx]->pucch_ResourceId;
8690       macResrcList->resrcToAddModList[arrIdx].startPrb     =\
8691         cuResrcList->list.array[arrIdx]->startingPRB;
8692       if(cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping)
8693       {
8694          macResrcList->resrcToAddModList[arrIdx].intraFreqHop =\
8695            *cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping;
8696       }
8697       if(cuResrcList->list.array[arrIdx]->secondHopPRB)
8698       {
8699          macResrcList->resrcToAddModList[arrIdx].secondPrbHop =\
8700            *cuResrcList->list.array[arrIdx]->secondHopPRB;
8701       }
8702       /* PUCCH RSRC FORMAT */
8703       if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format0)
8704       {
8705          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_0;
8706          if(cuResrcList->list.array[arrIdx]->format.choice.format0)
8707          {
8708             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0, sizeof(PucchFormat0));
8709             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0 == NULLP)
8710             {
8711                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
8712                return RFAILED;
8713             }
8714             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->initialCyclicShift =\
8715                cuResrcList->list.array[arrIdx]->format.choice.format0->initialCyclicShift;
8716             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->numSymbols =\
8717                cuResrcList->list.array[arrIdx]->format.choice.format0->nrofSymbols;
8718             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->startSymbolIdx =\
8719                cuResrcList->list.array[arrIdx]->format.choice.format0->startingSymbolIndex;
8720          }
8721       }
8722       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format1)
8723       {
8724          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_1;
8725          if(cuResrcList->list.array[arrIdx]->format.choice.format1)
8726          {
8727             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1, sizeof(PucchFormat1));
8728             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1 == NULLP)
8729             {
8730                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
8731                return RFAILED;
8732             }
8733             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->initialCyclicShift =\
8734                 cuResrcList->list.array[arrIdx]->format.choice.format1->initialCyclicShift;
8735             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->numSymbols =\
8736                 cuResrcList->list.array[arrIdx]->format.choice.format1->nrofSymbols;
8737             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->startSymbolIdx =\
8738                 cuResrcList->list.array[arrIdx]->format.choice.format1->startingSymbolIndex;
8739             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->timeDomOCC =\
8740                 cuResrcList->list.array[arrIdx]->format.choice.format1->timeDomainOCC;
8741          }
8742       }
8743       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format2)
8744       {
8745          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_2;
8746          if(cuResrcList->list.array[arrIdx]->format.choice.format2)
8747          {
8748             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
8749             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2 == NULLP)
8750             {
8751                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
8752                return RFAILED;
8753             }
8754             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numPrbs =\
8755                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofPRBs;
8756             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numSymbols =\
8757                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofSymbols;
8758             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->startSymbolIdx =\
8759                 cuResrcList->list.array[arrIdx]->format.choice.format2->startingSymbolIndex;
8760          }
8761       }
8762       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format3)
8763       {
8764          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_3;
8765          if(cuResrcList->list.array[arrIdx]->format.choice.format3)
8766          {
8767             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
8768             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3 == NULLP)
8769             {
8770                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
8771                return RFAILED;
8772             }
8773             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numPrbs =\
8774                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofPRBs;
8775             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numSymbols =\
8776                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofSymbols;
8777             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->startSymbolIdx =\
8778                 cuResrcList->list.array[arrIdx]->format.choice.format3->startingSymbolIndex;
8779          }
8780       }
8781       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format4)
8782       {
8783          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_4;
8784          if(cuResrcList->list.array[arrIdx]->format.choice.format4)
8785          {
8786             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4, sizeof(PucchFormat4));
8787             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4 == NULLP)
8788             {
8789                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
8790                return RFAILED;
8791             }
8792             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->numSymbols =\
8793                 cuResrcList->list.array[arrIdx]->format.choice.format4->nrofSymbols;
8794             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occLen =\
8795                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Length;
8796             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occIdx =\
8797                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Index;
8798             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->startSymbolIdx =\
8799                 cuResrcList->list.array[arrIdx]->format.choice.format4->startingSymbolIndex;
8800          }
8801       }
8802    }
8803    return ROK;
8804
8805 }/* End of extractResrcToAddModList */
8806
8807 /*******************************************************************
8808  *
8809  * @brief Fills fillPucchSchedReqPeriodAndOffset sent by CU
8810  *
8811  * @details
8812  *
8813  *    Function : fillPucchSchedReqPeriodAndOffset
8814  *
8815  *    Functionality: To fillPucchSchedReqPeriodAndOffset
8816  *
8817  * @params[in] macPeriodicty,
8818  *     SchedulingRequestResourceConfig__periodicityAndOffset pointer
8819  * @return void
8820  *
8821  * ****************************************************************/
8822
8823 void fillPucchSchedReqPeriodAndOffset(uint8_t macPeriodicty, uint16_t  macOffset,\
8824    struct SchedulingRequestResourceConfig__periodicityAndOffset *cuPeriodicty)
8825 {
8826    macPeriodicty = cuPeriodicty->present;
8827    switch(macPeriodicty)
8828    {
8829       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
8830          {
8831             macOffset     = cuPeriodicty->choice.sym2;
8832             break;
8833          }
8834       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
8835          {
8836             macOffset     = cuPeriodicty->choice.sym6or7;
8837             break;
8838          }
8839       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
8840          {
8841             macOffset     = cuPeriodicty->choice.sl1;
8842             break;
8843          }
8844       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
8845          {
8846             macOffset = cuPeriodicty->choice.sl2;
8847             break;
8848          }
8849       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
8850          {
8851             macOffset = cuPeriodicty->choice.sl4;
8852             break;
8853          }
8854       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
8855          {
8856             macOffset = cuPeriodicty->choice.sl5;
8857             break;
8858          }
8859       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
8860          {
8861             macOffset = cuPeriodicty->choice.sl8;
8862             break;
8863          }
8864       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
8865          {
8866             macOffset = cuPeriodicty->choice.sl10;
8867             break;
8868          }
8869       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
8870          {
8871             macOffset = cuPeriodicty->choice.sl16;
8872             break;
8873          }
8874       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
8875          {
8876             macOffset = cuPeriodicty->choice.sl20;
8877             break;
8878          }
8879       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
8880          {
8881             macOffset = cuPeriodicty->choice.sl40;
8882             break;
8883          }
8884       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
8885          {
8886             macOffset = cuPeriodicty->choice.sl80;
8887             break;
8888          }
8889       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
8890          {
8891             macOffset = cuPeriodicty->choice.sl160;
8892             break;
8893          }
8894       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
8895          {
8896             macOffset = cuPeriodicty->choice.sl320;
8897             break;
8898          }
8899       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
8900          {
8901             macOffset = cuPeriodicty->choice.sl640;
8902             break;
8903          }
8904       default :
8905          DU_LOG("\nERROR  -->  F1AP : Invalid periodicity %d", macPeriodicty);
8906    }
8907 }
8908
8909 /*******************************************************************
8910  *
8911  * @brief Function to extractPucchFormatCfg sent by CU
8912  *
8913  * @details
8914  *
8915  *    Function : extractPucchFormatCfg
8916  *
8917  *    Functionality: Function to extractPucchFormatCfg
8918  *
8919  * @params[in] PucchFormatCfg pointer,
8920  *             PUCCH_FormatConfig_t pointer
8921  * @return void
8922  *
8923  * ****************************************************************/
8924
8925 void extractPucchFormatCfg(PucchFormatCfg *macFormatCfg, PUCCH_FormatConfig_t *cuFormatCfg)
8926  {
8927     if(cuFormatCfg->interslotFrequencyHopping)
8928        macFormatCfg->interSlotFreqHop = *cuFormatCfg->interslotFrequencyHopping;
8929     if(cuFormatCfg->additionalDMRS)
8930        macFormatCfg->addDmrs = *cuFormatCfg->additionalDMRS;
8931     if(cuFormatCfg->maxCodeRate)
8932        macFormatCfg->maxCodeRate = *cuFormatCfg->maxCodeRate;
8933     if(cuFormatCfg->nrofSlots)
8934        macFormatCfg->numSlots = *cuFormatCfg->nrofSlots;
8935     if(cuFormatCfg->pi2BPSK)
8936        macFormatCfg->pi2BPSK = *cuFormatCfg->pi2BPSK;
8937     if(cuFormatCfg->simultaneousHARQ_ACK_CSI)
8938        macFormatCfg->harqAckCSI = *cuFormatCfg->simultaneousHARQ_ACK_CSI;
8939  }/* End of extractPucchFormatCfg */
8940
8941 /*******************************************************************
8942  *
8943  * @brief Function to extractSchedReqCfgToAddMod sent by CU
8944  *
8945  * @details
8946  *
8947  *    Function : extractSchedReqCfgToAddMod
8948  *
8949  *    Functionality: Function to extractSchedReqCfgToAddMod
8950  *
8951  * @params[in] PucchSchedReqCfg pointer,
8952  *      PUCCH_Config__schedulingRequestResourceToAddModList pointer
8953  * @return void
8954  *
8955  * ****************************************************************/
8956
8957 void extractSchedReqCfgToAddMod(PucchSchedReqCfg *macSchedReqCfg, struct PUCCH_Config__schedulingRequestResourceToAddModList *cuSchedReqList)
8958 {
8959    uint8_t arrIdx;
8960
8961    macSchedReqCfg->schedAddModListCount = cuSchedReqList->list.count;
8962    for(arrIdx = 0; arrIdx <  macSchedReqCfg->schedAddModListCount; arrIdx++)
8963    {
8964       macSchedReqCfg->schedAddModList[arrIdx].resrcId =\
8965          cuSchedReqList->list.array[arrIdx]->schedulingRequestResourceId;
8966       macSchedReqCfg->schedAddModList[arrIdx].requestId =\
8967          cuSchedReqList->list.array[arrIdx]->schedulingRequestID;
8968       if(cuSchedReqList->list.array[arrIdx]->periodicityAndOffset)
8969       {
8970          fillPucchSchedReqPeriodAndOffset(macSchedReqCfg->schedAddModList[arrIdx].periodicity,\
8971             macSchedReqCfg->schedAddModList[arrIdx].offset, cuSchedReqList->list.array[arrIdx]->periodicityAndOffset);
8972       }
8973       if(cuSchedReqList->list.array[arrIdx]->resource)
8974       {
8975          macSchedReqCfg->schedAddModList[arrIdx].resrc =\
8976             *cuSchedReqList->list.array[arrIdx]->resource;
8977       }
8978    }
8979
8980 }/* End of extractSchedReqCfgToAddMod */
8981
8982  /*******************************************************************
8983  *
8984  * @brief Fills PucchCfg received by CU
8985  *
8986  * @details
8987  *
8988  *    Function : extractPucchCfg
8989  *
8990  *    Functionality: Fills PucchCfg received  by CU
8991  *
8992  * @params[in] BWP_UplinkDedicated__pucch_Config *cuPucchCfg = Information which
8993  *                is send by CU, which we have stored in F1UeContextSetupDb,
8994  *             PucchCfg *macPucchCfg = Used to Store the information which
8995  *                needs to send in other layer, as well as this can be the variable
8996  *                which stores the information in DuCb,
8997  *             PucchCfg *storedPucchCfg = Null in case of sending the
8998  *                information to other layer else it will have Pucch Cfg which
8999  *                we have stored in copyOfmacUeCfg.
9000  * @return ROK/RFAILED
9001  *
9002  * ****************************************************************/
9003
9004 uint8_t extractPucchCfg(struct BWP_UplinkDedicated__pucch_Config *cuPucchCfg, PucchCfg *macPucchCfg,\
9005 PucchCfg *storedPucchCfg)
9006 {
9007    uint8_t arrIdx;
9008
9009    if(cuPucchCfg->present == BWP_UplinkDedicated__pucch_Config_PR_setup)
9010    {
9011       if(cuPucchCfg->choice.setup)
9012       {
9013          /* Resource Set Cfg */
9014          if(cuPucchCfg->choice.setup->resourceSetToAddModList)
9015          {
9016             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrcSet, sizeof(PucchResrcSetCfg));
9017             if(macPucchCfg->resrcSet == NULLP)
9018             {
9019                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
9020                return RFAILED;
9021             }
9022             memset(macPucchCfg->resrcSet, 0, sizeof(PucchResrcSetCfg));
9023             extractResrcSetToAddModList(macPucchCfg->resrcSet, cuPucchCfg->choice.setup->resourceSetToAddModList);
9024          }
9025
9026          /* Resource Cfg */
9027          if(cuPucchCfg->choice.setup->resourceToAddModList)
9028          {
9029             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrc, sizeof(PucchResrcCfg));
9030             if(macPucchCfg->resrc == NULLP)
9031             {
9032                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
9033                return RFAILED;
9034             }
9035             memset(macPucchCfg->resrc, 0, sizeof(PucchResrcCfg));
9036             extractResrcToAddModList(macPucchCfg->resrc, cuPucchCfg->choice.setup->resourceToAddModList);
9037          }
9038
9039          /* Format 1 Cfg */
9040          if(cuPucchCfg->choice.setup->format1)
9041          {
9042             DU_ALLOC_SHRABL_BUF(macPucchCfg->format1, sizeof(PucchFormatCfg));
9043             if(macPucchCfg->format1 == NULLP)
9044             {
9045                DU_LOG("\nERROR --> F1AP : Failed to extract format 1 Cfg in  extractPucchCfg()");
9046                return RFAILED;
9047             }
9048             memset(macPucchCfg->format1, 0, sizeof(PucchFormatCfg));
9049             extractPucchFormatCfg(macPucchCfg->format1,\
9050                cuPucchCfg->choice.setup->format1->choice.setup);
9051          }
9052
9053          /* Format 2 Cfg */
9054          if(cuPucchCfg->choice.setup->format2)
9055          {
9056             DU_ALLOC_SHRABL_BUF(macPucchCfg->format2, sizeof(PucchFormatCfg));
9057             if(macPucchCfg->format2 == NULLP)
9058             {
9059                DU_LOG("\nERROR --> F1AP : Failed to extract format 2 Cfg in  extractPucchCfg()");
9060                return RFAILED;
9061             }
9062             memset(macPucchCfg->format2, 0, sizeof(PucchFormatCfg));
9063             extractPucchFormatCfg(macPucchCfg->format2,\
9064                cuPucchCfg->choice.setup->format2->choice.setup);
9065          }
9066
9067          /* Format 3 Cfg */
9068          if(cuPucchCfg->choice.setup->format3)
9069          {
9070             DU_ALLOC_SHRABL_BUF(macPucchCfg->format3, sizeof(PucchFormatCfg));
9071             if(macPucchCfg->format3 == NULLP)
9072             {
9073                DU_LOG("\nERROR --> F1AP : Failed to extract format 3 Cfg in  extractPucchCfg()");
9074                return RFAILED;
9075             }
9076             memset(macPucchCfg->format3, 0, sizeof(PucchFormatCfg));
9077             extractPucchFormatCfg(macPucchCfg->format3,\
9078                cuPucchCfg->choice.setup->format3->choice.setup);
9079          }
9080
9081          /* Format 4 Cfg */
9082          if(cuPucchCfg->choice.setup->format4)
9083          {
9084             DU_ALLOC_SHRABL_BUF(macPucchCfg->format4, sizeof(PucchFormatCfg));
9085             if(macPucchCfg->format4 == NULLP)
9086             {
9087                DU_LOG("\nERROR --> F1AP : Failed to extract format 4 Cfg in  extractPucchCfg()");
9088                return RFAILED;
9089             }
9090             memset(macPucchCfg->format4, 0, sizeof(PucchFormatCfg));
9091             extractPucchFormatCfg(macPucchCfg->format4,\
9092                cuPucchCfg->choice.setup->format4->choice.setup);
9093          }
9094
9095          /* Sched Req List */
9096          if(cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList)
9097          {
9098             DU_ALLOC_SHRABL_BUF(macPucchCfg->schedReq, sizeof(PucchSchedReqCfg));
9099             if(macPucchCfg->schedReq == NULLP)
9100             {
9101                DU_LOG("\nERROR --> F1AP : Failed to extract schedReqCfg in  extractPucchCfg()");
9102                return RFAILED;
9103             }
9104             memset(macPucchCfg->schedReq, 0, sizeof(PucchSchedReqCfg));
9105             extractSchedReqCfgToAddMod(macPucchCfg->schedReq,\
9106             cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList);
9107          }
9108
9109          /*TODO: Add support for  Spatial Info */
9110
9111          /* MultiCsiCfg */
9112          if(cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList)
9113          {
9114             DU_ALLOC_SHRABL_BUF(macPucchCfg->multiCsiCfg, sizeof(PucchMultiCsiCfg));
9115             if(macPucchCfg->multiCsiCfg == NULLP)
9116             {
9117                DU_LOG("\nERROR --> F1AP : Failed to extract multiCsiCfg in  extractPucchCfg()");
9118                return RFAILED;
9119             }
9120             memset(macPucchCfg->multiCsiCfg, 0, sizeof(PucchMultiCsiCfg));
9121             macPucchCfg->multiCsiCfg->multiCsiResrcListCount = cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.count;
9122             for(arrIdx =0; arrIdx < macPucchCfg->multiCsiCfg->multiCsiResrcListCount; arrIdx++)
9123             {
9124                macPucchCfg->multiCsiCfg->multiCsiResrcList[arrIdx] =\
9125                  *cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.array[arrIdx];
9126             }
9127          }
9128
9129          /* Dl_DataToUL_ACK */
9130          if(cuPucchCfg->choice.setup->dl_DataToUL_ACK)
9131     {
9132        if(storedPucchCfg)
9133        {
9134           if(storedPucchCfg->dlDataToUlAck)
9135           {
9136              macPucchCfg->dlDataToUlAck = storedPucchCfg->dlDataToUlAck;
9137           }
9138           else
9139           {
9140             DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
9141           }
9142        }
9143        else
9144        {
9145           DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
9146        }
9147        if(macPucchCfg->dlDataToUlAck == NULLP)
9148        {
9149           DU_LOG("\nERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
9150           return RFAILED;
9151        }
9152        memset(macPucchCfg->dlDataToUlAck, 0, sizeof(PucchDlDataToUlAck));
9153        macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount = cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.count;
9154        for(arrIdx = 0; arrIdx < macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount; arrIdx++)
9155        {
9156           macPucchCfg->dlDataToUlAck->dlDataToUlAckList[arrIdx] =\
9157           *cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.array[arrIdx];
9158        }
9159          }
9160
9161          /* Power Control */
9162          if(cuPucchCfg->choice.setup->pucch_PowerControl)
9163          {
9164             DU_ALLOC_SHRABL_BUF(macPucchCfg->powerControl, sizeof(PucchPowerControl));
9165             if(macPucchCfg->powerControl == NULLP)
9166             {
9167                DU_LOG("\nERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
9168                return RFAILED;
9169             }
9170             extractPucchPowerControl(macPucchCfg->powerControl,\
9171                cuPucchCfg->choice.setup->pucch_PowerControl);
9172          }
9173       }
9174    }
9175    return ROK;
9176 }
9177
9178 /*******************************************************************
9179  *
9180  * @brief Fills ServingCellReconfig received by CU
9181  *
9182  * @details
9183  *
9184  *    Function : extractSpCellDedicatedCfg
9185  *
9186  *    Functionality: Fills ServingCellReconfig received  by CU
9187  *
9188  * @params[in] ServingCellConfig_t *cuSrvCellCfg = Information which is send by
9189  *                  CU, which we have stored in F1UeContextSetupDb,
9190  *             ServCellCfgInfo *macSrvCellCfg = Used to Store the information
9191  *                  which  needs to send in other layer, as well as this can be the
9192  *                  variable which stores the information in DuCb,
9193  *             ServCellCfgInfo *storedSrvCellCfg = Null in case of sending the
9194  *                  information to other layer else it will have ServCellCfgInfo which
9195  *                  we have stored in copyOfmacUeCfg.
9196  * @return ROK/RFAILD
9197  *
9198  * ****************************************************************/
9199 uint8_t extractSpCellDedicatedCfg(ServingCellConfig_t *cuSrvCellCfg, ServCellCfgInfo *macSrvCellCfg,\
9200 ServCellCfgInfo *storedSrvCellCfg)
9201 {
9202    uint8_t ret = ROK;
9203    BWP_DownlinkDedicated_t *dlBwp = NULLP;
9204    BWP_UplinkDedicated_t   *ulBwp = NULLP;
9205
9206    if(cuSrvCellCfg->initialDownlinkBWP)
9207    {
9208       dlBwp = ((BWP_DownlinkDedicated_t *)(cuSrvCellCfg->initialDownlinkBWP));
9209       if(dlBwp->pdcch_Config)
9210       {
9211          if(dlBwp->pdcch_Config->choice.setup)
9212          {
9213             macSrvCellCfg->initDlBwp.pdcchPresent = true;
9214             if(storedSrvCellCfg)
9215             {
9216                if(!storedSrvCellCfg->initDlBwp.pdcchPresent)
9217                {
9218                   extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
9219                }
9220                else
9221                {
9222                   extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
9223                }
9224             }
9225             else
9226             {
9227                extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
9228             }
9229          }
9230       }
9231       if(dlBwp->pdsch_Config)
9232       {
9233          if(dlBwp->pdsch_Config->choice.setup)
9234          {
9235             macSrvCellCfg->initDlBwp.pdschPresent = true;
9236
9237             if(storedSrvCellCfg)
9238             {
9239                if(!storedSrvCellCfg->initDlBwp.pdschPresent)
9240                {
9241                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
9242                }
9243                else
9244                {
9245                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg,\
9246                         &storedSrvCellCfg->initDlBwp.pdschCfg);
9247                }
9248             }
9249             else
9250             {
9251                extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
9252             }
9253          }
9254       }
9255    }
9256    if(cuSrvCellCfg->firstActiveDownlinkBWP_Id)
9257       macSrvCellCfg->firstActvDlBwpId = *(cuSrvCellCfg->firstActiveDownlinkBWP_Id);
9258    if(cuSrvCellCfg->defaultDownlinkBWP_Id)
9259       macSrvCellCfg->defaultDlBwpId = *(cuSrvCellCfg->defaultDownlinkBWP_Id);
9260    if(cuSrvCellCfg->bwp_InactivityTimer)
9261    {
9262       if(macSrvCellCfg->bwpInactivityTmr)
9263       {
9264          memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
9265       }
9266       else
9267       {
9268          macSrvCellCfg->bwpInactivityTmr = NULLP;
9269          DU_ALLOC_SHRABL_BUF(macSrvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
9270          if(macSrvCellCfg->bwpInactivityTmr)
9271          {
9272             memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
9273          }
9274          else
9275          {
9276             DU_LOG("\nERROR  --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
9277             return RFAILED;
9278          }
9279       }
9280    }
9281    if(cuSrvCellCfg->pdsch_ServingCellConfig)
9282    {
9283       if(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup)
9284       {
9285          ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
9286          if(ret == RFAILED)
9287          {
9288             DU_LOG("\nERROR --> F1AP : Failed at extractPdschServingCellCfg()");
9289             return RFAILED;
9290          }
9291       }
9292    }
9293    if(cuSrvCellCfg->uplinkConfig)
9294    {
9295       if(cuSrvCellCfg->uplinkConfig->initialUplinkBWP)
9296       {
9297          ulBwp = ((BWP_UplinkDedicated_t *)(cuSrvCellCfg->uplinkConfig->initialUplinkBWP));
9298          if(ulBwp->pusch_Config)
9299          {
9300             macSrvCellCfg->initUlBwp.puschPresent = true;
9301             extractPuschCfg(ulBwp->pusch_Config, &macSrvCellCfg->initUlBwp.puschCfg);
9302          }
9303          if(ulBwp->pucch_Config)
9304          {
9305             macSrvCellCfg->initUlBwp.pucchPresent = true;
9306             memset(&macSrvCellCfg->initUlBwp.pucchCfg, 0, sizeof(PucchCfg));
9307             if(storedSrvCellCfg)
9308             {
9309                if(!storedSrvCellCfg->initUlBwp.pucchPresent)
9310                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
9311                else
9312                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg,\
9313                   &storedSrvCellCfg->initUlBwp.pucchCfg);
9314             }
9315             else
9316             {
9317                extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
9318             }
9319          }
9320       }
9321       if(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id)
9322          macSrvCellCfg->firstActvUlBwpId = *(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id);
9323    }
9324    return ret;
9325 }
9326 /*******************************************************************
9327  *
9328  * @brief Fills Reconfig Cell group Info received by CU
9329  *
9330  * @details
9331  *
9332  *    Function : extractUeReCfgCellInfo
9333  *
9334  *    Functionality: Fills Reconfig Cell group Info received by CU
9335  *
9336  * @params[in] CellGroupConfigRrc_t *cellGrp = CellGroupConfigRrc_t information which
9337  *                       is send by CU, which we have stored in F1UeContextSetupDb
9338  *             MacUeCfg *MacUeCfg = Used to Store the information,
9339  *                      which needs to send in other layer, as well as this can be
9340  *                      the variable which stores the information in DuCb,
9341  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
9342  *                      information to other layer else it will have copyOfmacUeCfg
9343  *                      which we have stored in F1UeContextSetupDb.
9344  *
9345  * @return ROK/RFAILED
9346  *
9347  * ****************************************************************/
9348 uint8_t extractUeReCfgCellInfo(CellGroupConfigRrc_t *cellGrp, MacUeCfg *macUeCfg, MacUeCfg *storedMacUeCfg)
9349 {
9350    uint8_t ret = ROK;
9351    MAC_CellGroupConfig_t     *macCellGroup = NULLP;
9352    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
9353    SpCellConfig_t            *spcellCfg = NULLP;
9354    ServingCellConfig_t       *servCellCfg = NULLP;
9355
9356    if(cellGrp)
9357    {
9358       /* Fill MacCell Group Reconfig  */
9359       if(cellGrp->mac_CellGroupConfig)
9360       {
9361          macUeCfg->macCellGrpCfgPres = true;
9362          macCellGroup = ((MAC_CellGroupConfig_t *)(cellGrp->mac_CellGroupConfig));
9363          if(macCellGroup->schedulingRequestConfig)
9364          {
9365             extractSchReqReConfig(macCellGroup->schedulingRequestConfig, &macUeCfg->macCellGrpCfg.schReqCfg);
9366          }
9367          if(macCellGroup->tag_Config)
9368          {
9369             extractTagReconfig(macCellGroup->tag_Config, &macUeCfg->macCellGrpCfg.tagCfg);
9370          }
9371          if(macCellGroup->bsr_Config)
9372          {
9373             macUeCfg->macCellGrpCfg.bsrTmrCfg.periodicTimer = macCellGroup->bsr_Config->periodicBSR_Timer;
9374             macUeCfg->macCellGrpCfg.bsrTmrCfg.retxTimer     = macCellGroup->bsr_Config->retxBSR_Timer;
9375             if(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer)
9376             {
9377                macUeCfg->macCellGrpCfg.bsrTmrCfg.srDelayTimer  =\
9378                *(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer);
9379             }
9380          }
9381          if(macCellGroup->phr_Config)
9382          {
9383             if(macCellGroup->phr_Config->present == MAC_CellGroupConfig__phr_Config_PR_setup)
9384             {
9385                macUeCfg->macCellGrpCfg.phrCfgSetupPres = true;
9386                if(macCellGroup->phr_Config->choice.setup)
9387                {
9388                   macUeCfg->macCellGrpCfg.phrCfg.periodicTimer     = \
9389                   macCellGroup->phr_Config->choice.setup->phr_PeriodicTimer;
9390                   macUeCfg->macCellGrpCfg.phrCfg.prohibitTimer     = \
9391                   macCellGroup->phr_Config->choice.setup->phr_ProhibitTimer;
9392                   macUeCfg->macCellGrpCfg.phrCfg.txPowerFactor     = \
9393                   macCellGroup->phr_Config->choice.setup->phr_Tx_PowerFactorChange;
9394                   macUeCfg->macCellGrpCfg.phrCfg.multiplePHR       = \
9395                   macCellGroup->phr_Config->choice.setup->multiplePHR;
9396                   macUeCfg->macCellGrpCfg.phrCfg.dummy             = \
9397                   macCellGroup->phr_Config->choice.setup->dummy;
9398                   macUeCfg->macCellGrpCfg.phrCfg.phrType2OtherCell = \
9399                   macCellGroup->phr_Config->choice.setup->phr_Type2OtherCell;
9400                   macUeCfg->macCellGrpCfg.phrCfg.phrOtherCG        = \
9401                   macCellGroup->phr_Config->choice.setup->phr_ModeOtherCG;
9402                }
9403             }
9404          }
9405       }
9406       /* Fill Physical Cell Group Reconfig */
9407       if(cellGrp->physicalCellGroupConfig)
9408       {
9409          macUeCfg->phyCellGrpCfgPres = true;
9410          phyCellGrpCfg = ((PhysicalCellGroupConfig_t *)(cellGrp->physicalCellGroupConfig));
9411          if(phyCellGrpCfg->p_NR_FR1)
9412          {
9413             if(*(phyCellGrpCfg->p_NR_FR1) != macUeCfg->phyCellGrpCfg.pNrFr1)
9414                macUeCfg->phyCellGrpCfg.pNrFr1 = *(phyCellGrpCfg->p_NR_FR1);
9415          }
9416          macUeCfg->phyCellGrpCfg.pdschHarqAckCodebook = phyCellGrpCfg->pdsch_HARQ_ACK_Codebook;
9417       }
9418       /* Fill SpCell Reconfig */
9419       if(cellGrp->spCellConfig)
9420       {
9421          macUeCfg->spCellCfgPres = true;
9422          spcellCfg = ((SpCellConfig_t *)(cellGrp->spCellConfig));
9423          if(spcellCfg->servCellIndex)
9424          {
9425             macUeCfg->spCellCfg.servCellIdx = *(spcellCfg->servCellIndex);
9426          }
9427          /* Fill Serving cell Reconfig info */
9428          if(cellGrp->spCellConfig->spCellConfigDedicated)
9429          {
9430             servCellCfg = ((ServingCellConfig_t *)(cellGrp->spCellConfig->spCellConfigDedicated));
9431             if(storedMacUeCfg)
9432             {
9433                if(!storedMacUeCfg->spCellCfgPres)
9434                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
9435                else
9436                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg,\
9437                         &storedMacUeCfg->spCellCfg.servCellCfg);
9438             }
9439             else
9440             {
9441                ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
9442             }
9443             if(ret == RFAILED)
9444             {
9445                DU_LOG("\nERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
9446             }
9447          }
9448       }
9449    }
9450    return ret;
9451 }
9452 /*******************************************************************
9453 *
9454 * @brief free the memory allocated by decoder
9455 *
9456 * @details
9457 *
9458 *    Function : freeAperDecodeNrcgi
9459 *
9460 *    Functionality: Free Nrcgi values
9461 *
9462 * @params[in] NRCGI_t *nrcgi
9463 * @return void
9464 *
9465 * ****************************************************************/
9466
9467
9468 void freeAperDecodeNrcgi(NRCGI_t *nrcgi)
9469 {
9470     if(nrcgi->pLMN_Identity.buf != NULLP)
9471     {
9472        free(nrcgi->pLMN_Identity.buf);
9473     }
9474     if(nrcgi->nRCellIdentity.buf != NULLP)
9475     {
9476        free(nrcgi->nRCellIdentity.buf);
9477     }
9478 }
9479 /*******************************************************************
9480 *
9481 * @brief free the memory allocated by decoder
9482 *
9483 * @details
9484 *
9485 *    Function : freeAperDecodeCuToDuInfo
9486 *
9487 *    Functionality:  Free Cu To Du Information
9488 *
9489 * @params[in] CUtoDURRCInformation_t *rrcMsg
9490 * @return void
9491 *
9492 * ****************************************************************/
9493
9494
9495 void freeAperDecodeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
9496 {
9497    uint8_t ieIdx =0;
9498    uint8_t arrIdx =0;
9499
9500    if(rrcMsg->uE_CapabilityRAT_ContainerList)
9501    {
9502       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
9503          free(rrcMsg->uE_CapabilityRAT_ContainerList->buf);
9504       free(rrcMsg->uE_CapabilityRAT_ContainerList);
9505    }
9506
9507    if(rrcMsg->iE_Extensions)
9508    {
9509       if(rrcMsg->iE_Extensions->list.array)
9510       {
9511          for(ieIdx= 0; ieIdx < rrcMsg->iE_Extensions->list.count; ieIdx++)
9512          {
9513             if(rrcMsg->iE_Extensions->list.array[ieIdx])
9514             {
9515                switch(rrcMsg->iE_Extensions->list.array[ieIdx]->id)
9516                {
9517                   case ProtocolIE_ID_id_CellGroupConfig:
9518                      if(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
9519                      {
9520                         free(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf);
9521                      }
9522                      break;
9523                   default:
9524                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
9525                            rrcMsg->iE_Extensions->list.array[ieIdx]->id);
9526                      break;
9527                }
9528             }
9529          }
9530          for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
9531          {
9532             free(rrcMsg->iE_Extensions->list.array[arrIdx]);
9533          }
9534          free(rrcMsg->iE_Extensions->list.array);
9535
9536       }
9537
9538       free(rrcMsg->iE_Extensions);
9539    }
9540 }
9541 /*******************************************************************
9542 *
9543 * @brief free the memory allocated by decoder
9544 *
9545 * @details
9546 *
9547 *    Function : freeAperDecodeSplCellList
9548 *
9549 *    Functionality: Free Spl Cell List
9550                     where memory allocated by aper_decoder
9551 *
9552 * @params[in]  SCell_ToBeSetup_List_t *spCellLst
9553 * @return void
9554 *
9555 * ****************************************************************/
9556
9557
9558 void freeAperDecodeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
9559 {
9560     uint8_t  cellIdx =0;
9561
9562     if(spCellLst->list.array != NULLP)
9563     {
9564        for(cellIdx=0; cellIdx<spCellLst->list.count; cellIdx++)
9565        {
9566           if(cellIdx==0&&spCellLst->list.array[cellIdx]!=NULLP)
9567           {
9568              freeAperDecodeNrcgi(&spCellLst->list.array[cellIdx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
9569           }
9570           if(spCellLst->list.array[cellIdx]!=NULLP)
9571           {
9572              free(spCellLst->list.array[cellIdx]);
9573           }
9574        }
9575        free(spCellLst->list.array);
9576     }
9577 }
9578 /*******************************************************************
9579 *
9580 * @brief free the memory allocated by decoder
9581 *
9582 * @details
9583 *
9584 *    Function : freeAperDecodeSRBSetup
9585 *
9586 *    Functionality: added free part for the memory allocated by aper_decoder
9587 *
9588 * @params[in] SRBs_ToBeSetup_List_t *srbSet
9589 * @return void
9590 *
9591 ****************************************************************/
9592
9593
9594 void freeAperDecodeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
9595 {
9596     uint8_t srbIdx =0;
9597     if(srbSet->list.array != NULLP)
9598     {
9599        for(srbIdx=0; srbIdx<srbSet->list.count; srbIdx++)
9600        {
9601           if(srbSet->list.array[srbIdx]!=NULLP)
9602           {
9603              free(srbSet->list.array[srbIdx]);
9604           }
9605        }
9606        free(srbSet->list.array);
9607     }
9608 }
9609
9610 /*******************************************************************
9611 *
9612 * @brief free the memory allocated by decoder
9613 *
9614 * @details
9615 *
9616 *    Function : freeAperDecodeULTnlInfo
9617 *
9618 *    Functionality: added free part for the memory allocated by aper_decoder
9619 *
9620 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
9621 * @return void
9622 *
9623 * ****************************************************************/
9624
9625
9626 void freeAperDecodeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
9627 {
9628    uint8_t ulIdx=0;
9629    if(ulInfo->list.array != NULLP)
9630    {
9631       for(ulIdx=0; ulIdx<ulInfo->list.count; ulIdx++)
9632       {
9633          if(ulIdx==0&&ulInfo->list.array[ulIdx]!=NULLP)
9634          {
9635             if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
9636             {
9637                if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9638                      transportLayerAddress.buf != NULLP)
9639                {
9640                   if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
9641                         !=NULLP)
9642                   {
9643                      free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf);
9644                   }
9645                   free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9646                         transportLayerAddress.buf);
9647                }
9648                free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel);
9649             }
9650          }
9651          if(ulInfo->list.array[ulIdx]!=NULLP)
9652          {
9653             free(ulInfo->list.array[ulIdx]);
9654          }
9655       }
9656       free(ulInfo->list.array);
9657    }
9658 }
9659 /*******************************************************************
9660 *
9661 * @brief free the memory allocated by decoder
9662 *
9663 * @details
9664 *
9665 *    Function : freeAperDecodeDRBSetup
9666 *
9667 *    Functionality: free DRBSetup which is allocated by decoder
9668 *
9669 * @params[in]  DRBs_ToBeSetup_List_t *drbSet
9670 * @return void
9671 *
9672 * ****************************************************************/
9673
9674 void freeAperDecodeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
9675 {
9676    DRBs_ToBeSetup_Item_t *drbSetItem = NULLP;
9677    uint8_t  flowIdx =0;
9678    uint8_t  drbIdx =0;
9679
9680    if(drbSet->list.array != NULLP)
9681    {
9682       for(drbIdx=0; drbIdx<drbSet->list.count; drbIdx++)
9683       {
9684          if(drbIdx==0&&drbSet->list.array[drbIdx] != NULLP)
9685          {
9686             drbSetItem =&drbSet->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
9687             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
9688             {
9689                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9690                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
9691                {
9692                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9693                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9694                   {
9695                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9696                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9697                      {
9698
9699                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
9700                         {
9701
9702                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
9703                            {
9704
9705                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->\
9706                                     buf!=NULLP)
9707                               {
9708
9709                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
9710                                        flows_Mapped_To_DRB_List.list.array != NULLP)
9711                                  {
9712
9713                                     for(flowIdx=0;flowIdx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9714                                           DRB_Information.flows_Mapped_To_DRB_List.list.count; flowIdx++)
9715                                     {
9716
9717                                        if(flowIdx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9718                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9719                                        {
9720                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9721                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9722                                                 qoSFlowLevelQoSParameters.\
9723                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
9724                                           {
9725                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9726                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9727                                                    qoSFlowLevelQoSParameters.\
9728                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9729                                              {
9730
9731                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9732                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9733                                                       qoSFlowLevelQoSParameters.\
9734                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9735                                                 {
9736
9737
9738                                                    free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9739                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9740                                                          qoSFlowLevelQoSParameters.\
9741                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9742                                                 }
9743
9744                                                 free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9745                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9746                                                       qoSFlowLevelQoSParameters.\
9747                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9748                                              }
9749
9750                                              free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9751
9752                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9753                                                    qoSFlowLevelQoSParameters.\
9754                                                    qoS_Characteristics.choice.non_Dynamic_5QI);
9755                                           }
9756                                        }
9757                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9758                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9759                                        {
9760
9761                                           free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9762                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]);
9763                                        }
9764                                     }
9765
9766                                     free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9767                                           DRB_Information.flows_Mapped_To_DRB_List.list.array);
9768                                  }
9769
9770                                  free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9771                                        DRB_Information.sNSSAI.sD->buf);
9772                               }
9773
9774                               free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD);
9775                            }
9776
9777                            free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf);
9778
9779                         }
9780
9781                         free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9782
9783                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9784                      }
9785
9786                      free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9787                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9788                   }
9789
9790                   free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9791                         qoS_Characteristics.choice.non_Dynamic_5QI);
9792                }
9793                free(drbSetItem->qoSInformation.choice.choice_extension);
9794             }
9795             freeAperDecodeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
9796             if(drbSetItem->uLConfiguration)
9797             {
9798                free(drbSetItem->uLConfiguration);
9799             }
9800          }
9801          if(drbSet->list.array[drbIdx]!=NULLP)
9802          {
9803             free(drbSet->list.array[drbIdx]);
9804          }
9805       }
9806       free(drbSet->list.array);
9807    }
9808 }
9809
9810
9811 /*******************************************************************
9812  *
9813  * @brief builds Mac Cell Cfg
9814  *
9815  * @details
9816  *
9817  *    Function : procUeReCfgCellInfo
9818  *
9819  *    Functionality: builds Mac Cell Cfg
9820  *
9821  * @params[in] MacUeCfg *macUeCfgToSend = Used to Store the information which
9822  *                       needs to send in other layer, as well as this can be
9823  *                       the variable which stores the information in DuCb.
9824  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
9825  *                       information to other layer else it will have copyOfmacUeCfg
9826  *                       which we have stored in F1UeContextSetupDb
9827  *             void *cellInfo = CellGroupConfigRrc_t information which is send
9828  *                        by CU, which we have stored in F1UeContextSetupDb
9829  *
9830  * @return void
9831  *
9832  * ****************************************************************/
9833 uint8_t procUeReCfgCellInfo(MacUeCfg *macUeCfgToSend,MacUeCfg *storedMacUeCfg, void *cellInfo)
9834 {
9835    uint8_t ret = ROK;
9836    CellGroupConfigRrc_t *cellGrp = NULLP;
9837
9838    if(cellInfo)
9839    {
9840       cellGrp = (CellGroupConfigRrc_t *)cellInfo;
9841       ret = extractUeReCfgCellInfo(cellGrp, macUeCfgToSend, storedMacUeCfg);
9842       if(ret == RFAILED)
9843          DU_LOG("\nERROR  -->  F1AP : Failed at procUeReCfgCellInfo()");
9844    }
9845    if(ret == RFAILED)
9846    {
9847       freeUeReCfgCellGrpInfo(macUeCfgToSend);
9848    }
9849    return ret;
9850 }
9851
9852 /*******************************************************************
9853  *
9854  * @brief Filling modulation info in mac ue cfg
9855  *
9856  * @details
9857  *
9858  *    Function : duFillModulationDetails
9859  *
9860  *    Functionality: Filling modulation info in mac ue cfg
9861  *
9862  * @params[in] MAC UE Config to be updated
9863  *             Current UE configuration
9864  *             UE NR capability from CU
9865  * @return ROK     - success
9866  *         RFAILED - failure
9867  *
9868  * ****************************************************************/
9869 void duFillModulationDetails(MacUeCfg *ueCfg, MacUeCfg *oldUeCfg, void *ueCap)
9870 {
9871    UE_NR_Capability_t *ueNrCap=NULLP;
9872
9873    if(!ueCap)
9874    {
9875       memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9876       memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9877    }
9878    else
9879    {
9880       ueNrCap = (UE_NR_Capability_t *)ueCap;
9881
9882       /* Filling DL modulation info */
9883       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsDownlinkPerCC && \
9884          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0] && \
9885          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL)
9886       {
9887          switch(*(ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL))
9888          {
9889             case ModulationOrder_qpsk:
9890                {
9891                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
9892                   break;
9893                }
9894             case ModulationOrder_qam16:
9895                {
9896                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM16;
9897                   break;
9898                }
9899             case ModulationOrder_qam64:
9900                {
9901                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM64;
9902                   ueCfg->dlModInfo.mcsIndex = PDSCH_MCS_INDEX;
9903                   ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64;
9904                   break;
9905                }
9906             case ModulationOrder_qam256:
9907                {
9908                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM256;
9909                   break;
9910                }
9911             default:
9912                {
9913                   DU_LOG("\nERROR  -->  DU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
9914                   memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9915                   break;
9916                }
9917          }
9918       }
9919       else
9920       {
9921          memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9922       }
9923
9924       /* Filling UL modulation info */
9925       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsUplinkPerCC && \
9926          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0] && \
9927          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL)
9928       {
9929          switch(*(ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL))
9930          {
9931             case ModulationOrder_qpsk:
9932                {
9933                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
9934                   break;
9935                }
9936             case ModulationOrder_qam16:
9937                {
9938                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM16;
9939                   ueCfg->ulModInfo.mcsIndex = PUSCH_MCS_INDEX;
9940                   ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64;
9941                   break;
9942                }
9943             case ModulationOrder_qam64:
9944                {
9945                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM64;
9946                   break;
9947                }
9948             case ModulationOrder_qam256:
9949                {
9950                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM256;
9951                   break;
9952                }
9953             default:
9954                {
9955                   DU_LOG("\nERROR  -->  DU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
9956                   memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9957                   break;
9958                }
9959          }
9960       }
9961       else
9962       {
9963          memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9964       }
9965    }
9966 }
9967
9968 /*******************************************************************
9969  *
9970  * @brief Function to extract cellGrp Info present in cutoDu cont
9971  *
9972  * @details
9973  *
9974  *    Function : extractCellGrpInfo
9975  *
9976  *    Functionality: Function to extract cellGrp Info present
9977  *                   in cutoDu cont
9978  *
9979  * @params[in] ProtocolExtensionContainer_4624P16_t pointer
9980  *
9981  * @return CellGroupConfigRrc_t *
9982  *
9983  * ****************************************************************/
9984
9985 CellGroupConfigRrc_t *extractCellGrpInfo(ProtocolExtensionContainer_4624P16_t *protocolIeExtn,\
9986       DuUeCfg *ueCfgDb)
9987 {
9988    uint8_t idx2 =0;
9989    uint16_t id =0;
9990    uint16_t recvBufLen =0;
9991    CellGroupConfigRrc_t *cellGrpCfg = NULLP;
9992    CUtoDURRCInformation_ExtIEs_t *extIeInfo = NULLP;
9993    asn_dec_rval_t rval; /* Decoder return value */
9994    memset(&rval, 0, sizeof(asn_dec_rval_t));
9995
9996    if(protocolIeExtn)
9997    {
9998       for(idx2 = 0; idx2 < protocolIeExtn->list.count; idx2++)
9999       {
10000          extIeInfo = ((CUtoDURRCInformation_ExtIEs_t *)(protocolIeExtn->list.array[idx2]));
10001          id = extIeInfo->id;
10002          switch(id)
10003          {
10004             case ProtocolIE_ID_id_CellGroupConfig:
10005             {
10006                recvBufLen = extIeInfo->extensionValue.choice.CellGroupConfig.size;
10007                /* decoding the CellGroup Buf received */
10008                DU_ALLOC(cellGrpCfg, sizeof(CellGroupConfigRrc_t));
10009                if(cellGrpCfg)
10010                {
10011                   memset(cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
10012                   rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfg,
10013                      extIeInfo->extensionValue.choice.CellGroupConfig.buf, recvBufLen, 0, 0);
10014                   if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10015                   {
10016                      DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
10017                      return NULLP;
10018                   }
10019                   xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfg);
10020                   if(extractRlcCfgToAddMod(cellGrpCfg->rlc_BearerToAddModList, ueCfgDb))
10021                      return NULLP;
10022                }
10023                break;
10024             }
10025             default:
10026                DU_LOG("\nERROR  -->  F1AP : Invalid IE received CUtoDURRCInformation:%d at decodeCellGrpCfg()", id);
10027                break;
10028          }
10029       }
10030    }
10031    return cellGrpCfg;
10032 }
10033
10034 /*******************************************************************
10035  *
10036  * @brief Fills Srb List received by CU
10037  *
10038  * @details
10039  *
10040  *    Function : procSrbListToSetup
10041  *
10042  *    Functionality: Fills Srb List received  by CU
10043  *
10044  * @params[in] SRBs_ToBeSetup_Item_t *cuSrbItem
10045  *             LcCfg pointer
10046  *             RlcBearerCfg pointer
10047  * @return void
10048  *
10049  * ****************************************************************/
10050 uint8_t procSrbListToSetup(SRBs_ToBeSetup_Item_t * srbItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd)
10051 {
10052
10053    /* Filling RLC INFO */
10054    procRlcLcCfg(srbItem->sRBID, srbItem->sRBID, RB_TYPE_SRB, RLC_AM, CONFIG_ADD, NULL, rlcLcToAdd, NULL);
10055
10056    /* Filling MAC INFO */
10057    if(procMacLcCfg(srbItem->sRBID, RB_TYPE_SRB, CONFIG_ADD, NULL,NULL, NULL, NULL, macLcToAdd, NULL)  != ROK)
10058    {
10059       DU_LOG("\nERROR  -->  F1AP : Failed at MAC LC Cfg in procSrbListToSetup()");
10060       return RFAILED;
10061    }
10062
10063    return ROK;
10064 }
10065
10066
10067
10068 /*******************************************************************
10069  *
10070  * @brief extract Srb List received by CU
10071  *
10072  * @details
10073  *
10074  *    Function : extractSrbListToSetup
10075  *
10076  *    Functionality: extract Srb List received by CU
10077  *                   for both MAC and RLC
10078  *
10079  * @params[in] SRBs_ToBeSetup_Item_t pointer
10080  *             DuUeCfg pointer
10081  * @return ROK/RFAIED
10082  *
10083  * ****************************************************************/
10084
10085 uint8_t extractSrbListToSetup(SRBs_ToBeSetup_List_t *srbCfg, DuUeCfg *ueCfgDb)
10086 {
10087    uint8_t ret, srbIdx;
10088    SRBs_ToBeSetup_Item_t *srbItem = NULLP;
10089
10090    if(srbCfg)
10091    {
10092       for(srbIdx = 0; srbIdx < srbCfg->list.count; srbIdx++)
10093       {
10094          srbItem = &srbCfg->list.array[srbIdx]->value.choice.SRBs_ToBeSetup_Item;
10095          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
10096          {
10097             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in MAC");
10098             ret = RFAILED;
10099             break;
10100          }
10101          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
10102          {
10103             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in RLC");
10104             ret = RFAILED;
10105             break;
10106          }
10107          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
10108          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
10109          ret = procSrbListToSetup(srbItem, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
10110             &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs]);
10111          ueCfgDb->numRlcLcs++;
10112          ueCfgDb->numMacLcs++;
10113          DU_LOG("\nDEBUG --> DUAPP: extractSrbListToSetup: SRBID: %d [RLC,MAC,NumDrb]:[%x,%x,%x]",\
10114                             srbItem->sRBID, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
10115          if(ret == RFAILED)
10116          {
10117             DU_LOG("\nERROR  -->  F1AP:  Failed at extractSrbListToSetup()");
10118             break;
10119          }
10120       }
10121    }
10122    else
10123       ret = RFAILED;
10124
10125    return ret;
10126 }
10127
10128 /*******************************************************************
10129  *
10130  * @brief Fills Drb List received by CU
10131  *
10132  * @details
10133  *
10134  *    Function : procDrbListToSetupMod
10135  *
10136  *    Functionality: Fills Drb List received by CU
10137  *                   for both MAC and RLC
10138  *
10139  * @params[in] DRBs_ToBeSetup_Item_t , DRBs_ToBeSetupMod_Item_t,
10140  *             DRBs_ToBeModified_Item_t , lcId, LcCfg pointer,
10141  *             RlcBearerCfg , UpTnlCfg, RlcUeCfg
10142  * @return void
10143  *
10144  * ****************************************************************/
10145
10146 uint8_t procDrbListToSetupMod(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbItem,\
10147 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd, UpTnlCfg *upTnlInfo, RlcUeCfg *storedRlcUeCfg)
10148 {
10149    uint8_t cfgIdx = 0;
10150    RlcMode rlcModeInfo;
10151
10152    if(drbItem != NULLP)
10153    {
10154       /* Filling RLC INFO */
10155       procRlcLcCfg(drbItem->dRBID, lcId, RB_TYPE_DRB, drbItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd, &drbItem->\
10156       qoSInformation);
10157
10158       /* Filling MAC INFO */
10159       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, drbItem, NULL, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
10160       {
10161          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
10162          return RFAILED;
10163       }
10164    }
10165    else if(drbSetupModItem != NULLP)
10166    {
10167       procRlcLcCfg(drbSetupModItem->dRBID, lcId, RB_TYPE_DRB, drbSetupModItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd,
10168       &drbSetupModItem->qoSInformation);
10169
10170       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, NULL, drbSetupModItem, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
10171       {
10172          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
10173          return RFAILED;
10174       }
10175    }
10176    else if(drbModItem != NULLP)
10177    {
10178       /* Drb to Mod IEs doesnot have rlcMode to be modified
10179        * in ASN. Hence no change in RLC configurations */
10180       if(storedRlcUeCfg != NULLP)
10181       {
10182          for(cfgIdx = 0; cfgIdx < storedRlcUeCfg->numLcs; cfgIdx++)
10183          {
10184             if(storedRlcUeCfg->rlcLcCfg[cfgIdx].lcId == lcId)
10185             {
10186                rlcModeInfo = storedRlcUeCfg->rlcLcCfg[cfgIdx].rlcMode;
10187                break;
10188             }
10189          }
10190       }
10191
10192       procRlcLcCfg(drbModItem->dRBID, lcId, RB_TYPE_DRB, rlcModeInfo, CONFIG_MOD, NULL, rlcLcToAdd, drbModItem->qoSInformation);
10193       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_MOD, NULL, NULL, drbModItem, NULL, macLcToAdd, upTnlInfo) != ROK)
10194       {
10195          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
10196          return RFAILED;
10197       }
10198    }
10199    return ROK;
10200 }
10201
10202 /*******************************************************************
10203  *
10204  * @brief extract Drb List received by CU
10205  *
10206  * @details
10207  *
10208  *    Function : extractDrbListToSetupMod
10209  *
10210  *    Functionality: extract Drb List received by CU
10211  *                   for both MAC and RLC
10212  *
10213  * @params[in] DRBs_ToBeSetup_Item_t pointer
10214  *             DuUeCfg pointer
10215  * @return ROK/RFAIED
10216  *
10217  * ****************************************************************/
10218
10219 uint8_t extractDrbListToSetupMod(DRBs_ToBeSetup_List_t *drbCfg, DRBs_ToBeSetupMod_List_t *drbSetupModCfg,\
10220  DRBs_ToBeModified_List_t *drbModCfg, uint8_t drbCount, DuUeCfg *ueCfgDb, uint32_t *drbBitMap, RlcUeCfg *rlcUeCfg)
10221 {
10222    uint8_t ret, drbIdx, lcId = 0;
10223    DRBs_ToBeSetup_Item_t *drbItem = NULLP;
10224    DRBs_ToBeSetupMod_ItemIEs_t *drbSetupModItem = NULLP;
10225    DRBs_ToBeModified_ItemIEs_t *drbModItem = NULLP;
10226
10227    ret = ROK;
10228    if(drbCount > 0)
10229    {
10230       for(drbIdx = 0; drbIdx < drbCount; drbIdx++)
10231       {
10232          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
10233          {
10234             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in MAC at extractDrbListToSetupMod()");
10235             ret = RFAILED;
10236             break;
10237          }
10238          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
10239          {
10240             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in RLC at extractDrbListToSetupMod()");
10241             ret = RFAILED;
10242             break;
10243          }
10244          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
10245          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
10246
10247          if(drbModCfg != NULLP)
10248          {
10249             drbModItem = (DRBs_ToBeModified_ItemIEs_t *) drbModCfg->list.array[drbIdx];
10250             lcId = fetchLcId(drbModItem->value.choice.DRBs_ToBeModified_Item.dRBID);
10251             if(lcId < MIN_DRB_LCID)
10252             {
10253                DU_LOG("\nERROR  --> F1AP : Failed fetching LCID %d in extractDrbListToSetupMod() for Modified List", lcId);
10254                break;
10255             }
10256             ret = procDrbListToSetupMod(lcId, NULL, NULL, &(drbModItem->value.choice.DRBs_ToBeModified_Item),\
10257             &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs],\
10258             &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
10259             if(ret == RFAILED)
10260             {
10261                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for Modified List");
10262                break;
10263             }
10264
10265          }
10266          else
10267          {
10268             lcId = getDrbLcId(drbBitMap);
10269             if(lcId == RFAILED)
10270             {
10271                DU_LOG("\nERROR  -->  F1AP :  InCorrect LCID extractDrbListToSetupMod()");
10272                ret = RFAILED;
10273                break;
10274             }
10275             if(drbCfg != NULL)
10276             {
10277                drbItem = &drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
10278                ret = procDrbListToSetupMod(lcId, drbItem, NULL, NULL, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
10279                      &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
10280                if(ret == RFAILED)
10281                {
10282                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetup List");
10283                   break;
10284                }
10285             }
10286             else if(drbSetupModCfg != NULL)
10287             {
10288                drbSetupModItem = (DRBs_ToBeSetupMod_ItemIEs_t *) drbSetupModCfg->list.array[drbIdx];
10289                ret = procDrbListToSetupMod(lcId, NULL, &(drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item), NULL,\
10290                      &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs],\
10291                      &ueCfgDb->upTnlInfo[ueCfgDb->numDrb], rlcUeCfg);
10292                if(ret == RFAILED)
10293                {
10294                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetupMod List");
10295                   break;
10296                }
10297             }
10298          }
10299          ueCfgDb->numRlcLcs++;
10300          ueCfgDb->numMacLcs++;
10301          ueCfgDb->numDrb++;
10302
10303          DU_LOG("\nDEBUG --> DUAPP: extractDrbListToSetupMod:lcId:%x ,BitMap:%x, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
10304                             lcId,*drbBitMap, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
10305          if(ret == RFAILED)
10306          {
10307             DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod()");
10308             break;
10309          }
10310       }
10311    }
10312    else
10313       ret = RFAILED;
10314
10315    return ret;
10316 }
10317
10318 /*******************************************************************
10319  *
10320  * @brief Function to extract Dl RRC Msg received from CU
10321  *
10322  * @details
10323  *
10324  *    Function : extractDlRrcMsg
10325  *
10326  *    Functionality: Function to extract Dl RRC Msg received from CU
10327  *
10328  * @params[in] F1AP message
10329  * @return ROK     - success
10330  *         RFAILED - failure
10331  *
10332  * ****************************************************************/
10333
10334 uint8_t extractDlRrcMsg(uint32_t gnbDuUeF1apId, uint32_t gnbCuUeF1apId, \
10335    F1DlRrcMsg *dlRrcMsg, RRCContainer_t *rrcContainer)
10336 {
10337    uint8_t ret = ROK;
10338    dlRrcMsg->rrcMsgSize = rrcContainer->size;
10339    if(dlRrcMsg->rrcMsgSize > 0)
10340    {
10341       DU_ALLOC_SHRABL_BUF(dlRrcMsg->rrcMsgPdu, dlRrcMsg->rrcMsgSize);
10342       if(!dlRrcMsg->rrcMsgPdu)
10343       {
10344          DU_LOG("\nERROR  --> DU APP : Memory allocation failed for RRC Msg in extractDlRrcMsg()");
10345          ret = RFAILED;
10346       }
10347       else
10348       {
10349          dlRrcMsg->gnbDuUeF1apId = gnbDuUeF1apId;
10350          dlRrcMsg->gnbCuUeF1apId = gnbCuUeF1apId;
10351          dlRrcMsg->srbId = SRB1_LCID;
10352          memcpy(dlRrcMsg->rrcMsgPdu, rrcContainer->buf, dlRrcMsg->rrcMsgSize);
10353       }
10354    }
10355    return ret;
10356 }
10357
10358 /*******************************************************************
10359  *
10360  * @brief Extract UE capability info
10361  *
10362  * @details
10363  *
10364  *    Function : extractUeCapability
10365  *
10366  *    Functionality: Extract UE capability info and stores in ue Cb
10367  *
10368  * @params[in] Octet string of UE capability RAT container list
10369  * @return ROK     - success
10370  *         RFAILED - failure
10371  *
10372  * ****************************************************************/
10373 UE_NR_Capability_t *extractUeCapability(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf, DuUeCb *ueCb)
10374 {
10375    uint8_t  idx;
10376    uint16_t recvBufLen;
10377    asn_dec_rval_t rval;
10378    UE_NR_Capability_t  *ueNrCap = NULLP;
10379    UE_CapabilityRAT_ContainerListRRC_t  *ueCapRatContList = NULLP;
10380
10381    /* Decoding UE Capability RAT Container List */
10382    recvBufLen = ueCapablityListBuf->size;
10383    DU_ALLOC(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10384    if(!ueCapRatContList)
10385    {
10386       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
10387       return NULLP;
10388    }
10389    memset(ueCapRatContList, 0, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10390    memset(&rval, 0, sizeof(asn_dec_rval_t));
10391    rval = aper_decode(0, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, (void **)&ueCapRatContList,
10392           ueCapablityListBuf->buf, recvBufLen, 0, 0);
10393    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10394    {
10395       DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
10396       return NULLP;
10397    }
10398    xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, ueCapRatContList);
10399
10400    /* Free encoded buffer after decoding */
10401
10402    for(idx = 0; idx < ueCapRatContList->list.count; idx++)
10403    {
10404       if(ueCapRatContList->list.array[idx]->rat_Type == RAT_Type_nr)
10405       {
10406          /* Decoding UE NR Capability */
10407           recvBufLen = ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.size;
10408           DU_ALLOC(ueNrCap, sizeof(UE_NR_Capability_t));
10409           if(!ueNrCap)
10410           {
10411              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
10412              DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10413              return NULLP;
10414           }
10415           memset(ueNrCap, 0, sizeof(UE_NR_Capability_t));
10416           memset(&rval, 0, sizeof(asn_dec_rval_t));
10417           rval = aper_decode(0, &asn_DEF_UE_NR_Capability, (void **)&ueNrCap,
10418                  ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf, recvBufLen, 0, 0);
10419           if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10420           {
10421              DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
10422              return NULLP;
10423           }
10424           xer_fprint(stdout, &asn_DEF_UE_NR_Capability, ueNrCap);
10425
10426           /* Free encoded buffer after decoding */
10427           free(ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf);
10428       }
10429       free(ueCapRatContList->list.array[idx]);
10430    }
10431
10432    /* Free Memory*/
10433    free(ueCapRatContList->list.array);
10434    DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10435    return ueNrCap;
10436 }
10437
10438 /*******************************************************************
10439 *
10440 * @brief free UE context setup request from CU
10441 *
10442 * @details
10443 *
10444 *    Function : freeAperDecodeF1UeContextSetupReq
10445 *
10446 *    Functionality: freeing part for the memory allocated by aper_decoder
10447 *
10448 * @params[in] F1AP message
10449 * @return ROK     - success
10450 *         RFAILED - failure
10451 *
10452 * ****************************************************************/
10453 void freeAperDecodeF1UeContextSetupReq(UEContextSetupRequest_t   *ueSetReq)
10454 {
10455    uint8_t ieIdx = 0;
10456
10457    if(ueSetReq->protocolIEs.list.array != NULLP)
10458    {
10459       for(ieIdx = 0; ieIdx < ueSetReq->protocolIEs.list.count; ieIdx++)
10460       {
10461          if(ueSetReq->protocolIEs.list.array[ieIdx])
10462          {
10463             switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
10464             {
10465                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10466                   break;
10467                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10468                   break;
10469                case ProtocolIE_ID_id_SpCell_ID:
10470                   freeAperDecodeNrcgi(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
10471                   break;
10472                case ProtocolIE_ID_id_ServCellIndex:
10473                   break;
10474                case ProtocolIE_ID_id_SpCellULConfigured:
10475                   break;
10476                case ProtocolIE_ID_id_CUtoDURRCInformation:
10477
10478                   freeAperDecodeCuToDuInfo(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation);
10479                   break;
10480                case ProtocolIE_ID_id_SCell_ToBeSetup_List:
10481
10482                   freeAperDecodeSplCellList(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SCell_ToBeSetup_List);
10483                   break;
10484                case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
10485
10486                   freeAperDecodeSRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List);
10487                   break;
10488                case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
10489
10490                   freeAperDecodeDRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List);
10491                   break;
10492                case ProtocolIE_ID_id_RRCContainer:
10493                   {
10494
10495                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf != NULLP)
10496                      {
10497
10498                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
10499                      }
10500                      break;
10501                   }
10502                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10503                   break;
10504                case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
10505                   {
10506                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf)
10507                      {
10508                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf);
10509                      }
10510                      break;
10511                   }
10512                default:
10513                   DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld " ,ueSetReq->protocolIEs.list.array[ieIdx]->id);
10514             }
10515             free(ueSetReq->protocolIEs.list.array[ieIdx]);
10516          }
10517       }
10518       free(ueSetReq->protocolIEs.list.array);
10519    }
10520 }
10521 /*******************************************************************
10522  *
10523  * @brief Process UE context setup request from CU
10524  *
10525  * @details
10526  *
10527  *    Function : procF1UeContextSetupReq
10528  *
10529  *    Functionality: Process UE context setup request from CU
10530  *
10531  * @params[in] F1AP message
10532  * @return ROK     - success
10533  *         RFAILED - failure
10534  *
10535  * ****************************************************************/
10536 uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
10537 {
10538    uint8_t  ret=0, ieIdx=0, ueIdx=0, cellIdx=0;
10539    bool ueCbFound = false;
10540    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0, bitRateSize=0;
10541    DuUeCb   *duUeCb = NULL;
10542    UEContextSetupRequest_t   *ueSetReq = NULL;
10543    DRBs_ToBeSetup_List_t *drbCfg = NULL;
10544
10545    ret = ROK;
10546
10547    ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
10548    for(ieIdx=0; (ieIdx < ueSetReq->protocolIEs.list.count && ret == ROK); ieIdx++)
10549    {
10550       switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
10551       {
10552          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10553             {
10554                gnbCuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
10555                break;
10556             }
10557          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10558             {
10559                gnbDuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
10560                break;
10561             }
10562          case ProtocolIE_ID_id_ServCellIndex:
10563             {
10564                cellIdx = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.ServCellIndex;
10565                for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
10566                {
10567                   if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
10568                         (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
10569                   {
10570                      ueCbFound = true;
10571                      duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
10572                      DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
10573                      if(duUeCb->f1UeDb)
10574                      {
10575                         memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
10576                         duUeCb->f1UeDb->actionType = UE_CTXT_SETUP;
10577                         duUeCb->f1UeDb->cellIdx = cellIdx;
10578                      }
10579                      else
10580                      {
10581                         DU_LOG("\nERROR  -->  F1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
10582                         ret = RFAILED;
10583                      }
10584                      break;
10585                   }
10586                   else
10587                      ueCbFound = false;
10588
10589                }
10590                if(!ueCbFound)
10591                {
10592                   DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
10593                   ret = RFAILED;
10594                }
10595                break;
10596             }
10597          case ProtocolIE_ID_id_SpCellULConfigured:
10598             /* Indicates whether the gNB-CU requests the gNB-DU to configure the uplink as no UL,
10599                UL, SUL or UL+SUL for the indicated cell for the UE */
10600             break;
10601          case ProtocolIE_ID_id_CUtoDURRCInformation:
10602             {
10603                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.uE_CapabilityRAT_ContainerList)
10604                {
10605                   duUeCb->f1UeDb->duUeCfg.ueNrCapability = \
10606                   extractUeCapability(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.\
10607                   uE_CapabilityRAT_ContainerList, duUeCb);
10608                }
10609                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.iE_Extensions)
10610                {
10611                   duUeCb->f1UeDb->duUeCfg.cellGrpCfg = extractCellGrpInfo(ueSetReq->protocolIEs.list.array[ieIdx]->\
10612                         value.choice.CUtoDURRCInformation.iE_Extensions, &duUeCb->f1UeDb->duUeCfg);
10613                   if(!duUeCb->f1UeDb->duUeCfg.cellGrpCfg)
10614                   {
10615                      DU_LOG("\nERROR  -->  F1AP: Failed to extract cell Grp Info");
10616                      //TODO: Update the failure cause in ue context Setup Response
10617                      ret = RFAILED;
10618                   }
10619                }
10620                break;
10621             }
10622          case ProtocolIE_ID_id_SCell_ToBeSetup_List:
10623             {
10624                DU_LOG("\nINFO   -->  DU_APP: Received SCell_ToBeSetup_List but  Not processing the list");
10625                break;
10626             }
10627          case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
10628             {
10629                if(extractSrbListToSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List,\
10630                &duUeCb->f1UeDb->duUeCfg))
10631                {
10632                   DU_LOG("\nERROR  -->  DU APP : Failed at extractSrbListToSetup()");
10633                   //TODO: Update the failure cause in ue context Setup Response
10634                   ret = RFAILED;
10635                }
10636                break;
10637             }
10638          case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
10639             {
10640                   drbCfg = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List;
10641
10642                   if(extractDrbListToSetupMod(drbCfg, NULL, NULL, drbCfg->list.count, &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, NULLP))
10643                   {
10644                      DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod()");
10645                      //TODO: Update the failure cause in ue context Setup Response
10646                      ret = RFAILED;
10647                   }
10648                break;
10649             }
10650          case ProtocolIE_ID_id_RRCContainer:
10651             {
10652                /* Filling Dl RRC Msg Info */
10653                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
10654                if(!duUeCb->f1UeDb->dlRrcMsg)
10655                {
10656                   DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
10657                   ret = RFAILED;
10658                }
10659                else
10660                {
10661                   duUeCb->f1UeDb->dlRrcMsgPres = true;
10662                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
10663                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
10664                         &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer);
10665                }
10666                break;
10667             }
10668          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10669             {
10670                if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
10671                {
10672                   duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
10673                }
10674                else
10675                {
10676                   DU_LOG("\nERROR  -->  Ignoring delivery report, since rrcContainer is not present");
10677                }
10678                break;
10679             }
10680          case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
10681             {
10682                /* MaximumBitRate Uplink */
10683                bitRateSize = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.size;
10684                if(bitRateSize > 0)
10685                {
10686                   DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.ambrCfg, bitRateSize);
10687                   if(!duUeCb->f1UeDb->duUeCfg.ambrCfg)
10688                   {
10689                      DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
10690                      ret = RFAILED;
10691                   }
10692                   else
10693                   {
10694                      memset(duUeCb->f1UeDb->duUeCfg.ambrCfg, 0, sizeof(AmbrCfg));
10695                      memcpy(&duUeCb->f1UeDb->duUeCfg.ambrCfg->ulBr,
10696                            ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf, bitRateSize);
10697                   }
10698                }
10699                else
10700                   ret = RFAILED;
10701                break;
10702             }
10703          default:
10704             {
10705                break;
10706             }
10707       }
10708    }
10709    if(ret == RFAILED)
10710    {
10711       /*TODO : Negative case*/
10712       // BuildAndSendUeContextSetupRsp(cellId,ueIdx);
10713       DU_LOG("\nERROR  -->  F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
10714    }
10715    else
10716       ret = duProcUeContextSetupRequest(duUeCb);
10717
10718    freeAperDecodeF1UeContextSetupReq(ueSetReq);
10719    return ret;
10720
10721 }
10722 /*******************************************************************
10723  * @brief Free the memory allocated for Dl Tunnel Info
10724  *
10725  * @details
10726  *
10727  *    Function : freeDlTnlInfo
10728  *
10729  *    Functionality:
10730  *       Free the memory allocated for Dl Tunnel Info
10731  *
10732  * @params[in] DLUPTNLInformation_ToBeSetup_List_t *
10733  * @return void
10734  *
10735  * ****************************************************************/
10736
10737 void freeDlTnlInfo(DLUPTNLInformation_ToBeSetup_List_t *tnlInfo)
10738 {
10739    uint8_t arrIdx = 0;
10740
10741    if(tnlInfo)
10742    {
10743       for(arrIdx=0; arrIdx < tnlInfo->list.count; arrIdx++)
10744       {
10745          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf,\
10746                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
10747          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf,\
10748                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
10749          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
10750          DU_FREE(tnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
10751       }
10752       DU_FREE(tnlInfo->list.array, tnlInfo->list.size);
10753    }
10754 }
10755
10756 /*******************************************************************
10757  * @brief Free the memory allocated for DRB setup List
10758  *
10759  * @details
10760  *
10761  *    Function : freeDrbSetupList
10762  *
10763  *    Functionality:
10764  *       Free the memory allocated for DRB setup list
10765  *
10766  * @params[in] DRBs_Setup_List_t *
10767  * @return void
10768  *
10769  * ****************************************************************/
10770 void freeDrbSetupList(DRBs_Setup_List_t *drbSetupList)
10771 {
10772    uint8_t arrIdx = 0;
10773    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
10774
10775    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
10776    {
10777       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
10778       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
10779       DU_FREE(drbSetupList->list.array[arrIdx],  sizeof(DRBs_Setup_Item_t));
10780    }
10781    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
10782 }
10783
10784 /*******************************************************************
10785  * @brief Free the memory allocated for UE Setup response
10786  *
10787  * @details
10788  *
10789  *    Function : FreeUeContextSetupRsp
10790  *
10791  *    Functionality:
10792  *       Free the memory allocated for UE Setup response
10793  *
10794  * @params[in] F1AP PDU for UE setup response
10795  * @return ROK     - success
10796  *         RFAILED - failure
10797  *
10798  * ****************************************************************/
10799 void FreeUeContextSetupRsp(F1AP_PDU_t *f1apMsg)
10800 {
10801    uint8_t idx;
10802    UEContextSetupResponse_t *ueSetRsp = NULLP;
10803
10804    if(f1apMsg)
10805    {
10806       if(f1apMsg->choice.successfulOutcome)
10807       {
10808          ueSetRsp = &f1apMsg->choice.successfulOutcome->value.choice.\
10809                     UEContextSetupResponse;
10810          if(ueSetRsp->protocolIEs.list.array)
10811          {
10812             for(idx = 0; idx < ueSetRsp->protocolIEs.list.count; idx++)
10813             {
10814                if(ueSetRsp->protocolIEs.list.array[idx])
10815                {
10816                   switch(ueSetRsp->protocolIEs.list.array[idx]->id)
10817                   {
10818                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10819                         break;
10820                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10821                         break;
10822                      case ProtocolIE_ID_id_DUtoCURRCInformation:
10823                         {
10824                            CellGroupConfig_t *cellGrpCfg = NULLP;
10825                            cellGrpCfg  = &ueSetRsp->protocolIEs.list.array[idx]->value.choice.\
10826                                          DUtoCURRCInformation.cellGroupConfig;
10827                            if(cellGrpCfg->buf != NULLP)
10828                            {
10829                               DU_FREE(cellGrpCfg->buf, cellGrpCfg->size);
10830                               cellGrpCfg = NULLP;
10831                            }
10832                            break;
10833                         }
10834                     case ProtocolIE_ID_id_DRBs_Setup_List:
10835                         {
10836                            freeDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
10837                            break;
10838                         }
10839                      default:
10840                         DU_LOG("\nERROR  -->  DUAPP: Invalid Id %ld at FreeUeContextSetupRsp()",\
10841                         ueSetRsp->protocolIEs.list.array[idx]->id);
10842                         break;
10843                   }
10844                   DU_FREE(ueSetRsp->protocolIEs.list.array[idx],\
10845                         sizeof(UEContextSetupResponseIEs_t));
10846                }
10847             }
10848             DU_FREE(ueSetRsp->protocolIEs.list.array, \
10849                   ueSetRsp->protocolIEs.list.size);
10850          }
10851          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
10852       }
10853       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10854    }
10855 }
10856
10857 /*******************************************************************
10858  *
10859  * @brief Builds Ue context Setup Rsp DU To CU Info
10860  *
10861  * @details
10862  *
10863  *    Function : EncodeUeCntxtDuToCuInfo
10864  *
10865  *    Functionality: Builds Ue context Setup Rsp DU To CU Info
10866  *
10867  * @params[in] CellGroupConfig_t *, CellGroupConfigRrc_t *
10868  *
10869  * @return ROK     - success
10870  *         RFAILED - failure
10871  *
10872  ******************************************************************/
10873
10874 uint8_t EncodeUeCntxtDuToCuInfo(CellGroupConfig_t *duToCuCellGrp, CellGroupConfigRrc_t *duCellGrpCfg)
10875 {
10876    asn_enc_rval_t        encRetVal;
10877
10878    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, duCellGrpCfg);
10879    memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
10880    encBufSize = 0;
10881    encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, duCellGrpCfg, PrepFinalEncBuf, encBuf);
10882    /* Encode results */
10883    if(encRetVal.encoded == ENCODE_FAIL)
10884    {
10885       DU_LOG( "\nERROR  -->  F1AP : Could not encode UeCntxtDuToCuInfo (at %s)\n",\
10886             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10887       return RFAILED;
10888    }
10889    else
10890    {
10891       DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
10892       for(int i=0; i< encBufSize; i++)
10893       {
10894          printf("%x",encBuf[i]);
10895       }
10896    }
10897    duToCuCellGrp->size = encBufSize;
10898    DU_ALLOC(duToCuCellGrp->buf, duToCuCellGrp->size);
10899    if(!duToCuCellGrp->buf)
10900    {
10901       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in UeCntxtDuToCuInfo");
10902    }
10903    memcpy(duToCuCellGrp->buf, encBuf, duToCuCellGrp->size);
10904    return ROK;
10905 }
10906
10907 /*******************************************************************
10908  *
10909  * @brief Fills Dl Gtp tunnel Info
10910  *
10911  * @details
10912  *
10913  *    Function : fillGtpTunnelforDl
10914  *
10915  *    Functionality: Fills Dl Gtp tunnel Info
10916  *
10917  * @params[in]
10918  *
10919  * @return ROK     - success
10920  *         RFAILED - failure
10921  *
10922  * ****************************************************************/
10923
10924 uint8_t fillGtpTunnelforDl(GTPTunnel_t *gtpDl, GtpTnlCfg *gtpUeCfg)
10925 {
10926    uint8_t bufSize = 0;
10927
10928    gtpDl->transportLayerAddress.size    = 4*sizeof(uint8_t);
10929    DU_ALLOC(gtpDl->transportLayerAddress.buf, gtpDl->transportLayerAddress.size);
10930    if(gtpDl->transportLayerAddress.buf == NULLP)
10931    {
10932       return RFAILED;
10933    }
10934    memcpy(gtpDl->transportLayerAddress.buf, &gtpUeCfg->dlTnlAddress, gtpDl->transportLayerAddress.size);
10935
10936    /*GTP TEID*/
10937    gtpDl->gTP_TEID.size = 4 * sizeof(uint8_t);
10938    DU_ALLOC(gtpDl->gTP_TEID.buf, gtpDl->gTP_TEID.size);
10939    if(gtpDl->gTP_TEID.buf == NULLP)
10940    {
10941       return RFAILED;
10942    }
10943    bufSize = 3; /*forming an Octect String*/
10944    fillTeIdString(bufSize, gtpUeCfg->teId, gtpDl->gTP_TEID.buf);
10945
10946    return ROK;
10947 }
10948
10949 /*******************************************************************
10950  *
10951  * @brief Fills DL Tunnel Setup List
10952  *
10953  * @details
10954  *
10955  *    Function : fillDlTnlSetupList
10956  *
10957  *    Functionality: Fills the DL Tunnel Setup List
10958  *
10959  * @params[in]
10960  *
10961  * @return ROK     - success
10962  *         RFAILED - failure
10963  *
10964  * ****************************************************************/
10965
10966 uint8_t fillDlTnlSetupList(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo, UpTnlCfg *tnlCfg)
10967 {
10968    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
10969
10970    eleCount = 1;
10971    dlTnlInfo->list.count = eleCount;
10972    dlTnlInfo->list.size = (eleCount * sizeof(DLUPTNLInformation_ToBeSetup_Item_t *));
10973
10974    /* Initialize the DL Tnl Setup List Members */
10975    DU_ALLOC(dlTnlInfo->list.array, dlTnlInfo->list.size);
10976    if(dlTnlInfo->list.array == NULLP)
10977    {
10978       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL Tnl Setup List in fillDlTnlSetupList()");
10979       ret = RFAILED;
10980    }
10981    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
10982    {
10983       DU_ALLOC(dlTnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
10984       if(dlTnlInfo->list.array[arrIdx] == NULLP)
10985       {
10986          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDlTnlSetupList()", arrIdx);
10987          return RFAILED;
10988       }
10989       dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
10990       DU_ALLOC(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
10991       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel == NULLP)
10992       {
10993          DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL tunnel info in fillDlTnlSetupList()");
10994          return RFAILED;
10995       }
10996       ret = fillGtpTunnelforDl(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel,\
10997                tnlCfg->tnlCfg1);
10998       if(ret != ROK)
10999          break;
11000    }
11001    return ret;
11002 }
11003
11004 /*******************************************************************
11005  *
11006  * @brief Fills the Drb Setup List for Ue Context Setup Response
11007  *
11008  * @details
11009  *
11010  *    Function : fillDrbSetupList
11011  *
11012  *    Functionality: Fills the Drb Setup List for Ue Context Setup Response
11013  *
11014  * @params[in]
11015  *
11016  * @return ROK     - success
11017  *         RFAILED - failure
11018  *
11019  * ****************************************************************/
11020 uint8_t fillDrbSetupList(DRBs_Setup_List_t *drbSetupList, DuUeCfg *ueCfg)
11021 {
11022    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
11023    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
11024
11025    eleCount = ueCfg->numDrb;
11026    drbSetupList->list.count = eleCount;
11027    drbSetupList->list.size = \
11028         (eleCount * sizeof(DRBs_Setup_Item_t *));
11029
11030    /* Initialize the Drb Setup List Members */
11031    DU_ALLOC(drbSetupList->list.array, drbSetupList->list.size);
11032    if(drbSetupList->list.array == NULLP)
11033    {
11034       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DRB Setup List in fillDrbSetupList()");
11035       ret = RFAILED;
11036    }
11037
11038    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
11039    {
11040       DU_ALLOC(drbSetupList->list.array[arrIdx], sizeof(DRBs_Setup_Item_t));
11041       if(drbSetupList->list.array[arrIdx] == NULLP)
11042       {
11043          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDrbSetupList()", arrIdx);
11044          return RFAILED;
11045       }
11046       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
11047       drbItemIe->id = ProtocolIE_ID_id_DRBs_Setup_Item;
11048       drbItemIe->criticality = Criticality_reject;
11049       drbItemIe->value.present = DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item;
11050       drbItemIe->value.choice.DRBs_Setup_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
11051       ret = fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List,\
11052           &ueCfg->upTnlInfo[arrIdx]);
11053       if(ret != ROK)
11054          break;
11055    }
11056    return ret;
11057 }
11058
11059 /*******************************************************************
11060  *
11061  * @brief Builds and sends the UE Setup Response
11062  *
11063  * @details
11064  *
11065  *    Function : BuildAndSendUeContextSetupRsp
11066  *
11067  *    Functionality: Constructs the UE Setup Response and sends
11068  *                   it to the DU through SCTP.
11069  *
11070  * @params[in] uint8_t cellId,uint8_t ueIdx
11071  *
11072  * @return ROK     - success
11073  *         RFAILED - failure
11074  *
11075  * ****************************************************************/
11076 uint8_t BuildAndSendUeContextSetupRsp(uint8_t cellId,uint8_t ueIdx)
11077 {
11078    uint8_t   idx, ret, cellIdx, elementCnt;
11079    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
11080    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
11081    asn_enc_rval_t  encRetVal;        /* Encoder return value */
11082    F1AP_PDU_t               *f1apMsg = NULLP;
11083    UEContextSetupResponse_t *ueSetRsp = NULLP;
11084    CellGroupConfigRrc_t     *cellGrpCfg = NULLP;
11085    DuUeCb                   *ueCb = NULLP;
11086
11087    DU_LOG("\n INFO   -->  F1AP : Building UE Context Setup Response for cellId %d, ueIdx %d\n", cellId, ueIdx);
11088
11089    while(true)
11090    {
11091       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11092       if(f1apMsg == NULLP)
11093       {
11094          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11095          ret = RFAILED;
11096          break;
11097       }
11098
11099       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
11100       DU_ALLOC(f1apMsg->choice.successfulOutcome,
11101             sizeof(SuccessfulOutcome_t));
11102       if(f1apMsg->choice.successfulOutcome == NULLP)
11103       {
11104          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
11105          ret = RFAILED;
11106          break;
11107       }
11108
11109       f1apMsg->choice.successfulOutcome->procedureCode = \
11110                                                          ProcedureCode_id_UEContextSetup;
11111       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
11112       f1apMsg->choice.successfulOutcome->value.present = \
11113                                                          SuccessfulOutcome__value_PR_UEContextSetupResponse;
11114
11115       ueSetRsp =
11116          &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
11117       elementCnt = 4;
11118       ueSetRsp->protocolIEs.list.count = elementCnt;
11119       ueSetRsp->protocolIEs.list.size = \
11120                                         elementCnt * sizeof(UEContextSetupResponse_t *);
11121
11122       /* Initialize the UESetup members */
11123       DU_ALLOC(ueSetRsp->protocolIEs.list.array, \
11124             ueSetRsp->protocolIEs.list.size);
11125       if(ueSetRsp->protocolIEs.list.array == NULLP)
11126       {
11127          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
11128          ret = RFAILED;
11129          break;
11130       }
11131
11132       for(idx=0; idx<elementCnt; idx++)
11133       {
11134          DU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
11135                sizeof(UEContextSetupResponseIEs_t));
11136          if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
11137          {
11138             DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
11139             ret = RFAILED;
11140             break;
11141          }
11142       }
11143       /* Fetching Ue Cb Info*/
11144       GET_CELL_IDX(cellId, cellIdx);
11145       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
11146       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
11147       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
11148
11149       idx = 0;
11150       /*GNB CU UE F1AP ID*/
11151       ueSetRsp->protocolIEs.list.array[idx]->id = \
11152                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11153       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11154       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
11155                                                              UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
11156       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
11157
11158       /*GNB DU UE F1AP ID*/
11159       idx++;
11160       ueSetRsp->protocolIEs.list.array[idx]->id = \
11161                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11162       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11163       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
11164                                                              UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
11165       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
11166
11167
11168       /*DUtoCURRC Information */
11169       idx++;
11170       ueSetRsp->protocolIEs.list.array[idx]->id  = \
11171                                                    ProtocolIE_ID_id_DUtoCURRCInformation;
11172       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11173       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
11174                                                             UEContextSetupResponseIEs__value_PR_DUtoCURRCInformation;
11175       if(ueCb->f1UeDb)
11176       {
11177          if(ueCb->f1UeDb->duUeCfg.cellGrpCfg)
11178          {
11179             cellGrpCfg = (CellGroupConfigRrc_t*)ueCb->f1UeDb->duUeCfg.cellGrpCfg;
11180             ret = EncodeUeCntxtDuToCuInfo(&ueSetRsp->protocolIEs.list.array[idx]->value.\
11181                      choice.DUtoCURRCInformation.cellGroupConfig, cellGrpCfg);
11182             if(ret == RFAILED)
11183             {
11184                DU_LOG("\nERROR  -->  F1AP : Failed to EncodeUeCntxtDuToCuInfo in BuildAndSendUeContextSetupRsp()");
11185                freeF1UeDb(ueCb->f1UeDb);
11186                ueCb->f1UeDb = NULLP;
11187                break;
11188             }
11189          }
11190       }
11191       else
11192       {
11193          DU_LOG("\nERROR  -->  F1AP : Failed to form DUtoCU RRCInfo at BuildAndSendUeContextSetupRsp()");
11194          ret = RFAILED;
11195          break;
11196       }
11197
11198       /* Drb Setup List */
11199       idx++;
11200       ueSetRsp->protocolIEs.list.array[idx]->id  = \
11201                                  ProtocolIE_ID_id_DRBs_Setup_List;
11202       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11203       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
11204                                  UEContextSetupResponseIEs__value_PR_DRBs_Setup_List;
11205       ret = fillDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List,\
11206                &ueCb->f1UeDb->duUeCfg);
11207       if(ret == RFAILED)
11208       {
11209          DU_LOG("\nERROR  -->  F1AP : Failed to fillDrbSetupList in BuildAndSendUeContextSetupRsp()");
11210          freeF1UeDb(ueCb->f1UeDb);
11211          ueCb->f1UeDb = NULLP;
11212          break;
11213       }
11214
11215        /* Free UeContext Db created during Ue context Req */
11216        freeF1UeDb(ueCb->f1UeDb);
11217        ueCb->f1UeDb = NULLP;
11218
11219       /* TODO: To send Drb list */
11220       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11221
11222       /* Encode the UE context setup response type as APER */
11223       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
11224       encBufSize = 0;
11225       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11226             encBuf);
11227       /* Encode results */
11228       if(encRetVal.encoded == ENCODE_FAIL)
11229       {
11230          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Response structure (at %s)\n",\
11231                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11232          ret = RFAILED;
11233          break;
11234       }
11235       else
11236       {
11237          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Setup Response\n");
11238          for(int i=0; i< encBufSize; i++)
11239          {
11240             printf("%x",encBuf[i]);
11241          }
11242       }
11243
11244       /* Sending  msg  */
11245       if(sendF1APMsg()  != ROK)
11246       {
11247          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Response failed");
11248          ret = RFAILED;
11249          break;
11250       }
11251       break;
11252    }
11253    FreeUeContextSetupRsp(f1apMsg);
11254    return ret;
11255 }/* End of BuildAndSendUeContextSetupRsp */
11256 /*******************************************************************
11257 *
11258 * @brief  Build And Send Ue Context Rsp
11259 *
11260 * @details
11261 *
11262 *    Function : BuildAndSendUeCtxtRsp
11263 *
11264 *    Functionality : Build And Send Ue Context Rsp
11265
11266 * @params[in]
11267 * @return sucess = ROK
11268 *         failure = RFAILED
11269 *
11270 * ****************************************************************/
11271 uint8_t BuildAndSendUeCtxtRsp(uint8_t cellId, uint8_t ueIdx)
11272 {
11273    uint8_t cellIdx = 0, actionType = 0;
11274
11275    GET_CELL_IDX(cellId, cellIdx);
11276    actionType = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].f1UeDb->actionType;
11277
11278    switch(actionType)
11279    {
11280       case UE_CTXT_SETUP:
11281          {
11282             BuildAndSendUeContextSetupRsp(cellId,ueIdx);
11283             break;
11284          }
11285       case UE_CTXT_MOD:
11286          {
11287             BuildAndSendUeContextModRsp(cellId, ueIdx);
11288             break;
11289          }
11290       default:
11291          DU_LOG("ERROR  -->  F1AP: Invalid Action Type %d at BuildAndSendUeCtxtRsp()", actionType);
11292          break;
11293
11294    }
11295    return ROK;
11296 }
11297
11298 /*******************************************************************
11299  *
11300  * @brief deallocating the memory of  F1reset msg
11301  *
11302  * @details
11303  *
11304  *    Function : FreeF1ResetReq
11305  *
11306  *    Functionality :
11307  *         - freeing memory of F1reset request msg
11308  *
11309  * @params[in]
11310  * @return void
11311  *
11312  *
11313  * ****************************************************************/
11314 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
11315 {
11316    uint8_t idx =0 ;
11317    Reset_t *f1ResetMsg;
11318
11319    if(f1apMsg)
11320    {
11321       if(f1apMsg->choice.initiatingMessage)
11322       {
11323          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11324
11325          if(f1ResetMsg->protocolIEs.list.array)
11326          {
11327             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
11328             {
11329                if(f1ResetMsg->protocolIEs.list.array[idx])
11330                {
11331                   DU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
11332                }
11333             }
11334             DU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
11335          }
11336          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11337       }
11338       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11339    }
11340 }
11341 /*******************************************************************
11342  *
11343  * @brief Build and Send F1reset request
11344  *
11345  * @details
11346  *
11347  *    Function : BuildAndSendF1ResetReq
11348  *
11349  *    Functionality:
11350  *         - Build and Send F1reset request msg
11351  *
11352  * @params[in]
11353  * @return ROK     - success
11354  *         RFAILED - failure
11355  *
11356  * ****************************************************************/
11357 uint8_t BuildAndSendF1ResetReq()
11358 {
11359    uint8_t          elementCnt=0;
11360    uint8_t          idx=0;
11361    uint8_t          ret= RFAILED;
11362    Reset_t          *f1ResetMsg = NULLP;
11363    F1AP_PDU_t       *f1apMsg = NULLP;
11364    asn_enc_rval_t   encRetVal;
11365    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset request \n");
11366    do
11367    {
11368       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11369       if(f1apMsg == NULLP)
11370       {
11371          break;
11372       }
11373       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
11374       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11375       if(f1apMsg->choice.initiatingMessage == NULLP)
11376       {
11377          break;
11378       }
11379       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
11380       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
11381       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
11382
11383       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11384
11385       elementCnt = 3;
11386       f1ResetMsg->protocolIEs.list.count = elementCnt;
11387       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
11388
11389       /* Initialize the F1Setup members */
11390       DU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
11391       if(f1ResetMsg->protocolIEs.list.array == NULLP)
11392       {
11393          break;
11394       }
11395       for(idx=0; idx<elementCnt; idx++)
11396       {
11397          DU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
11398          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
11399          {
11400             break;
11401          }
11402       }
11403
11404       /*TransactionID*/
11405       idx=0;
11406       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
11407       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11408       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
11409       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
11410
11411       /*Cause*/
11412       idx++;
11413       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
11414       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
11415       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
11416       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
11417       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
11418
11419       /*Reset Type*/
11420       idx++;
11421       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
11422       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11423       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
11424       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
11425       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
11426
11427       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11428
11429       /* Encode the F1SetupRequest type as APER */
11430       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11431       encBufSize = 0;
11432       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11433             encBuf);
11434
11435       /* Encode results */
11436       if(encRetVal.encoded == ENCODE_FAIL)
11437       {
11438          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
11439                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11440          break;
11441       }
11442       else
11443       {
11444          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1Reset\n");
11445          for(idx=0; idx< encBufSize; idx++)
11446          {
11447             printf("%x",encBuf[idx]);
11448          }
11449       }
11450
11451       if(sendF1APMsg() != ROK)
11452       {
11453          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
11454          break;
11455       }
11456
11457       ret = ROK;
11458       break;
11459    }while(true);
11460
11461    FreeF1ResetReq(f1apMsg);
11462    return ret;
11463 }
11464 /*******************************************************************
11465  *
11466  * @brief Build And Send F1ResetAck
11467  *
11468  * @details
11469  *
11470  *    Function : BuildAndSendF1ResetAck
11471  *
11472  *    Functionality:
11473  *         - Build And Send  F1ResetRSP
11474  *
11475  * @return ROK     - success
11476  *         RFAILED - failure
11477  *
11478  * ****************************************************************/
11479 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
11480 {
11481    uint8_t idx;
11482    ResetAcknowledge_t *f1ResetAck;
11483
11484    if(f1apMsg)
11485    {
11486       if(f1apMsg->choice.successfulOutcome)
11487       {
11488          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
11489
11490          if(f1ResetAck->protocolIEs.list.array)
11491          {
11492             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
11493             {
11494                if(f1ResetAck->protocolIEs.list.array[idx])
11495                {
11496                   DU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
11497                }
11498             }
11499             DU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
11500          }
11501          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11502       }
11503       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11504    }
11505 }
11506
11507 /*******************************************************************
11508  *
11509  * @brief Build And Send F1ResetAck
11510  *
11511  * @details
11512  *
11513  *    Function : BuildAndSendF1ResetAck
11514  *
11515  *    Functionality:
11516  *         - Build And Send  F1ResetRSP
11517  *
11518  *  @params[in]
11519  * @return ROK     - success
11520  *         RFAILED - failure
11521  *
11522  * ****************************************************************/
11523 uint8_t BuildAndSendF1ResetAck()
11524 {
11525    uint8_t                idx = 0;
11526    uint8_t                elementCnt = 0;
11527    uint8_t                ret = RFAILED;
11528    F1AP_PDU_t             *f1apMsg = NULL;
11529    ResetAcknowledge_t     *f1ResetAck = NULLP;
11530    asn_enc_rval_t         encRetVal;
11531    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset Acknowledgment \n");
11532
11533    do{
11534       /* Allocate the memory for F1ResetRequest_t */
11535       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11536       if(f1apMsg == NULLP)
11537       {
11538          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11539          break;
11540       }
11541
11542       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
11543
11544       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11545       if(f1apMsg->choice.successfulOutcome == NULLP)
11546       {
11547          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11548          break;
11549       }
11550       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
11551       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
11552       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
11553
11554       elementCnt = 1;
11555
11556       f1ResetAck->protocolIEs.list.count = elementCnt;
11557       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
11558
11559       DU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
11560       if(f1ResetAck->protocolIEs.list.array == NULLP)
11561       {
11562          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
11563          break;
11564       }
11565
11566       for(idx=0; idx<elementCnt; idx++)
11567       {
11568          DU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
11569          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
11570          {
11571             break;
11572          }
11573       }
11574       /*TransactionID*/
11575       idx = 0;
11576       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
11577       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11578       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
11579       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
11580
11581       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11582
11583       /* Encode the F1SetupRequest type as UPER */
11584       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11585       encBufSize = 0;
11586       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
11587
11588       /* Check encode results */
11589       if(encRetVal.encoded == ENCODE_FAIL)
11590       {
11591          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
11592                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11593          break;
11594       }
11595       else
11596       {
11597          DU_LOG("\nDUBUG   -->  F1AP : Created APER encoded buffer for F1ResetAck\n");
11598          for(int i=0; i< encBufSize; i++)
11599          {
11600             printf("%x",encBuf[i]);
11601          }
11602       }
11603       /* Sending msg */
11604       if(sendF1APMsg() != ROK)
11605       {
11606          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Acknowledgement failed");
11607          break;
11608       }
11609
11610       ret = ROK;
11611       break;
11612    }while(true);
11613
11614    FreeF1ResetAck(f1apMsg);
11615    return ret;
11616 }
11617 /******************************************************************
11618 *
11619 * @brief free F1 reset msg allocated by aper_decoder
11620 *
11621 * @details
11622 *
11623 *    Function : freeAperDecodeF1ResetMsg
11624 *
11625 *    Functionality: free F1 reset msg allocated by aper_decoder
11626 *
11627 * @params[in] Reset_t *f1ResetMsg
11628 * @return void
11629 *
11630 * ****************************************************************/
11631
11632 void freeAperDecodeF1ResetMsg(Reset_t *f1ResetMsg)
11633 {
11634    uint8_t ieIdx =0;
11635    if(f1ResetMsg->protocolIEs.list.array)
11636    {
11637       for(ieIdx=0 ;ieIdx < f1ResetMsg->protocolIEs.list.count ; ieIdx++)
11638       {
11639          if(f1ResetMsg->protocolIEs.list.array[ieIdx])
11640          {
11641             free(f1ResetMsg->protocolIEs.list.array[ieIdx]);
11642          }
11643       }
11644       free(f1ResetMsg->protocolIEs.list.array);
11645    }
11646 }
11647
11648 /******************************************************************
11649  *
11650  * @brief Processes DL RRC Message Transfer  sent by CU
11651  *
11652  * @details
11653  *
11654  *    Function : procF1ResetReq
11655  *
11656  *    Functionality: Processes DL RRC Message Transfer sent by CU
11657  *
11658  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11659  * @return ROK     - success
11660  *         RFAILED - failure
11661  *
11662  * ****************************************************************/
11663 uint8_t procF1ResetReq(F1AP_PDU_t *f1apMsg)
11664 {
11665    /* we are currently not supporting Ue release. right now we are supporting only init case of fireset */
11666    uint8_t       ieIdx = 0;
11667    uint8_t        ret = ROK;
11668    Reset_t       *f1ResetMsg = NULLP;
11669
11670    DU_LOG("\nINFO   -->  Processing F1 reset request");
11671    f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11672
11673    for(ieIdx=0; ieIdx<f1ResetMsg->protocolIEs.list.count; ieIdx++)
11674    {
11675       switch(f1ResetMsg->protocolIEs.list.array[ieIdx]->id)
11676       {
11677          case ProtocolIE_ID_id_TransactionID:
11678             break;
11679
11680          case ProtocolIE_ID_id_Cause:
11681             break;
11682
11683          case ProtocolIE_ID_id_ResetType:
11684             {
11685                break;
11686             }
11687
11688          default:
11689             break;
11690       }
11691    }
11692    ret = BuildAndSendF1ResetAck();
11693    DU_LOG("\nINFO   -->  UE release is not supported for now");
11694
11695    freeAperDecodeF1ResetMsg(f1ResetMsg);
11696
11697    return ret;
11698 }
11699
11700 /*******************************************************************
11701  *
11702  * @brief free the RRC delivery report
11703  *
11704  * @details
11705  *
11706  *    Function : freeRrcDeliveryReport
11707  *
11708  *    Functionality: free the RRC delivery report
11709  *
11710  * @params[in]
11711  * @return ROK     - success
11712  *         RFAILED - failure
11713  *
11714  * ****************************************************************/
11715 void freeRrcDeliveryReport(F1AP_PDU_t  *f1apMsg )
11716 {
11717    uint8_t idx=0;
11718    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11719
11720    if(f1apMsg)
11721    {
11722       if(f1apMsg->choice.initiatingMessage)
11723       {
11724          rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11725          if(rrcDeliveryReport->protocolIEs.list.array)
11726          {
11727             for(idx =0 ;idx <rrcDeliveryReport->protocolIEs.list.count ;
11728                   idx++)
11729             {
11730                if(rrcDeliveryReport->protocolIEs.list.array[idx])
11731                {
11732                   DU_FREE(rrcDeliveryReport->protocolIEs.list.array[idx],
11733                         sizeof(RRCDeliveryReportIEs_t));
11734                }
11735             }
11736             DU_FREE(rrcDeliveryReport->protocolIEs.list.array,
11737                   rrcDeliveryReport->protocolIEs.list.size);
11738          }
11739          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11740       }
11741       DU_FREE(f1apMsg,
11742             sizeof(F1AP_PDU_t));
11743    }
11744 }
11745
11746 /*******************************************************************
11747 *
11748 * @brief Builds and sends the RRC delivery report
11749 *
11750 * @details
11751 *
11752 *    Function : BuildAndSendRrcDeliveryReport
11753 *
11754 *    Functionality: Builds and sends the RRC delivery report
11755 *
11756 * @params[in]
11757 *
11758 * @return ROK     - success
11759 *         RFAILED - failure
11760 *
11761 * ****************************************************************/
11762 uint8_t BuildAndSendRrcDeliveryReport(uint32_t gnbCuUeF1apId, \
11763    uint32_t gnbDuUeF1apId, RrcDeliveryReport *rrcDelivery)
11764 {
11765    uint8_t             ret = RFAILED;
11766    uint8_t             idx    = 0;
11767    uint8_t             idx1   = 0;
11768    uint8_t             elementCnt = 0;
11769    F1AP_PDU_t          *f1apMsg = NULLP;
11770    asn_enc_rval_t      encRetVal;
11771    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11772
11773    do{
11774
11775       DU_LOG("\nINFO   -->  F1AP : Building RRC delivery Message Transfer Message\n");
11776       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11777       if(f1apMsg == NULLP)
11778       {
11779          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11780          break;
11781       }
11782       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
11783       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11784       if(f1apMsg->choice.initiatingMessage == NULLP)
11785       {
11786          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU  failed");
11787          break;
11788       }
11789       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_RRCDeliveryReport;
11790       f1apMsg->choice.initiatingMessage->criticality   = Criticality_ignore;
11791       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RRCDeliveryReport;
11792
11793       rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11794       elementCnt = 4;
11795       rrcDeliveryReport->protocolIEs.list.count = elementCnt;
11796       rrcDeliveryReport->protocolIEs.list.size = elementCnt * sizeof(RRCDeliveryReportIEs_t *);
11797
11798       /* Initialize the F1Setup members */
11799       DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array, rrcDeliveryReport->protocolIEs.list.size);
11800       if(rrcDeliveryReport->protocolIEs.list.array == NULLP)
11801       {
11802          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRC Delivery  failed");
11803          break;
11804       }
11805       for(idx =0 ;idx <elementCnt; idx++)
11806       {
11807          DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array[idx], sizeof(RRCDeliveryReportIEs_t));
11808          if(rrcDeliveryReport->protocolIEs.list.array[idx] == NULLP)
11809          {
11810             break;
11811          }
11812       }
11813
11814       idx1 = 0;
11815
11816       /*GNB CU UE F1AP ID*/
11817       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11818       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
11819       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_CU_UE_F1AP_ID;
11820       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
11821
11822       /*GNB DU UE F1AP ID*/
11823       idx1++;
11824       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11825       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
11826       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_DU_UE_F1AP_ID;
11827       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
11828
11829       /*RRC delivery status*/
11830       idx1++;
11831       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_RRCDeliveryStatus;
11832       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
11833       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_RRCDeliveryStatus;
11834       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.delivery_status =\
11835       rrcDelivery->rrcDeliveryStatus.deliveryStatus;
11836       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.triggering_message =\
11837       rrcDelivery->rrcDeliveryStatus.triggeringMessage;
11838
11839       /* SRB ID */
11840       idx1++;
11841       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
11842       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
11843       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_SRBID;
11844       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.SRBID =  rrcDelivery->srbId;
11845
11846       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11847
11848       /* Encode the RRC DELIVERY REPORT type as APER */
11849       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11850       encBufSize = 0;
11851       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11852             encBuf);
11853
11854       /* Encode results */
11855       if(encRetVal.encoded == ENCODE_FAIL)
11856       {
11857          DU_LOG("\nERROR  -->  F1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
11858                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11859          break;
11860       }
11861       else
11862       {
11863          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for RRC Delivery Msg \n");
11864          for(idx=0; idx< encBufSize; idx++)
11865          {
11866             printf("%x",encBuf[idx]);
11867          }
11868       }
11869
11870       /* Sending msg */
11871       if(sendF1APMsg() != ROK)
11872       {
11873          DU_LOG("\nERROR  -->  F1AP : Sending RRC delivery  msg request failed");
11874          break;
11875       }
11876       ret = ROK;
11877       break;
11878
11879    }while(true);
11880
11881    freeRrcDeliveryReport(f1apMsg);
11882    return ret;
11883 }
11884
11885 /*******************************************************************
11886  *
11887  * @brief Processes cells to be activated
11888  *
11889  * @details
11890  *
11891  *    Function : extractCellsToBeActivated
11892  *
11893  *    Functionality:
11894  *      - Processes cells to be activated list received in F1SetupRsp
11895  *
11896  * @params[in] void
11897  * @return ROK     - success
11898  *         RFAILED - failure
11899  *
11900  * ****************************************************************/
11901
11902 uint8_t extractCellsToBeActivated(Cells_to_be_Activated_List_t cellsToActivate)
11903 {
11904    uint8_t  ret = ROK;
11905    uint16_t idx, nci, pci = 0;
11906    Cells_to_be_Activated_List_Item_t cell;
11907
11908    for(idx=0; idx<cellsToActivate.list.count; idx++)
11909    {
11910       nci = 0;
11911       cell = cellsToActivate.list.array[idx]->value.choice.Cells_to_be_Activated_List_Item;
11912       bitStringToInt(&cell.nRCGI.nRCellIdentity, &nci);
11913
11914       if(cell.nRPCI)
11915       {
11916          pci = *cell.nRPCI;
11917       }
11918       ret = duProcCellsToBeActivated(cell.nRCGI.pLMN_Identity.buf, nci, pci);
11919    }
11920    return ret;
11921 }
11922 /******************************************************************
11923 *
11924 * @brief Processes F1 Setup Response allocated by aper_decoder
11925 *
11926 * @details
11927 *
11928 *    Function : freeF1SetupRsp
11929 *
11930 *    Functionality: free F1 Setup Response allocated by aper_decoder
11931 *
11932 * @params[in] F1SetupResponse_t *f1SetRspMsg
11933 * @return void
11934 *
11935 * ****************************************************************/
11936
11937 void freeAperDecodeF1SetupRsp(F1SetupResponse_t *f1SetRspMsg)
11938 {
11939    uint8_t ieIdx =0;
11940    uint8_t arrIdx =0;
11941    Cells_to_be_Activated_List_t *cellToActivate =NULLP;
11942    RRC_Version_t      *rrcVer =NULLP;
11943
11944    if(f1SetRspMsg->protocolIEs.list.array)
11945    {
11946       for(ieIdx=0; ieIdx<f1SetRspMsg->protocolIEs.list.count; ieIdx++)
11947       {
11948          if(f1SetRspMsg->protocolIEs.list.array[ieIdx])
11949          {
11950             switch(f1SetRspMsg->protocolIEs.list.array[ieIdx]->id)
11951             {
11952                case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11953                   {
11954                      cellToActivate =
11955                         &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.Cells_to_be_Activated_List;
11956                      if(cellToActivate->list.array)
11957                      {
11958                         for(arrIdx=0; arrIdx<cellToActivate->list.count ; arrIdx++)
11959                         {
11960                            if(cellToActivate->list.array[arrIdx])
11961                            {
11962
11963                               if(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.\
11964                               pLMN_Identity.buf)
11965                               {
11966                                  if(cellToActivate->list.array[0]->value.choice.\
11967                                        Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf)
11968                                  {
11969                                     free(cellToActivate->list.array[0]->value.choice.\
11970                                           Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf);
11971                                  }
11972
11973                                  free(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
11974                                        nRCGI.pLMN_Identity.buf);
11975                               }
11976                               free(cellToActivate->list.array[arrIdx]);
11977                            }
11978                         }
11979                         free(cellToActivate->list.array);
11980                      }
11981                      break;
11982                   }
11983                case ProtocolIE_ID_id_TransactionID:
11984                   {
11985                      break;
11986                   }
11987                case ProtocolIE_ID_id_gNB_CU_Name:
11988                   {
11989                      free(f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_Name.buf);
11990                      break;
11991                   }
11992                case ProtocolIE_ID_id_GNB_CU_RRC_Version:
11993                   {
11994                      rrcVer = &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
11995                      if(rrcVer->latest_RRC_Version.buf)
11996                      {
11997                         if(rrcVer->iE_Extensions)
11998                         {
11999                            if(rrcVer->iE_Extensions->list.array)
12000                            {
12001                               if(rrcVer->iE_Extensions->list.array[0])
12002                               {
12003                                  if(rrcVer->iE_Extensions->list.\
12004                                        array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf)
12005                                  {
12006                                     free(rrcVer->iE_Extensions->list.\
12007                                           array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf);
12008                                  }
12009                                  free(rrcVer->iE_Extensions->list.array[0]);
12010                               }
12011                               free(rrcVer->iE_Extensions->list.array);
12012                            }
12013                            free(rrcVer->iE_Extensions);
12014                         }
12015                         free(rrcVer->latest_RRC_Version.buf);
12016                      }
12017                      break;
12018
12019                   }
12020                default:
12021                   {
12022                      DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
12023                            f1SetRspMsg->protocolIEs.list.array[ieIdx]->id);
12024                   }
12025             }
12026             free(f1SetRspMsg->protocolIEs.list.array[ieIdx]);
12027          }
12028       }
12029       free(f1SetRspMsg->protocolIEs.list.array);
12030    }
12031 }
12032 /******************************************************************
12033  *
12034  * @brief Processes F1 Setup Response sent by CU
12035  *
12036  * @details
12037  *
12038  *    Function : procF1SetupRsp
12039  *
12040  *    Functionality: Processes F1 Setup Response sent by CU
12041  *
12042  * @params[in] F1AP_PDU_t ASN decoded F1AP message
12043  * @return ROK     - success
12044  *         RFAILED - failure
12045  *
12046  * ****************************************************************/
12047 uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg)
12048 {
12049    uint8_t ret = ROK;
12050    uint16_t idx =0;
12051    F1SetupResponse_t *f1SetRspMsg = NULLP;
12052    GNB_CU_Name_t     *cuName = NULLP;
12053    F1SetupRsp  f1SetRspDb;
12054    RRC_Version_t      *rrcVer =NULLP;
12055
12056    memset(&f1SetRspDb, 0, sizeof(F1SetupRsp));
12057
12058    DU_LOG("\nINFO   -->  F1AP : F1 Setup Response received");
12059    f1SetRspMsg = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
12060
12061    for(idx=0; idx<f1SetRspMsg->protocolIEs.list.count; idx++)
12062    {
12063       switch(f1SetRspMsg->protocolIEs.list.array[idx]->id)
12064       {
12065          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
12066             {
12067                extractCellsToBeActivated(f1SetRspMsg->protocolIEs.list.array[idx]->\
12068                      value.choice.Cells_to_be_Activated_List);
12069                break;
12070             }
12071          case ProtocolIE_ID_id_TransactionID:
12072             {
12073                f1SetRspDb.transId = f1SetRspMsg->protocolIEs.list.array[idx]->\
12074                                     value.choice.TransactionID;
12075                break;
12076             }
12077          case ProtocolIE_ID_id_gNB_CU_Name:
12078             {
12079                cuName = &f1SetRspMsg->protocolIEs.list.array[idx]->\
12080                         value.choice.GNB_CU_Name;
12081                strcpy(f1SetRspDb.cuName, (const char*)cuName->buf);
12082                break;
12083             }
12084          case ProtocolIE_ID_id_GNB_CU_RRC_Version:
12085             {
12086                rrcVer = &f1SetRspMsg->protocolIEs.list.array[idx]->value.choice.RRC_Version;
12087                strcpy(f1SetRspDb.rrcVersion.rrcVer,
12088                      (const char*)rrcVer->latest_RRC_Version.buf);
12089                break;
12090             }
12091          default:
12092             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
12093                   f1SetRspMsg->protocolIEs.list.array[idx]->id);
12094       }
12095       duProcF1SetupRsp();
12096    }
12097
12098    freeAperDecodeF1SetupRsp(f1SetRspMsg);
12099    return ret;
12100 }
12101 /*******************************************************************
12102 *
12103 * @brief free GNB DU config update ack
12104 *
12105 * @details
12106 *
12107 *    Function : freeAperDecodeGnbDuAck
12108 *
12109 *    Functionality: Processes GNB DU config update ack And
12110 *                     added free part for the memory allocated by aper_decoder
12111 *
12112 * @params[in] F1AP_PDU_t ASN decoded F1AP message
12113 * @return ROK     - success
12114 *         RFAILED - failure
12115 *
12116 * ****************************************************************/
12117
12118 void freeAperDecodeGnbDuAck(GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck)
12119 {
12120    uint8_t ieIdx = 0;
12121
12122    if(gnbDuAck->protocolIEs.list.array)
12123    {
12124       for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
12125       {
12126          if(gnbDuAck->protocolIEs.list.array[ieIdx])
12127          {
12128             free(gnbDuAck->protocolIEs.list.array[ieIdx]);
12129          }
12130       }
12131       free(gnbDuAck->protocolIEs.list.array);
12132    }
12133 }
12134
12135 /*******************************************************************
12136 *
12137 * @brief Building  result of gnb-du config update ack output
12138 *
12139 * @details
12140 *
12141 *    Function : duProcGnbDuCfgUpdAckMsg
12142 *
12143 *    Functionality:
12144 *        Building output of gnb-du config update ack
12145 *
12146 * @params[in] transId
12147 * @return void
12148 *
12149 * ****************************************************************/
12150
12151 uint8_t duProcGnbDuCfgUpdAckMsg(uint8_t transId)
12152 {
12153    uint8_t  ieIdx=0, arrIdx=0,ret=ROK;
12154    uint8_t  ueId =0 , ueIdx =0;
12155    uint16_t cellId =0, cellIdx =0, crnti=0;
12156    CmLList *f1apPduNode = NULLP;
12157    ReservedF1apPduInfo *f1apPduInfo =NULLP;
12158    F1AP_PDU_t *f1apMsgPdu = NULLP;
12159    GNBDUConfigurationUpdate_t *gnbDuConfigUpdate = NULLP;
12160    BIT_STRING_t *cellIdentity=NULLP;
12161    struct Served_Cells_To_Delete_ItemIEs *deleteItemIe=NULLP;
12162    Served_Cells_To_Delete_List_t *cellsToDelete=NULLP;
12163    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
12164
12165    DU_LOG("\nINFO   -->  DU APP: GNB-DU config update Ack received ");
12166    f1apPduNode = searchFromReservedF1apPduList(transId);
12167    f1apPduInfo = (ReservedF1apPduInfo *)f1apPduNode->node;
12168    f1apMsgPdu = (F1AP_PDU_t *)f1apPduInfo->f1apMsg;
12169
12170    if(f1apMsgPdu)
12171    {
12172       if(f1apMsgPdu->choice.initiatingMessage)
12173       {
12174          gnbDuConfigUpdate = &f1apMsgPdu->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
12175          for(ieIdx=0; ieIdx < gnbDuConfigUpdate->protocolIEs.list.count; ieIdx++)
12176          {
12177             switch(gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->id)
12178             {
12179                case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
12180                   {
12181                      cellsToDelete = &gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
12182                                      Served_Cells_To_Delete_List;
12183                      if(cellsToDelete->list.array)
12184                      {
12185                         if(cellsToDelete->list.array[arrIdx])
12186                         {
12187                            deleteItemIe = (Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx];
12188                            deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
12189                            if(deleteItem->oldNRCGI.nRCellIdentity.buf)
12190                            {
12191                               cellIdentity = &deleteItem->oldNRCGI.nRCellIdentity;
12192                               bitStringToInt(cellIdentity, &cellId);
12193                            }
12194                         }
12195                      }
12196
12197                      GET_CELL_IDX(cellId, cellIdx);
12198                      if(duCb.actvCellLst[cellIdx] != NULLP)
12199                      {
12200                         if(duCb.actvCellLst[cellIdx]->numActvUes == 0)
12201                         {
12202                            duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
12203                            ret = duSendCellDeletReq(cellId);
12204                            if(ret == RFAILED)
12205                            {
12206                               DU_LOG("ERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to send cell delete\
12207                               request for cellId[%d]", cellId);
12208                            }
12209                         }
12210                         else
12211                         {
12212                            for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
12213                            {
12214                               crnti = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].crnti;
12215                               GET_UE_IDX(crnti,ueId);
12216                               ret = BuildAndSendUeContextReleaseReq(cellId, ueId);
12217                               if(ret == RFAILED)
12218                               {
12219                                  DU_LOG("ERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to build and send UE delete\
12220                                  request for cellId[%d]", cellId);
12221                               }
12222                            }
12223                         }
12224                      }
12225                      else
12226                      {
12227                         DU_LOG("ERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): CellId [%d] not found", cellId);
12228                         ret = RFAILED;
12229                      }
12230                      break;
12231                   }
12232
12233                default:
12234                   break;
12235             }
12236          }
12237       }
12238    }
12239
12240    FreeDUConfigUpdate(f1apMsgPdu);
12241    deleteFromReservedF1apPduList(f1apPduNode);
12242    return ret;
12243 }
12244
12245 /*******************************************************************
12246 *
12247 * @brief Processes GNB DU config update ack
12248 *
12249 * @details
12250 *
12251 *    Function : procF1GNBDUCfgUpdAck
12252 *
12253 *    Functionality: added free part for the memory allocated by aper_decoder
12254 *
12255 * @params[in] F1AP_PDU_t *f1apMsg
12256 * @return void
12257 *
12258 * ****************************************************************/
12259 uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
12260 {
12261    uint8_t ieIdx=0,transId=0;
12262    GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
12263
12264    DU_LOG("\nINFO   -->  F1AP : GNB-DU config update acknowledgment");
12265    gnbDuAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
12266
12267    for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
12268    {
12269       switch(gnbDuAck->protocolIEs.list.array[ieIdx]->id)
12270       {
12271          case ProtocolIE_ID_id_TransactionID:
12272             {
12273                transId = gnbDuAck->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
12274                break;
12275             }
12276          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
12277             {
12278                break;
12279             }
12280          default :
12281             {
12282                DU_LOG("\nERROR  -->  F1AP: procF1GNBDUCfgUpdAck(): Invalid IE Received: %ld", \
12283                      gnbDuAck->protocolIEs.list.array[ieIdx]->id);
12284                break;
12285             }
12286       }
12287    }
12288
12289    duProcGnbDuCfgUpdAckMsg(transId);
12290
12291 #if 0
12292    /* presently we are not supporting F1 Reset from DU to CU , we are only
12293     * supporting F1 Reset from CU to DU */
12294
12295    if(BuildAndSendF1ResetReq() != ROK)
12296    {
12297       return RFAILED;
12298    }
12299 #endif
12300
12301    freeAperDecodeGnbDuAck(gnbDuAck);
12302    return ROK;
12303 }
12304 /******************************************************************
12305 *
12306 * @brief free DL RRC Message Transfer allocated by aper_decoder
12307 *
12308 * @details
12309 *
12310 *    Function : freeAperDecodef1DlRrcMsg
12311 *
12312 *    Functionality: free DL RRC Message Transfer allocated by aper_decoder
12313 *
12314 * @params[in] DLRRCMessageTransfer_t *f1DlRrcMsg
12315 * @return ROK     - success
12316 *         RFAILED - failure
12317 *
12318 * ****************************************************************/
12319
12320 void freeAperDecodef1DlRrcMsg(DLRRCMessageTransfer_t *f1DlRrcMsg)
12321 {
12322    uint8_t ieIdx =0;
12323    RRCContainer_t *rrcContainer = NULLP;
12324
12325    if(f1DlRrcMsg->protocolIEs.list.array)
12326    {
12327       for(ieIdx=0; ieIdx<f1DlRrcMsg->protocolIEs.list.count; ieIdx++)
12328       {
12329          if(f1DlRrcMsg->protocolIEs.list.array[ieIdx])
12330          {
12331             switch(f1DlRrcMsg->protocolIEs.list.array[ieIdx]->id)
12332             {
12333                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12334                   break;
12335                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12336                   break;
12337                case ProtocolIE_ID_id_SRBID:
12338                   break;
12339                case ProtocolIE_ID_id_RRCContainer:
12340                   {
12341                      rrcContainer =&f1DlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
12342                      free(rrcContainer->buf);
12343                   }
12344                case ProtocolIE_ID_id_ExecuteDuplication:
12345                   break;
12346                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
12347                   break;
12348                   break;
12349             }
12350             free(f1DlRrcMsg->protocolIEs.list.array[ieIdx]);
12351          }
12352       }
12353       free(f1DlRrcMsg->protocolIEs.list.array);
12354    }
12355 }
12356 /******************************************************************
12357  *
12358  * @brief Processes DL RRC Message Transfer  sent by CU
12359  *
12360  * @details
12361  *
12362  *    Function : procF1DlRrcMsgTrans
12363  *
12364  *    Functionality: Processes DL RRC Message Transfer sent by CU
12365  *
12366  * @params[in] F1AP_PDU_t ASN decoded F1AP message
12367  * @return ROK     - success
12368  *         RFAILED - failure
12369  *
12370  * ****************************************************************/
12371 uint8_t procF1DlRrcMsgTrans(F1AP_PDU_t *f1apMsg)
12372 {
12373    uint8_t  idx, ret;
12374    DLRRCMessageTransfer_t *f1DlRrcMsg = NULLP;
12375    F1DlRrcMsg dlMsg;
12376    memset(&dlMsg, 0, sizeof(F1DlRrcMsg));
12377
12378    DU_LOG("\nINFO   -->  DU_APP : DL RRC message transfer Recevied");
12379    f1DlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
12380
12381    ret = ROK;
12382
12383    for(idx=0; idx<f1DlRrcMsg->protocolIEs.list.count; idx++)
12384    {
12385       switch(f1DlRrcMsg->protocolIEs.list.array[idx]->id)
12386       {
12387          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12388             {
12389                dlMsg.gnbCuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
12390                break;
12391             }
12392          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12393             {
12394                dlMsg.gnbDuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
12395                break;
12396             }
12397          case ProtocolIE_ID_id_SRBID:
12398             {
12399                dlMsg.srbId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
12400                break;
12401             }
12402          case ProtocolIE_ID_id_ExecuteDuplication:
12403             dlMsg.execDup = true;
12404             break;
12405
12406          case ProtocolIE_ID_id_RRCContainer:
12407             {
12408                if(f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0)
12409                {
12410                   dlMsg.rrcMsgSize = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
12411                   DU_ALLOC_SHRABL_BUF(dlMsg.rrcMsgPdu, dlMsg.rrcMsgSize);
12412                   if(dlMsg.rrcMsgPdu)
12413                   {
12414                      memcpy(dlMsg.rrcMsgPdu, f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
12415                         dlMsg.rrcMsgSize);
12416                   }
12417                   else
12418                   {
12419                      DU_LOG("\nERROR  -->  DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
12420                      return RFAILED;
12421                   }
12422                }
12423                else
12424                {
12425                   DU_LOG("\nERROR  -->  DU_APP : RRC Container Size is invalid:%ld",\
12426                   f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
12427                   return RFAILED;
12428                }
12429                break;
12430             }
12431          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
12432             {
12433                dlMsg.deliveryStatRpt = true;
12434                break;
12435             }
12436          default:
12437             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
12438                   f1DlRrcMsg->protocolIEs.list.array[idx]->id);
12439       }
12440    }
12441
12442    ret = duProcDlRrcMsg(&dlMsg);
12443
12444    freeAperDecodef1DlRrcMsg(f1DlRrcMsg);
12445    return ret;
12446 }
12447 /*******************************************************************
12448  *
12449 * @brief Builds the DRB to be Setup Mod list
12450 *
12451 * @details
12452 *
12453 *    Function :
12454 *
12455 *    Functionality: Constructs the DRB to be Setup Mod list
12456 *
12457 * @params[in] DRBs_SetupMod_List_t *drbSet
12458 *
12459 * @return ROK     - success
12460 *         RFAILED - failure
12461 *
12462 * ****************************************************************/
12463
12464 uint8_t BuildDrbSetupModList(DRBs_SetupMod_List_t *drbSet , DuUeCfg *ueCfg)
12465 {
12466    uint8_t arrIdx =0;
12467    uint8_t drbCnt =0;
12468    struct DRBs_SetupMod_ItemIEs *drbItemIe;
12469
12470    drbCnt = 1;
12471    drbSet->list.count = drbCnt;
12472    drbSet->list.size = drbCnt * sizeof(DRBs_SetupMod_ItemIEs_t *);
12473    DU_ALLOC(drbSet->list.array, drbSet->list.size);
12474    if(drbSet->list.array == NULLP)
12475    {
12476       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
12477       return  RFAILED;
12478    }
12479    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
12480    {
12481       DU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
12482       if(drbSet->list.array[arrIdx] == NULLP)
12483       {
12484               DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
12485               return  RFAILED;
12486       }
12487
12488       drbItemIe = (struct DRBs_SetupMod_ItemIEs *)drbSet->list.array[arrIdx];
12489       drbItemIe->id = ProtocolIE_ID_id_DRBs_SetupMod_Item;
12490       drbItemIe->criticality = Criticality_reject;
12491       drbItemIe->value.present = DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item;
12492       drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
12493       if(fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List,\
12494       &ueCfg->upTnlInfo[arrIdx])!= ROK)
12495       {
12496          DU_LOG("\nERROR  -->  F1AP : Failed to fill DlTnl SetupList in BuildDrbToBeSetupModList");
12497          return RFAILED;
12498       }
12499
12500    }
12501
12502    return ROK;
12503 }
12504 /*******************************************************************
12505 * @brief Free the memory allocated for DRB setup List
12506 *
12507 * @details
12508 *
12509 *    Function : FreeDrbSetupModList
12510 *
12511 *    Functionality:
12512 *       Free the memory allocated for DRB setup list
12513 *
12514 * @params[in] DRBs_Setup_List_t *
12515 * @return void
12516 *
12517 * ****************************************************************/
12518 void FreeDrbSetupModList(DRBs_SetupMod_List_t *drbSetupList)
12519 {
12520    uint8_t arrIdx = 0;
12521    DRBs_SetupMod_ItemIEs_t *drbItemIe = NULLP;
12522
12523    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
12524    {
12525       drbItemIe = ((DRBs_SetupMod_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
12526       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
12527       DU_FREE(drbSetupList->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
12528    }
12529    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
12530 }
12531 /*******************************************************************
12532 * @brief Free the memory allocated for UE Context Mod Response
12533 *
12534 * @details
12535 *
12536 *    Function : FreeUeContextModResp
12537 *
12538 *    Functionality:
12539 *       Free the memory allocated for UE Context Mod Response
12540 *
12541 * @params[in] F1AP_PDU_t *f1apMsg
12542 * @return void
12543 *
12544 * ****************************************************************/
12545
12546 void FreeUeContextModResp(F1AP_PDU_t *f1apMsg)
12547 {
12548    uint8_t ieIdx;
12549    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
12550    if(f1apMsg)
12551    {
12552       if(f1apMsg->choice.successfulOutcome)
12553       {
12554          ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
12555          if(ueContextModifyRes->protocolIEs.list.array)
12556          {
12557             for(ieIdx=0 ; ieIdx<ueContextModifyRes->protocolIEs.list.count; ieIdx++)
12558             {
12559                if(ueContextModifyRes->protocolIEs.list.array[ieIdx])
12560                {
12561                   switch(ueContextModifyRes->protocolIEs.list.array[ieIdx]->id)
12562                   {
12563                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12564                         break;
12565                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12566                         break;
12567                      case ProtocolIE_ID_id_DRBs_SetupMod_List:
12568                         {
12569                             FreeDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
12570                             value.choice.DRBs_SetupMod_List));
12571                             break;
12572                         }
12573                   }
12574                   DU_FREE(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
12575                }
12576
12577             }
12578             DU_FREE(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
12579          }
12580          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12581       }
12582       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12583    }
12584 }
12585
12586 /*****************************************************************i
12587 *
12588 * @brief Creating the ue context modifcation response and sending
12589 *
12590 * @details
12591 *
12592 *    Function : BuildAndSendUeContextModRsp
12593 *
12594 *    Functionality:
12595 *         - Creating the ue context modifcation response
12596 *
12597 * @params[in] uint8_t cellId,uint8_t ueIdx
12598 * @return ROK     - success
12599 *         RFAILED - failure
12600 *
12601 * ****************************************************************/
12602 uint8_t BuildAndSendUeContextModRsp(uint8_t cellId,uint8_t ueIdx)
12603 {
12604    uint8_t   ieIdx = 0;
12605    uint8_t   cellIdx =0;
12606    uint8_t   elementCnt = 0;
12607    uint8_t   ret = RFAILED;
12608    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
12609    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
12610    F1AP_PDU_t *f1apMsg = NULLP;
12611    asn_enc_rval_t         encRetVal;
12612    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
12613    DuUeCb                   *ueCb = NULLP;
12614
12615    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification response\n");
12616
12617    while(1)
12618    {
12619       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12620       if(f1apMsg == NULLP)
12621       {
12622          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
12623          break;
12624       }
12625
12626       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
12627
12628       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12629       if(f1apMsg->choice.successfulOutcome == NULLP)
12630       {
12631          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
12632          break;
12633       }
12634       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextModification;
12635       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
12636       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_UEContextModificationResponse;
12637
12638       ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
12639
12640       elementCnt = 3;
12641       ueContextModifyRes->protocolIEs.list.count = elementCnt;
12642       ueContextModifyRes->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationResponse_t*);
12643
12644       /* Initialize the UE context modification members */
12645       DU_ALLOC(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
12646       if(ueContextModifyRes->protocolIEs.list.array == NULLP)
12647       {
12648          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
12649          break;
12650       }
12651
12652       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
12653       {
12654          DU_ALLOC(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
12655          if(ueContextModifyRes->protocolIEs.list.array[ieIdx] == NULLP)
12656          {
12657             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
12658             break;
12659          }
12660       }
12661
12662       /* Fetching Ue Cb Info*/
12663       GET_CELL_IDX(cellId, cellIdx);
12664       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
12665       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
12666       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
12667
12668       ieIdx=0;
12669       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
12670       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12671       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
12672       UEContextModificationResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
12673       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
12674
12675       ieIdx++;
12676       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
12677       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12678       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present=\
12679       UEContextModificationResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
12680       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
12681
12682       ieIdx++;
12683       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_SetupMod_List;
12684       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12685       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
12686       UEContextModificationResponseIEs__value_PR_DRBs_SetupMod_List;
12687       if(ueCb->f1UeDb)
12688       {
12689          ret = BuildDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
12690                   value.choice.DRBs_SetupMod_List) , &ueCb->f1UeDb->duUeCfg);
12691          if(ret != ROK)
12692          {
12693             DU_LOG( "\nERROR  -->  F1AP : Failed to build drb setupmod List ");
12694             break;
12695          }
12696          freeF1UeDb(ueCb->f1UeDb);
12697          ueCb->f1UeDb = NULLP;
12698       }
12699       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12700
12701       /* Encode the F1SetupRequest type as APER */
12702       memset(encBuf, 0, ENC_BUF_MAX_LEN);
12703       encBufSize = 0;
12704       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,encBuf);
12705
12706       /* Encode results */
12707       if(encRetVal.encoded == ENCODE_FAIL)
12708       {
12709          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
12710                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12711          ret = RFAILED;
12712          break;
12713       }
12714       else
12715       {
12716          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Modification Response\n");
12717          for(int i=0; i< encBufSize; i++)
12718          {
12719             printf("%x",encBuf[i]);
12720          }
12721       }
12722
12723       /* Sending  msg  */
12724       if(sendF1APMsg() != ROK)
12725       {
12726          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Res Failed");
12727          ret = RFAILED;
12728          break;
12729       }
12730       break;
12731    }
12732    FreeUeContextModResp(f1apMsg);
12733    return ret;
12734 }
12735 /*******************************************************************
12736  *
12737  * @brief Deallocating the memory allocated by the aper decoder
12738  *          for QOSInfo
12739  *
12740  * @details
12741  *
12742  *    Function : freeAperDecodeQosInfo
12743  *
12744  *    Functionality:  Deallocating the memory allocated for QOSInfo
12745  *
12746  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
12747  *
12748  * @return void
12749  *
12750  * ****************************************************************/
12751
12752 void freeAperDecodeQosInfo(QoSFlowLevelQoSParameters_t *drbQos)
12753 {
12754    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
12755    {
12756       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
12757       {
12758          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
12759          {
12760             free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
12761          }
12762          free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
12763       }
12764       free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI);
12765    }
12766 }
12767 /*******************************************************************
12768  *
12769  * @brief Deallocating the memory allocated by the aper decoder
12770  *          for UlTnlInfoforDrb
12771  *
12772  * @details
12773  *
12774  *    Function : freeAperDecodeUlTnlInfoforDrbSetupMod
12775  *
12776  *    Functionality:  Deallocating memory allocated for UlTnlInfoforDrb
12777  *
12778  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
12779  *
12780  * @return void
12781  *
12782  * ****************************************************************/
12783 void freeAperDecodeUlTnlInfoforDrbSetupMod(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
12784 {
12785    uint8_t arrIdx =0;
12786
12787    if(ulInfo->list.array)
12788    {
12789       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
12790       {
12791          if(ulInfo->list.array[arrIdx])
12792          {
12793             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
12794             {
12795                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
12796                {
12797                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
12798                   {
12799                      free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12800                            gTP_TEID.buf);
12801                   }
12802                   free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12803                         transportLayerAddress.buf);
12804                }
12805                free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel);
12806             }
12807             free(ulInfo->list.array[arrIdx]);
12808          }
12809       }
12810       free(ulInfo->list.array);
12811    }
12812 }
12813 /*******************************************************************
12814  *
12815  * @brief Deallocating the memory allocated by the aper decoder
12816  *          for DrbSetupModItem
12817  *
12818  * @details
12819  *
12820  *    Function : freeAperDecodeDrbSetupModItem
12821  *
12822  *    Functionality:  Deallocating memory allocated for DrbSetupModItem
12823  *
12824  * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
12825  *
12826  * @return void
12827  *
12828  * ****************************************************************/
12829
12830 void freeAperDecodeDrbSetupModItem(DRBs_ToBeSetupMod_Item_t *drbItem)
12831 {
12832    uint8_t arrIdx =0;
12833    SNSSAI_t *snssai =NULLP;
12834    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
12835
12836    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
12837    switch(drbItem->qoSInformation.present)
12838    {
12839       case QoSInformation_PR_NOTHING:
12840          break;
12841       case QoSInformation_PR_eUTRANQoS:
12842          {
12843             if(drbItem->qoSInformation.choice.eUTRANQoS)
12844             {
12845                free(drbItem->qoSInformation.choice.eUTRANQoS);
12846             }
12847             break;
12848          }
12849       case QoSInformation_PR_choice_extension:
12850          {
12851             if(drbItem->qoSInformation.choice.choice_extension)
12852             {
12853                freeAperDecodeQosInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.\
12854                      DRB_Information.dRB_QoS);
12855                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
12856                if(snssai->sST.buf)
12857                {
12858                   free(snssai->sST.buf);
12859                }
12860                if(snssai->sD)
12861                {
12862                   if(snssai->sD->buf)
12863                   {
12864                      free(snssai->sD->buf);
12865                   }
12866                   free(snssai->sD);
12867                }
12868
12869                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.\
12870                          DRB_Information.flows_Mapped_To_DRB_List;
12871                if(flowMap->list.array)
12872                {
12873                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
12874                   {
12875                      if(flowMap->list.array[arrIdx] )
12876                      {
12877                         freeAperDecodeQosInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
12878                         free(flowMap->list.array[arrIdx]);
12879                      }
12880                   }
12881                   free(flowMap->list.array);
12882                }
12883
12884                free(drbItem->qoSInformation.choice.choice_extension);
12885             }
12886             break;
12887          }
12888
12889    }
12890    freeAperDecodeUlTnlInfoforDrbSetupMod(&drbItem->uLUPTNLInformation_ToBeSetup_List);
12891    if(drbItem->uLConfiguration)
12892    {
12893       free(drbItem->uLConfiguration);
12894    }
12895 }
12896
12897 /*******************************************************************
12898  *
12899  * @brief Deallocating the memory allocated by the aper decoder
12900  *          for DrbToBeSetupModList
12901  *
12902  * @details
12903  *
12904  *    Function : freeAperDecodeDrbToBeSetupModList
12905  *
12906  *    Functionality:  Deallocating memory allocated for DrbToBeSetupModList
12907  *
12908  * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
12909  *
12910  * @return void
12911  *
12912  * ****************************************************************/
12913
12914 void freeAperDecodeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
12915 {
12916    uint8_t arrIdx =0;
12917    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
12918
12919    if(drbSet->list.array)
12920    {
12921       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
12922       {
12923          if(drbSet->list.array[arrIdx] != NULLP)
12924          {
12925             if(arrIdx == 0)
12926             {
12927                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
12928                freeAperDecodeDrbSetupModItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
12929             }
12930             free(drbSet->list.array[arrIdx]);
12931          }
12932       }
12933       free(drbSet->list.array);
12934    }
12935
12936 }
12937 /*******************************************************************
12938  *
12939  * @brief Deallocating the memory allocated by the aper decoder
12940  *          for UeContextModificationReqMsg
12941  *
12942  * @details
12943  *
12944  *    Function : freeAperDecodeUeContextModificationReqMsg
12945  *
12946  *    Functionality:  Deallocating memory allocated for
12947  *                  UeContextModificationReqMsg
12948  *
12949  * @params[in] UEContextModificationRequest_t *UeContextModifyReq
12950  *
12951  * @return void
12952  *
12953  * ****************************************************************/
12954 void freeAperDecodeUeContextModificationReqMsg(UEContextModificationRequest_t *UeContextModifyReq )
12955 {
12956    uint8_t arrIdx, ieId;
12957
12958    if(UeContextModifyReq->protocolIEs.list.array)
12959    {
12960       for( arrIdx = 0 ; arrIdx<UeContextModifyReq->protocolIEs.list.count ; arrIdx++)
12961       {
12962          if(UeContextModifyReq->protocolIEs.list.array[arrIdx])
12963          {
12964             ieId = UeContextModifyReq->protocolIEs.list.array[arrIdx]->id;
12965             switch(ieId)
12966             {
12967                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12968                   break;
12969                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12970                   break;
12971                case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
12972                   {
12973                      freeAperDecodeDrbToBeSetupModList(&UeContextModifyReq->protocolIEs.list.array[arrIdx]->\
12974                            value.choice.DRBs_ToBeSetupMod_List);
12975                      break;
12976                   }
12977             }
12978             free(UeContextModifyReq->protocolIEs.list.array[arrIdx]);
12979          }
12980       }
12981       free(UeContextModifyReq->protocolIEs.list.array);
12982    }
12983 }
12984 /*******************************************************************
12985  *
12986  * @brief processing the F1 UeContextModificationReq
12987  *
12988  * @details
12989  *
12990  *    Function : procF1UeContextModificationReq
12991  *
12992  *    Functionality:  processing the F1 UeContextModificationReq
12993  *
12994  * @params[in] F1AP_PDU_t *f1apMsg
12995  *
12996  * @return
12997  * ****************************************************************/
12998 uint8_t procF1UeContextModificationReq(F1AP_PDU_t *f1apMsg)
12999 {
13000    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
13001    uint8_t  ret = ROK, ieIdx = 0, cellIdx=0, ueIdx=0;
13002    DuUeCb   *duUeCb = NULLP;
13003    DRBs_ToBeSetupMod_List_t *drbSetupModCfg;
13004    DRBs_ToBeModified_List_t *drbModifiedCfg;
13005    uint32_t gnbCuUeF1apId, gnbDuUeF1apId;
13006
13007    ueContextModifyReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
13008    for(ieIdx=0; (ieIdx < ueContextModifyReq->protocolIEs.list.count && ret == ROK); ieIdx++)
13009    {
13010       switch(ueContextModifyReq->protocolIEs.list.array[ieIdx]->id)
13011       {
13012          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13013             {
13014                gnbCuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
13015                break;
13016             }
13017          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13018             {
13019                gnbDuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
13020                break;
13021             }
13022          case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
13023          case ProtocolIE_ID_id_DRBs_ToBeModified_List:
13024             {
13025                for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
13026                {
13027                   for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
13028                   {
13029                      if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
13030                            (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
13031                      {
13032
13033                         duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
13034                         if(duUeCb->f1UeDb == NULLP)
13035                         {
13036                            DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
13037                         }
13038                         if(duUeCb->f1UeDb)
13039                         {
13040                            duUeCb->f1UeDb->actionType = UE_CTXT_MOD;
13041                            if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present ==\
13042                                  UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List)
13043                            {
13044                               drbSetupModCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
13045                               choice.DRBs_ToBeSetupMod_List;
13046
13047                               if(extractDrbListToSetupMod(NULL, drbSetupModCfg, NULL, drbSetupModCfg->list.count,\
13048                               &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, NULL))
13049                               {
13050                                  DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbSetupModList");
13051                                  ret = RFAILED;
13052                               }
13053                            }
13054
13055                            if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present == \
13056                                   UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List)
13057
13058                            {
13059                               drbModifiedCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
13060                               choice.DRBs_ToBeModified_List;
13061                               if(extractDrbListToSetupMod(NULL, NULL, drbModifiedCfg, drbSetupModCfg->list.count,\
13062                                  &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap, &duUeCb->rlcUeCfg))
13063                               {
13064                                  DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbModifiedList");
13065                                  ret = RFAILED;
13066                               }
13067                            }
13068                         }
13069                         break;
13070                      }
13071                   }
13072                   if(ueIdx >= duCb.actvCellLst[cellIdx]->numActvUes)
13073                   {
13074                      DU_LOG("\nERROR  -->  DU APP : wrong values of gnbCuUeF1apId and gnbDuUeF1apId ");
13075                      ret = RFAILED;
13076                   }
13077                }
13078                break;
13079             }
13080       }
13081    }
13082    if(ret != RFAILED)
13083    {
13084       ret = duProcUeContextModReq(duUeCb);
13085    }
13086    freeAperDecodeUeContextModificationReqMsg(ueContextModifyReq);
13087    return ret;
13088 }
13089 /*****************************************************************i
13090 *
13091 * @brief Free memory allocated for UE Context Release Request
13092 *
13093 * @details
13094 *
13095 *    Function : FreeUeContextReleaseReq
13096 *
13097 *    Functionality:
13098 *         - Free memory allocated for UE Context Release Request
13099 *
13100 * @params[in] F1AP_PDU_t *f1apMsg
13101 * @return void
13102 *
13103 * *************************************************************/
13104 void FreeUeContextReleaseReq(F1AP_PDU_t *f1apMsg)
13105 {
13106    uint8_t ieIdx;
13107    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
13108
13109    if(f1apMsg)
13110    {
13111       if(f1apMsg->choice.initiatingMessage)
13112       {
13113          ueReleaseReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
13114          if(ueReleaseReq->protocolIEs.list.array)
13115          {
13116             for(ieIdx=0 ; ieIdx<ueReleaseReq->protocolIEs.list.count; ieIdx++)
13117             {
13118                DU_FREE(ueReleaseReq->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseRequest_t));
13119             }
13120             DU_FREE(ueReleaseReq->protocolIEs.list.array, ueReleaseReq->protocolIEs.list.size);
13121          }
13122          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
13123       }
13124       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
13125    }
13126
13127 }
13128 /*****************************************************************i
13129 *
13130 * @brief Build and Send UE Context Release Request
13131 *
13132 * @details
13133 *
13134 *    Function : BuildAndSendUeContextReleaseReq
13135 *
13136 *    Functionality:
13137 *         - Build and Send UE Context Release Request
13138 *
13139 * @params[in]
13140 * @return ROK     - success
13141 *         RFAILED - failure
13142 *
13143 * *************************************************************/
13144 uint8_t BuildAndSendUeContextReleaseReq(uint16_t cellId, uint8_t ueIdx)
13145 {
13146    bool memAllocFail = false;
13147    uint8_t ieIdx =0;
13148    uint8_t ret = RFAILED;
13149    uint16_t cellIdx =0;
13150    uint16_t crnti = 0;
13151    uint8_t  elementCnt = 0;
13152    uint32_t  gnbCuUeF1apId =0;   /* gNB-CU UE F1AP Id */
13153    uint32_t  gnbDuUeF1apId =0;   /* gNB-DU UE F1AP Id */
13154    asn_enc_rval_t encRetVal;
13155    F1AP_PDU_t *f1apMsg = NULLP;
13156    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
13157
13158    DU_LOG("\nINFO  --> Building the UE Context Release Request");
13159    do
13160    {
13161       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
13162       if(f1apMsg == NULLP)
13163       {
13164          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for f1apMsg");
13165          break;
13166       }
13167
13168       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
13169       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
13170       if(f1apMsg->choice.initiatingMessage == NULLP)
13171       {
13172          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for\
13173          initiatingMessage");
13174          break;
13175       }
13176       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextReleaseRequest;
13177       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
13178       f1apMsg->choice.initiatingMessage->value.present = \
13179       InitiatingMessage__value_PR_UEContextReleaseRequest;
13180
13181       ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
13182
13183       elementCnt = 2;
13184
13185       ueReleaseReq->protocolIEs.list.count = elementCnt;
13186       ueReleaseReq->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseRequest_t *);
13187
13188       /* Initialize the F1Setup members */
13189       DU_ALLOC(ueReleaseReq->protocolIEs.list.array,ueReleaseReq->protocolIEs.list.size);
13190       if(ueReleaseReq->protocolIEs.list.array == NULLP)
13191       {
13192          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE array");
13193          break;
13194       }
13195       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
13196       {
13197          DU_ALLOC(ueReleaseReq->protocolIEs.list.array[ieIdx],\
13198                sizeof(UEContextReleaseRequest_t));
13199          if(ueReleaseReq->protocolIEs.list.array[ieIdx] == NULLP)
13200          {
13201             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE elements");
13202             memAllocFail = true;
13203             break;
13204          }
13205       }
13206       if(memAllocFail == true)
13207          break;
13208
13209       /* Fetching Ue Cb Info*/
13210       GET_CELL_IDX(cellId, cellIdx);
13211       if(duCb.actvCellLst[cellIdx] == NULLP)
13212       {
13213          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): CellId[%d] does not exist", cellId);
13214          break;
13215       }
13216       else
13217       {
13218          GET_CRNTI(crnti, ueIdx);
13219          if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].crnti != crnti)
13220          {
13221             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): crnti[%d] does not exist", crnti);
13222             break;
13223          }
13224          gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
13225          gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
13226       }
13227
13228       ieIdx=0;
13229       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
13230       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13231       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present = \
13232       UEContextReleaseRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
13233       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
13234
13235       ieIdx++;
13236       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
13237       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13238       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present =\
13239       UEContextReleaseRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
13240       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
13241
13242       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13243
13244       /* Encode the F1SetupRequest type as APER */
13245       memset(encBuf, 0, ENC_BUF_MAX_LEN);
13246       encBufSize = 0;
13247       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
13248       /* Encode results */
13249       if(encRetVal.encoded == ENCODE_FAIL)
13250       {
13251          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseRequest structure (at %s)\n",\
13252                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13253          break;
13254       }
13255       else
13256       {
13257          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseRequest\n");
13258          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
13259          {
13260             printf("%x",encBuf[ieIdx]);
13261          }
13262       }
13263
13264       /* Sending msg */
13265       if(sendF1APMsg() != ROK)
13266       {
13267          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Request failed");
13268          break;
13269       }
13270       ret = ROK;
13271       break;
13272    }while(true);
13273
13274    FreeUeContextReleaseReq(f1apMsg);
13275    return ret;
13276 }
13277 /*****************************************************************i
13278  *
13279  * @brief Free memory allocated for UE Context Release Complete
13280  *
13281  * @details
13282  *
13283  *    Function : FreeUeContextReleaseComplete
13284  *
13285  *    Functionality:
13286  *         - Free memory allocated for UE Context Release Complete
13287  *
13288  * @params[in] F1AP_PDU_t *f1apMsg
13289  * @return void
13290  *
13291  * *************************************************************/
13292 void FreeUeContextReleaseComplete(F1AP_PDU_t *f1apMsg)
13293 {
13294    uint8_t ieIdx;
13295    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
13296
13297    if(f1apMsg)
13298    {
13299       if(f1apMsg->choice.successfulOutcome)
13300       {
13301          ueReleaseComplete =&f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
13302          if(ueReleaseComplete->protocolIEs.list.array)
13303          {
13304             for(ieIdx=0 ; ieIdx<ueReleaseComplete->protocolIEs.list.count; ieIdx++)
13305             {
13306                DU_FREE(ueReleaseComplete->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseComplete_t));
13307             }
13308             DU_FREE(ueReleaseComplete->protocolIEs.list.array, ueReleaseComplete->protocolIEs.list.size);
13309          }
13310          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
13311       }
13312       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
13313    }
13314
13315 }
13316 /*****************************************************************i
13317  *
13318  * @brief Build and Send UE Context Release Complete
13319  *
13320  * @details
13321  *
13322  *    Function : BuildAndSendUeContextReleaseComplete
13323  *
13324  *    Functionality:
13325  *         - Build and Send UE Context Release Complete
13326  *
13327  * @params[in]  cellId,  gnbCuUeF1apId, gnbDuUeF1apId
13328  * @return ROK     - success
13329  *         RFAILED - failure
13330  *
13331  * *************************************************************/
13332 uint8_t BuildAndSendUeContextReleaseComplete(uint16_t cellId, uint32_t gnbCuUeF1apId, uint32_t gnbDuUeF1apId)
13333 {
13334    bool memAllocFail = false;
13335    uint8_t ieIdx =0, ret = RFAILED, elementCnt = 0;
13336    asn_enc_rval_t encRetVal;
13337    F1AP_PDU_t *f1apMsg = NULLP;
13338    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
13339
13340    DU_LOG("\nINFO  --> Building the UE Context Release Complete");
13341    do
13342    {
13343       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
13344       if(f1apMsg == NULLP)
13345       {
13346          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for f1apMsg");
13347          break;
13348       }
13349
13350       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
13351       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
13352       if(f1apMsg->choice.successfulOutcome == NULLP)
13353       {
13354          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for\
13355                successfulOutcome");
13356          break;
13357       }
13358       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextRelease;
13359       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
13360       f1apMsg->choice.successfulOutcome->value.present = \
13361       SuccessfulOutcome__value_PR_UEContextReleaseComplete;
13362
13363       ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
13364
13365       elementCnt = 2;
13366       ueReleaseComplete->protocolIEs.list.count = elementCnt;
13367       ueReleaseComplete->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseComplete_t *);
13368
13369       /* Initialize the UE Release Complete members */
13370       DU_ALLOC(ueReleaseComplete->protocolIEs.list.array,ueReleaseComplete->protocolIEs.list.size);
13371       if(ueReleaseComplete->protocolIEs.list.array == NULLP)
13372       {
13373          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE array");
13374          break;
13375       }
13376       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
13377       {
13378          DU_ALLOC(ueReleaseComplete->protocolIEs.list.array[ieIdx],\
13379                sizeof(UEContextReleaseComplete_t));
13380          if(ueReleaseComplete->protocolIEs.list.array[ieIdx] == NULLP)
13381          {
13382             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE\
13383             elements");
13384             memAllocFail = true;
13385             break;
13386          }
13387       }
13388       if(memAllocFail == true)
13389          break;
13390
13391
13392       ieIdx=0;
13393       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
13394       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13395       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present = \
13396       UEContextReleaseCompleteIEs__value_PR_GNB_CU_UE_F1AP_ID;
13397       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
13398
13399       ieIdx++;
13400       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
13401       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13402       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present =\
13403       UEContextReleaseCompleteIEs__value_PR_GNB_DU_UE_F1AP_ID;
13404       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
13405
13406       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13407
13408       /* Encode the F1SetupComplete type as APER */
13409       memset(encBuf, 0, ENC_BUF_MAX_LEN);
13410       encBufSize = 0;
13411       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
13412       /* Encode results */
13413       if(encRetVal.encoded == ENCODE_FAIL)
13414       {
13415          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseComplete structure (at %s)\n",\
13416                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13417          break;
13418       }
13419       else
13420       {
13421          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseComplete\n");
13422          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
13423          {
13424             printf("%x",encBuf[ieIdx]);
13425          }
13426       }
13427
13428       /* Sending msg */
13429       if(sendF1APMsg() != ROK)
13430       {
13431          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Complete failed");
13432          break;
13433       }
13434       ret = ROK;
13435       break;
13436    }while(true);
13437
13438    if(ret == ROK)
13439    {
13440       duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
13441       ret = duSendCellDeletReq(cellId);
13442       if(ret != ROK)
13443       {
13444          DU_LOG("\nERROR  -->  F1AP: BuildAndSendUeContextReleaseComplete(): Failed to process cell\
13445                Delete req for CellId");
13446       }
13447    }
13448    FreeUeContextReleaseComplete(f1apMsg);
13449    return ret;
13450
13451 }
13452
13453 /*******************************************************************
13454 *
13455 * @brief added free part for the memory allocated by aper_decoder
13456 *
13457 * @details
13458 *
13459 *    Function : freeAperDecodeUeContextReleaseCommand
13460 *
13461 *    Functionality: added free part for the memory allocated by aper_decoder
13462 *
13463 * @params[in] F1AP_PDU_t *f1apMsg
13464 * @return void
13465 *
13466 * ****************************************************************/
13467 void freeAperDecodeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
13468 {
13469    uint8_t ieIdx=0;
13470    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
13471
13472    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
13473
13474    if(ueContextReleaseCommand->protocolIEs.list.array)
13475    {
13476       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
13477       {
13478          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
13479          {
13480             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
13481             {
13482                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13483                   break;
13484                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13485                   break;
13486                case ProtocolIE_ID_id_Cause:
13487                   break;
13488                case ProtocolIE_ID_id_RRCContainer:
13489                {
13490                   if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
13491                   {
13492                      free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
13493                   }
13494                   break;
13495                }
13496                default :
13497                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
13498                        ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
13499                   break;
13500             }
13501          }
13502          free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]);
13503       }
13504       free(ueContextReleaseCommand->protocolIEs.list.array);
13505    }
13506 }
13507 /*******************************************************************
13508 *
13509 * @brief processing of UE Context Release Command
13510 *
13511 * @details
13512 *
13513 *    Function : procF1UeContextReleaseCommand
13514 *
13515 *    Functionality: processing of UE Context Release Command
13516 *
13517 * @params[in] F1AP_PDU_t *f1apMsg
13518 * @return void
13519 *
13520 * ****************************************************************/
13521 uint8_t procF1UeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
13522 {
13523    uint8_t  ieIdx=0, ret=ROK, ueIdx=0;
13524    uint16_t cellIdx =0;
13525    bool ueIdxFound;
13526    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0;
13527    DuUeCb   *duUeCb = NULLP;
13528    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
13529
13530    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
13531
13532    if(ueContextReleaseCommand->protocolIEs.list.array)
13533    {
13534       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
13535       {
13536          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
13537          {
13538             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
13539             {
13540                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13541                   {
13542                      gnbCuUeF1apId= ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13543                                     value.choice.GNB_CU_UE_F1AP_ID;
13544                      break;
13545                   }
13546
13547                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13548                   {
13549                      gnbDuUeF1apId = ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13550                                      value.choice.GNB_DU_UE_F1AP_ID;
13551                      break;
13552                   }
13553
13554                case ProtocolIE_ID_id_Cause:
13555                   {
13556                      break;
13557                   }
13558
13559                case ProtocolIE_ID_id_RRCContainer:
13560                   {
13561                      for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
13562                      {
13563                         for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
13564                         {
13565                            if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
13566                                  (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
13567                            {
13568                               duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
13569                               DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
13570                               if(duUeCb->f1UeDb)
13571                               {
13572                                  memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
13573                                  duUeCb->f1UeDb->actionType = UE_CTXT_RELEASE;
13574                                  duUeCb->f1UeDb->cellIdx = cellIdx;
13575                                  /* Filling Dl RRC Msg Info */
13576                                  DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
13577                                  if(!duUeCb->f1UeDb->dlRrcMsg)
13578                                  {
13579                                     DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
13580                                     Memory allocation failed ");
13581                                     ret = RFAILED;
13582                                  }
13583                                  else
13584                                  {
13585                                     duUeCb->f1UeDb->dlRrcMsgPres = true;
13586                                     memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
13587                                     ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
13588                                           &ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13589                                           value.choice.RRCContainer);
13590                                  }
13591
13592                               }
13593                               else
13594                               {
13595                                  DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
13596                                  Memory allocation failed ");
13597                                  ret = RFAILED;
13598
13599                               }
13600
13601                               ueIdxFound = true;
13602                               break;
13603                            }
13604                         }
13605                         if(ueIdxFound == true)
13606                         {
13607                            break;
13608                         }
13609                      }
13610                      if(!ueIdxFound)
13611                      {
13612                         DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
13613                         ret = RFAILED;
13614                      }
13615
13616
13617                      break;
13618                   }
13619                default :
13620                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
13621                         ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
13622                   break;
13623             }
13624          }
13625       }
13626    }
13627    if(ret != RFAILED)
13628    {
13629       duProcUeContextReleaseCommand(duUeCb);
13630    }
13631    freeAperDecodeUeContextReleaseCommand(f1apMsg);
13632    return ret;
13633 }
13634 /**************************************************************
13635  *
13636  * @brief Handles received F1AP message and sends back response
13637  *
13638  * @details
13639  *
13640  *    Function : F1APMsgHdlr
13641  *
13642  *    Functionality:
13643  *         - Decodes received F1AP control message
13644  *         - Prepares response message, encodes and sends to SCTP
13645  *
13646  * @params[in]
13647  * @return ROK     - success
13648  *         RFAILED - failure
13649  *
13650  * ****************************************************************/
13651 void F1APMsgHdlr(Buffer *mBuf)
13652 {
13653    int i =0;
13654    char *recvBuf =NULLP;
13655    MsgLen copyCnt =0;
13656    MsgLen recvBufLen =0;
13657    F1AP_PDU_t *f1apMsg =NULLP;
13658    asn_dec_rval_t rval; /* Decoder return value */
13659    F1AP_PDU_t f1apasnmsg ;
13660    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
13661    ODU_PRINT_MSG(mBuf, 0,0);
13662
13663    /* Copy mBuf into char array to decode it */
13664    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
13665    DU_ALLOC(recvBuf, (Size)recvBufLen);
13666
13667    if(recvBuf == NULLP)
13668    {
13669       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
13670       return;
13671    }
13672    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
13673    {
13674       DU_LOG("\nERROR   -->  F1AP : Failed while copying %d", copyCnt);
13675       return;
13676    }
13677
13678    printf("\nDEBUG   -->  F1AP : Received flat buffer to be decoded : ");
13679    for(i=0; i< recvBufLen; i++)
13680    {
13681       printf("%x",recvBuf[i]);
13682    }
13683
13684    /* Decoding flat buffer into F1AP messsage */
13685    f1apMsg = &f1apasnmsg;
13686    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
13687
13688    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
13689    DU_FREE(recvBuf, (Size)recvBufLen);
13690
13691    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
13692    {
13693       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
13694       return;
13695    }
13696    printf("\n");
13697    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13698
13699    switch(f1apMsg->present)
13700    {
13701       case F1AP_PDU_PR_successfulOutcome:
13702          {
13703             switch(f1apMsg->choice.successfulOutcome->value.present)
13704             {
13705                case SuccessfulOutcome__value_PR_ResetAcknowledge:
13706                   {
13707                      DU_LOG("\nINFO   -->  F1AP : F1ResetAcknowledge is received successfully ");
13708                      break;
13709                   }
13710                case SuccessfulOutcome__value_PR_F1SetupResponse:
13711                   {
13712 #ifndef ODU_TEST_STUB
13713                      procF1SetupRsp(f1apMsg);
13714 #endif
13715                      break;
13716                   }
13717
13718                case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
13719                   {
13720                      procF1GNBDUCfgUpdAck(f1apMsg);
13721                      break;
13722                   }
13723
13724                default:
13725                   {
13726                      DU_LOG("\nERROR  -->  F1AP : Invalid type of SuccessfulOutcome__value_PR_ResetAcknowledge [%d]",\
13727                            f1apMsg->choice.successfulOutcome->value.present);
13728                      return;
13729                   }
13730             }/* End of switch(successfulOutcome) */
13731             free(f1apMsg->choice.successfulOutcome);
13732             break;
13733          }
13734       case F1AP_PDU_PR_initiatingMessage:
13735          {
13736             switch(f1apMsg->choice.initiatingMessage->value.present)
13737             {
13738                case InitiatingMessage__value_PR_Reset:
13739                   {
13740                      procF1ResetReq(f1apMsg);
13741                      break;
13742                   }
13743                case InitiatingMessage__value_PR_DLRRCMessageTransfer:
13744                   {
13745                      procF1DlRrcMsgTrans(f1apMsg);
13746                      break;
13747                   }
13748                case InitiatingMessage__value_PR_UEContextSetupRequest:
13749                   {
13750                      procF1UeContextSetupReq(f1apMsg);
13751                      break;
13752                   }
13753                case InitiatingMessage__value_PR_UEContextModificationRequest:
13754                   {
13755                      procF1UeContextModificationReq(f1apMsg);
13756                      break;
13757                   }
13758                case InitiatingMessage__value_PR_UEContextReleaseCommand:
13759                   {
13760                       procF1UeContextReleaseCommand(f1apMsg);
13761                       break;
13762                   }
13763                default:
13764                   {
13765                      DU_LOG("\nERROR  -->  F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
13766                            f1apMsg->choice.initiatingMessage->value.present);
13767                      return;
13768                   }
13769             }/* End of switch(initiatingMessage) */
13770             free(f1apMsg->choice.initiatingMessage);
13771             break;
13772          }
13773
13774       default:
13775          {
13776             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
13777             return;
13778          }
13779          free(f1apMsg);
13780
13781    }/* End of switch(f1apMsg->present) */
13782
13783 } /* End of F1APMsgHdlr */
13784
13785 /**********************************************************************
13786   End of file
13787  **********************************************************************/