src/du_app/du_f1ap_msg_hdl.c

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   4 #                                                                              #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
   6 #   you may not use this file except in compliance with the License.           #
   7 #   You may obtain a copy of the License at                                    #
   8 #                                                                              #
   9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10 #                                                                              #
  11 #   Unless required by applicable law or agreed to in writing, software        #
  12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
  14 #   See the License for the specific language governing permissions and        #
  15 #   limitations under the License.                                             #
  16 ################################################################################
  17 *******************************************************************************/
  18
  19 /* This file contains F1AP message handler functions */
  20 #include "common_def.h"
  21 #include "lrg.h"
  22 #include "legtp.h"
  23 #include "lkw.x"
  24 #include "lrg.x"
  25 #include "F1AP-PDU.h"
  26 #include "du_app_mac_inf.h"
  27 #include "du_cfg.h"
  28 #include "du_app_rlc_inf.h"
  29 #include "du_mgr_main.h"
  30 #include "du_utils.h"
  31 #include "RAT-Type.h"
  32 #include "FeatureSetUplinkPerCC.h"
  33 #include "FeatureSetDownlinkPerCC.h"
  34 #include "FeatureSets.h"
  35 #include "UE-NR-Capability.h"
  36 #include "UE-CapabilityRAT-Container.h"
  37 #include "UE-CapabilityRAT-ContainerListRRC.h"
  38 #include "GNB-DU-System-Information.h"
  39 #include "CellGroupConfigRrc.h"
  40 #include "MAC-CellGroupConfig.h"
  41 #include "SchedulingRequestConfig.h"
  42 #include "SchedulingRequestToAddMod.h"
  43 #include "BSR-Config.h"
  44 #include "TAG-Config.h"
  45 #include "TAG.h"
  46 #include "PHR-Config.h"
  47 #include "RLC-Config.h"
  48 #include "UL-AM-RLC.h"
  49 #include "DL-AM-RLC.h"
  50 #include "LogicalChannelConfig.h"
  51 #include "RLC-BearerConfig.h"
  52 #include "PhysicalCellGroupConfig.h"
  53 #include "SpCellConfig.h"
  54 #include "TDD-UL-DL-ConfigDedicated.h"
  55 #include "ServingCellConfig.h"
  56 #include "ControlResourceSet.h"
  57 #include "SearchSpace.h"
  58 #include "PDCCH-Config.h"
  59 #include "PDSCH-TimeDomainResourceAllocation.h"
  60 #include "PDSCH-TimeDomainResourceAllocationList.h"
  61 #include "PDSCH-CodeBlockGroupTransmission.h"
  62 #include "PDSCH-ServingCellConfig.h"
  63 #include "DMRS-DownlinkConfig.h"
  64 #include "PDSCH-Config.h"
  65 #include "BWP-DownlinkDedicated.h"
  66 #include "PUSCH-TimeDomainResourceAllocation.h"
  67 #include "PUSCH-TimeDomainResourceAllocationList.h"
  68 #include "DMRS-UplinkConfig.h"
  69 #include "PUSCH-Config.h"
  70 #include "SRS-ResourceId.h"
  71 #include "SRS-Resource.h"
  72 #include "SRS-ResourceSet.h"
  73 #include "SRS-Config.h"
  74 #include "BWP-UplinkDedicated.h"
  75 #include "PUSCH-ServingCellConfig.h"
  76 #include "UplinkConfig.h"
  77 #include "DUtoCURRCContainer.h"
  78 #include "GBR-QoSFlowInformation.h"
  79 #include "QoSFlowLevelQoSParameters.h"
  80 #include "PUCCH-Config.h"
  81 #include "PUCCH-ResourceSet.h"
  82 #include "PUCCH-Resource.h"
  83 #include "PUCCH-PowerControl.h"
  84 #include "P0-PUCCH.h"
  85 #include "PUCCH-PathlossReferenceRS.h"
  86 #include "PUCCH-format0.h"
  87 #include "PUCCH-format1.h"
  88 #include "PUCCH-format2.h"
  89 #include "PUCCH-format3.h"
  90 #include "PUCCH-format4.h"
  91 #include "PUCCH-FormatConfig.h"
  92 #include "SchedulingRequestResourceConfig.h"
  93 #include<ProtocolIE-Field.h>
  94 #include "ProtocolExtensionField.h"
  95 #include "odu_common_codec.h"
  96 #include "du_mgr.h"
  97 #include "du_cell_mgr.h"
  98 #include "du_f1ap_msg_hdl.h"
  99 #include "DRBs-Setup-Item.h"
 100 #include "DLUPTNLInformation-ToBeSetup-List.h"
 101 #include "DLUPTNLInformation-ToBeSetup-Item.h"
 102 #include "UPTransportLayerInformation.h"
 103 #include "GTPTunnel.h"
 104
 105 #ifdef O1_ENABLE
 106 #include "ConfigInterface.h"
 107 extern StartupConfig g_cfg;
 108 #endif
 109
 110 DuCfgParams duCfgParam;
 111
 112 /************************************************************************
 113  *
 114  * @brief Converts enum values into actual value of Poll retransmit timer
 115  *
 116  * @details
 117  *
 118  *    Function : getPollPdu
 119  *
 120  *    Functionality: Converts enum values into actual value of poll
 121  *    retransmit timer
 122  *
 123  * @params[in] Enum value of pollPdu
 124  * @return Actual value of pollPdu
 125  *
 126  * **********************************************************************/
 127
 128 uint16_t getPollRetxTmr(uint8_t pollRetxTmrCfg)
 129 {
 130    uint16_t pollRetxTmr;
 131
 132    /* All values of poll retx timer are at interval of 5ms.
 133     * This is valid upto 250ms
 134     * Hence converting the enum value to actual value by multiplying it to 5
 135     */
 136    if(pollRetxTmrCfg <= T_PollRetransmit_ms250)
 137       pollRetxTmr = (pollRetxTmrCfg + 1) * 5;
 138    else
 139    {
 140       switch(pollRetxTmrCfg)
 141       {
 142          case T_PollRetransmit_ms300:
 143             pollRetxTmr = 300;
 144             break;
 145          case T_PollRetransmit_ms350:
 146             pollRetxTmr = 350;
 147             break;
 148          case T_PollRetransmit_ms400:
 149             pollRetxTmr = 400;
 150             break;
 151          case T_PollRetransmit_ms450:
 152             pollRetxTmr = 450;
 153             break;
 154          case T_PollRetransmit_ms500:
 155             pollRetxTmr = 500;
 156             break;
 157          case T_PollRetransmit_ms800:
 158             pollRetxTmr = 800;
 159             break;
 160          default:
 161             DU_LOG("\nERROR  -->  F1AP: Invalid value of Poll Retransmit timer");
 162             pollRetxTmr = 0;
 163       }
 164    }
 165    return pollRetxTmr;
 166 }
 167
 168 /*******************************************************************
 169  *
 170  * @brief Converts enum values into actual value of PollPdu
 171  *
 172  * @details
 173  *
 174  *    Function : getPollPdu
 175  *
 176  *    Functionality: Converts enum values into actual value of PollPdu
 177  *
 178  * @params[in] Enum value of pollPdu
 179  * @return Actual value of pollPdu
 180  *
 181  * ****************************************************************/
 182 int32_t getPollPdu(uint8_t pollPduCfg)
 183 {
 184    int32_t pollPdu;
 185    switch(pollPduCfg)
 186    {
 187       case PollPDU_p4:
 188          pollPdu = 4;
 189          break;
 190       case PollPDU_p8:
 191          pollPdu = 8;
 192          break;
 193       case PollPDU_p16:
 194          pollPdu = 16;
 195          break;
 196       case PollPDU_p32:
 197          pollPdu = 32;
 198          break;
 199       case PollPDU_p64:
 200          pollPdu = 64;
 201          break;
 202       case PollPDU_p128:
 203          pollPdu = 128;
 204          break;
 205       case PollPDU_p256:
 206          pollPdu = 256;
 207          break;
 208       case PollPDU_p512:
 209          pollPdu = 512;
 210          break;
 211       case PollPDU_p1024:
 212          pollPdu = 1024;
 213          break;
 214       case PollPDU_p2048:
 215          pollPdu = 2048;
 216          break;
 217       case PollPDU_p4096:
 218          pollPdu = 4096;
 219          break;
 220       case PollPDU_p6144:
 221          pollPdu = 6144;
 222          break;
 223       case PollPDU_p8192:
 224          pollPdu = 8192;
 225          break;
 226       case PollPDU_p12288:
 227          pollPdu = 12288;
 228          break;
 229       case PollPDU_p16384:
 230          pollPdu = 16384;
 231          break;
 232       case PollPDU_p20480:
 233          pollPdu = 20480;
 234          break;
 235       case PollPDU_p24576:
 236          pollPdu = 24576;
 237          break;
 238       case PollPDU_p28672:
 239          pollPdu = 28672;
 240          break;
 241       case PollPDU_p32768:
 242          pollPdu = 32768;
 243          break;
 244       case PollPDU_p40960:
 245          pollPdu = 40960;
 246          break;
 247       case PollPDU_p49152:
 248          pollPdu = 49152;
 249          break;
 250       case PollPDU_p57344:
 251          pollPdu = 57344;
 252          break;
 253       case PollPDU_p65536:
 254          pollPdu = 65536;
 255          break;
 256       case PollPDU_infinity:
 257          pollPdu = -1;
 258          break;
 259       default:
 260          DU_LOG("\nERROR  -->  F1AP: Invalid value of poll pdu");
 261          pollPdu = 0;
 262          break;
 263    }
 264    return pollPdu;
 265 }
 266
 267 /*******************************************************************
 268  *
 269  * @brief Converts enum values into actual value of poll bytes
 270  *
 271  * @details
 272  *
 273  *    Function : getPollByte
 274  *
 275  *    Functionality: Converts enum values into actual value of pollBytes
 276  *
 277  * @params[in] Enum value
 278  * @return Actual value
 279  *
 280  * ****************************************************************/
 281 int32_t getPollByte(uint16_t pollBytesCfg)
 282 {
 283    int32_t pollBytes;
 284    switch(pollBytesCfg)
 285    {
 286       case PollByte_kB1:
 287          pollBytes = 1000;
 288          break;
 289       case PollByte_kB2:
 290          pollBytes = 2000;
 291          break;
 292       case PollByte_kB5:
 293          pollBytes = 5000;
 294          break;
 295       case PollByte_kB8:
 296          pollBytes = 8000;
 297          break;
 298       case PollByte_kB10:
 299          pollBytes = 10000;
 300          break;
 301       case PollByte_kB15:
 302          pollBytes = 15000;
 303          break;
 304       case PollByte_kB25:
 305          pollBytes = 25000;
 306          break;
 307       case PollByte_kB50:
 308          pollBytes = 50000;
 309          break;
 310       case PollByte_kB75:
 311          pollBytes = 75000;
 312          break;
 313       case PollByte_kB100:
 314          pollBytes = 100000;
 315          break;
 316       case PollByte_kB125:
 317          pollBytes = 125000;
 318          break;
 319       case PollByte_kB250:
 320          pollBytes = 250000;
 321          break;
 322       case PollByte_kB375:
 323          pollBytes = 375000;
 324          break;
 325       case PollByte_kB500:
 326          pollBytes = 500000;
 327          break;
 328       case PollByte_kB750:
 329          pollBytes = 750000;
 330          break;
 331       case PollByte_kB1000:
 332          pollBytes = 1000000;
 333          break;
 334       case PollByte_kB1250:
 335          pollBytes = 1250000;
 336          break;
 337       case PollByte_kB1500:
 338          pollBytes = 1500000;
 339          break;
 340       case PollByte_kB2000:
 341          pollBytes = 2000000;
 342          break;
 343       case PollByte_kB3000:
 344          pollBytes = 3000000;
 345          break;
 346       case PollByte_kB4000:
 347          pollBytes = 4000000;
 348          break;
 349       case PollByte_kB4500:
 350          pollBytes = 4500000;
 351          break;
 352       case PollByte_kB5000:
 353          pollBytes = 5000000;
 354          break;
 355       case PollByte_kB5500:
 356          pollBytes = 5500000;
 357          break;
 358       case PollByte_kB6000:
 359          pollBytes = 6000000;
 360          break;
 361       case PollByte_kB6500:
 362          pollBytes = 6500000;
 363          break;
 364       case PollByte_kB7000:
 365          pollBytes = 7000000;
 366          break;
 367       case PollByte_kB7500:
 368          pollBytes = 7500000;
 369          break;
 370       case PollByte_mB8:
 371          pollBytes = 8000000;
 372          break;
 373       case PollByte_mB9:
 374          pollBytes = 9000000;
 375          break;
 376       case PollByte_mB10:
 377          pollBytes = 10000000;
 378          break;
 379       case PollByte_mB11:
 380          pollBytes = 11000000;
 381          break;
 382       case PollByte_mB12:
 383          pollBytes = 12000000;
 384          break;
 385       case PollByte_mB13:
 386          pollBytes = 13000000;
 387          break;
 388       case PollByte_mB14:
 389          pollBytes = 14000000;
 390          break;
 391       case PollByte_mB15:
 392          pollBytes = 15000000;
 393          break;
 394       case PollByte_mB16:
 395          pollBytes = 16000000;
 396          break;
 397       case PollByte_mB17:
 398          pollBytes = 17000000;
 399          break;
 400       case PollByte_mB18:
 401          pollBytes = 18000000;
 402          break;
 403       case PollByte_mB20:
 404          pollBytes = 20000000;
 405          break;
 406       case PollByte_mB25:
 407          pollBytes = 25000000;
 408          break;
 409       case PollByte_mB30:
 410          pollBytes = 30000000;
 411          break;
 412       case PollByte_mB40:
 413          pollBytes = 40000000;
 414          break;
 415       case PollByte_infinity:
 416          pollBytes = -1;
 417          break;
 418       default:
 419          DU_LOG("\nERROR  -->  F1AP: Invalid value of poll bytes");
 420          pollBytes = 0;
 421    }
 422    return pollBytes;
 423 }
 424
 425 /*******************************************************************
 426  *
 427  * @brief Converts enum values into actual value of maxRetx
 428  *
 429  * @details
 430  *
 431  *    Function : getMaxRetx
 432  *
 433  *    Functionality: Converts enum values into actual value of maxRetx
 434  *
 435  * @params[in] Enum value
 436  * @return Actual value
 437  *
 438  * ****************************************************************/
 439 uint8_t getMaxRetx(uint8_t maxRetxCfg)
 440 {
 441    uint8_t maxRetx;
 442    switch(maxRetxCfg)
 443    {
 444       case UL_AM_RLC__maxRetxThreshold_t1:
 445          maxRetx = 1;
 446          break;
 447       case UL_AM_RLC__maxRetxThreshold_t2:
 448          maxRetx = 2;
 449          break;
 450       case UL_AM_RLC__maxRetxThreshold_t3:
 451          maxRetx = 3;
 452          break;
 453       case UL_AM_RLC__maxRetxThreshold_t4:
 454          maxRetx = 4;
 455          break;
 456       case UL_AM_RLC__maxRetxThreshold_t6:
 457          maxRetx = 6;
 458          break;
 459       case UL_AM_RLC__maxRetxThreshold_t8:
 460          maxRetx = 8;
 461          break;
 462       case UL_AM_RLC__maxRetxThreshold_t16:
 463          maxRetx = 16;
 464          break;
 465       case UL_AM_RLC__maxRetxThreshold_t32:
 466          maxRetx = 32;
 467          break;
 468       default:
 469          DU_LOG("\nERROR  -->  F1AP: Invalid configuration for Max retransmission threshold");
 470          maxRetx = 0;
 471    }
 472    return maxRetx;
 473 }
 474
 475 /*******************************************************************
 476  * @brief Converts enum values into actual value of reassembly timer
 477  *
 478  * @details
 479  *
 480  *    Function : getReAsmblTmr
 481  *
 482  *    Functionality: Converts enum values into actual value of reassembly
 483  *    timer
 484  *
 485  * @params[in] Enum value of reassembly timer
 486  * @return Actual value of reassembly timer
 487  *
 488  * **********************************************************************/
 489
 490 int8_t getReAsmblTmr(uint8_t reAsmblTmrCfg)
 491 {
 492    int8_t reAsmblTmr = 0;
 493
 494    if(reAsmblTmrCfg == T_Reassembly_ms0)
 495    {
 496       reAsmblTmr = 0;
 497    }
 498    else if(reAsmblTmrCfg >= T_Reassembly_ms5 || reAsmblTmrCfg <= T_Reassembly_ms100)
 499    {
 500      /* All values of re assembly timer are at interval of 5ms.
 501       * This is valid upto 100ms
 502       * Hence converting the enum value to actual value by multiplying it to 5
 503       */
 504       reAsmblTmr = reAsmblTmrCfg * 5;
 505    }
 506    else if(reAsmblTmrCfg >= T_Reassembly_ms110 || reAsmblTmrCfg <= T_Reassembly_ms200)
 507    {
 508      /* All values of re assembly timer are at interval of 10ms.
 509       * This is valid upto 200ms
 510       * since enum value starts from 20 for 100ms, subtracting 10 and
 511       * converting the enum value to actual value by multiplying it to 10
 512       */
 513       reAsmblTmr = ((reAsmblTmrCfg-10) * 10);
 514    }
 515    else
 516    {
 517       DU_LOG("\nERROR  -->  F1AP : Invalid value of Re Assembly timer %d", reAsmblTmrCfg);
 518       reAsmblTmr = -1;
 519    }
 520    return reAsmblTmr;
 521 }
 522
 523 /************************************************************************
 524  *
 525  * @brief Converts enum values into actual value of status prohibit timer
 526  *
 527  * @details
 528  *
 529  *    Function : getStatProhTmr
 530  *
 531  *    Functionality: Converts enum values into actual value of status prohibit
 532  *    timer
 533  *
 534  * @params[in] Enum value of status prohibit timer
 535  * @return Actual value of status prohibit timer
 536  *
 537  * **********************************************************************/
 538
 539 int16_t getStatProhTmr(uint8_t statProhTmrCfg)
 540 {
 541    int16_t statProhTmr =0;
 542
 543    if(statProhTmrCfg == T_StatusProhibit_ms0)
 544    {
 545       statProhTmr = 0;
 546    }
 547    else if(statProhTmrCfg >= T_StatusProhibit_ms5 || statProhTmrCfg <= T_StatusProhibit_ms250)
 548    {
 549       /* All values of re assembly timer are at interval of 5ms.
 550        * This is valid upto 250ms
 551        * Hence converting the enum value to actual value by multiplying it to 5
 552        */
 553       statProhTmr = statProhTmrCfg * 5;
 554    }
 555    else
 556    {
 557       switch(statProhTmrCfg)
 558       {
 559          case T_StatusProhibit_ms300:
 560             statProhTmr = 300;
 561             break;
 562          case T_StatusProhibit_ms350:
 563             statProhTmr = 350;
 564             break;
 565          case T_StatusProhibit_ms400:
 566             statProhTmr = 400;
 567             break;
 568          case T_StatusProhibit_ms450:
 569             statProhTmr = 450;
 570             break;
 571          case T_StatusProhibit_ms500:
 572             statProhTmr = 500;
 573             break;
 574          case T_StatusProhibit_ms800:
 575             statProhTmr = 800;
 576             break;
 577          case T_StatusProhibit_ms1000:
 578             statProhTmr = 1000;
 579             break;
 580          case T_StatusProhibit_ms1200:
 581             statProhTmr = 1200;
 582             break;
 583          case T_StatusProhibit_ms1600:
 584             statProhTmr = 1600;
 585             break;
 586          case T_StatusProhibit_ms2000:
 587             statProhTmr = 2000;
 588             break;
 589          case T_StatusProhibit_ms2400:
 590             statProhTmr = 2400;
 591             break;
 592          default:
 593             DU_LOG("\nInvalid value of Status Prohibit timer %d", statProhTmrCfg);
 594             statProhTmr = -1;
 595             break;
 596       }
 597    }
 598    return statProhTmr;
 599 }
 600
 601 /*******************************************************************
 602 *
 603 * @brief Adding F1AP pdu to reserved pdu list
 604 *
 605 * @details
 606 *
 607 *    Function : addToReservedF1apPduList
 608 *
 609 *    Functionality: Adding F1AP pdu to reserved pdu list.
 610 *     These pdu are awaiting aknowledgment from CU
 611 *
 612 * @params[in] uint8_t transId, F1AP_PDU_t *f1apMsg
 613 *
 614 * @return ROK - success
 615 *         RFAILED - failure
 616 *
 617 * ****************************************************************/
 618
 619 void addToReservedF1apPduList(uint8_t transId, F1AP_PDU_t *f1apPdu)
 620 {
 621    CmLList         *node = NULLP;
 622    ReservedF1apPduInfo *pduInfo = NULLP;
 623    DU_ALLOC(pduInfo, sizeof(ReservedF1apPduInfo));
 624    if(pduInfo)
 625    {
 626       DU_ALLOC(node, sizeof(CmLList));
 627       if(node)
 628       {
 629          pduInfo->transId = transId;
 630          pduInfo->f1apMsg = (void*) f1apPdu;
 631
 632          node->node = (PTR)pduInfo;
 633          cmLListAdd2Tail(&duCb.reservedF1apPduList, node);
 634       }
 635    }
 636 }
 637
 638 /*******************************************************************
 639 *
 640 * @brief searching for F1AP pdu from ReservedF1apPduList
 641 *
 642 * @details
 643 *
 644 *    Function : searchFromReservedF1apPduList
 645 *
 646 *    Functionality: searching for F1AP pdu information
 647 *
 648 * @params[in] uint8_t transId
 649 *
 650 * @return pointer to F1AP_PDU_t
 651 *
 652 * ****************************************************************/
 653
 654 CmLList *searchFromReservedF1apPduList(uint8_t transId)
 655 {
 656    CmLList         *node;
 657    ReservedF1apPduInfo *f1apPdu;
 658    if(duCb.reservedF1apPduList.count)
 659    {
 660       CM_LLIST_FIRST_NODE(&duCb.reservedF1apPduList, node);
 661       while(node)
 662       {
 663          f1apPdu = (ReservedF1apPduInfo*)node->node;
 664          if(f1apPdu->transId == transId)
 665          {
 666             return node;
 667          }
 668          node = node->next;
 669       }
 670    }
 671    return NULL;
 672 }
 673
 674 /*******************************************************************
 675 *
 676 * @brief deleting F1AP pdu information from ReservedF1apPduList
 677 *
 678 * @details
 679 *
 680 *    Function : deleteFromReservedF1apPduList
 681 *
 682 *    Functionality: deleting pdu information from ReservedF1apPduList
 683 *
 684 * @params[in] CmLList *node
 685 *
 686 * @return void
 687 *
 688 * ****************************************************************/
 689
 690 void deleteFromReservedF1apPduList(CmLList *node)
 691 {
 692    ReservedF1apPduInfo *f1apPdu;
 693
 694    if(node != NULL)
 695    {
 696       f1apPdu = (ReservedF1apPduInfo *)node->node;
 697       cmLListDelFrm(&duCb.reservedF1apPduList, node);
 698       DU_FREE(f1apPdu, sizeof(ReservedF1apPduInfo));
 699       DU_FREE(node, sizeof(CmLList));
 700       node = NULL;
 701    }
 702 }
 703
 704 /*******************************************************************
 705  *
 706  * @brief Builds Uplink Info for NR
 707  *
 708  * @details
 709  *
 710  *    Function : BuildULNRInfo
 711  *
 712  *    Functionality: Building NR Uplink Info
 713  *
 714  * @params[in] NRFreqInfo_t *ulnrfreq
 715  * @return ROK     - success
 716  *         RFAILED - failure
 717  *
 718  * ****************************************************************/
 719 uint8_t BuildULNRInfo(NRFreqInfo_t *ulnrfreq)
 720 {
 721    uint8_t idx=0;
 722    ulnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 723                        fdd.ulNrFreqInfo.nrArfcn;
 724    ulnrfreq->freqBandListNr.list.count = 1;
 725    ulnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 726    DU_ALLOC(ulnrfreq->freqBandListNr.list.array,ulnrfreq->freqBandListNr.list.size);
 727    if(ulnrfreq->freqBandListNr.list.array == NULLP)
 728    {
 729       return RFAILED;
 730    }
 731    for(idx=0;idx<ulnrfreq->freqBandListNr.list.count;idx++)
 732    {
 733       DU_ALLOC(ulnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 734       if(ulnrfreq->freqBandListNr.list.array[idx] == NULLP)
 735       {
 736          return RFAILED;
 737       }
 738    }
 739    ulnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 740                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
 741                                                                  freqBand[0].nrFreqBand;
 742    ulnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 743    return ROK;
 744 }
 745 /*******************************************************************
 746  *
 747  * @brief Builds Downlink NR Info
 748  *
 749  * @details
 750  *
 751  *    Function : BuildDLNRInfo
 752  *
 753  *    Functionality: Building Downlink NR Info
 754  *
 755  * @params[in] NRFreqInfo_t *dlnrfreq
 756  * @return ROK     - success
 757  *         RFAILED - failure
 758  *
 759  * ****************************************************************/
 760 uint8_t BuildDLNRInfo(NRFreqInfo_t *dlnrfreq)
 761 {
 762    uint8_t idx=0;
 763    dlnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 764                        fdd.dlNrFreqInfo.nrArfcn;
 765    dlnrfreq->freqBandListNr.list.count = 1;
 766    dlnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 767    DU_ALLOC(dlnrfreq->freqBandListNr.list.array,dlnrfreq->freqBandListNr.list.size);
 768    if(dlnrfreq->freqBandListNr.list.array == NULLP)
 769    {
 770       return RFAILED;
 771    }
 772    for(idx=0;idx< dlnrfreq->freqBandListNr.list.count;idx++)
 773    {
 774       DU_ALLOC(dlnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 775       if(dlnrfreq->freqBandListNr.list.array[idx] == NULLP)
 776       {
 777          return RFAILED;
 778       }
 779    }
 780    dlnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 781                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
 782                                                                  freqBand[0].nrFreqBand;
 783    dlnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 784
 785    return ROK;
 786 }
 787
 788 /*******************************************************************
 789  *
 790  * @brief Builds NRCell ID
 791  *
 792  * @details
 793  *
 794  *    Function : BuildNrCellId
 795  *
 796  *    Functionality: Building the NR Cell ID
 797  *
 798  * @params[in] BIT_STRING_t *nrcell
 799  * @return ROK     - success
 800  *         RFAILED - failure
 801  *
 802  * ****************************************************************/
 803
 804 S16 BuildNrCellId(BIT_STRING_t *nrcell)
 805 {
 806    memset(nrcell->buf, 0, nrcell->size);
 807    nrcell->buf[4]   = 16;
 808    nrcell->bits_unused = 4;
 809    return ROK;
 810 }
 811
 812 /*******************************************************************
 813  *
 814  * @brief Builds Nrcgi
 815  *
 816  * @details
 817  *
 818  *    Function : BuildNrcgi
 819  *
 820  *    Functionality: Building the PLMN ID and NR Cell id
 821  *
 822  * @params[in] NRCGI_t *nrcgi
 823  * @return ROK     - success
 824  *         RFAILED - failure
 825  *
 826  * ****************************************************************/
 827 uint8_t BuildNrcgi(NRCGI_t *nrcgi)
 828 {
 829    uint8_t ret;
 830    uint8_t byteSize = 5;
 831    /* Allocate Buffer Memory */
 832    nrcgi->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 833    DU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
 834    if(nrcgi->pLMN_Identity.buf == NULLP)
 835    {
 836       return RFAILED;
 837    }
 838    ret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 839          nrcgi->pLMN_Identity.buf); // Building PLMN function
 840    if(ret != ROK)
 841    {
 842       return RFAILED;
 843    }
 844    /*nrCellIdentity*/
 845    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
 846    DU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
 847    if(nrcgi->nRCellIdentity.buf == NULLP)
 848    {
 849       return RFAILED;
 850    }
 851    BuildNrCellId(&nrcgi->nRCellIdentity);
 852
 853    return ROK;
 854 }
 855 /*******************************************************************
 856  *
 857  * @brief Builds FiveGStac
 858  *
 859  * @details
 860  *
 861  *    Function : BuildFiveGSTac
 862  *
 863  *    Functionality: Building the FiveGSTac
 864  *
 865  * @params[in] OCTET_STRING_t *fivegsTac
 866  * @return ROK     - success
 867  *         RFAILED - failure
 868  *
 869  * ****************************************************************/
 870 uint8_t BuildFiveGSTac(Served_Cell_Information_t *servcell)
 871 {
 872    DU_ALLOC(servcell->fiveGS_TAC,sizeof(FiveGS_TAC_t));
 873    if(servcell->fiveGS_TAC == NULLP)
 874    {
 875       return RFAILED;
 876    }
 877    servcell->fiveGS_TAC->size = 3 * sizeof(uint8_t);
 878    DU_ALLOC(servcell->fiveGS_TAC->buf,\
 879          sizeof(servcell->fiveGS_TAC->size));
 880    if(servcell->fiveGS_TAC->buf == NULLP)
 881    {
 882       return RFAILED;
 883    }
 884    servcell->fiveGS_TAC->buf[0] = 0;
 885    servcell->fiveGS_TAC->buf[1] = 0;
 886    servcell->fiveGS_TAC->buf[2] = duCfgParam.srvdCellLst[0].duCellInfo.tac;
 887    return ROK;
 888 }
 889 /*******************************************************************
 890  *
 891  * @brief Builds NR Mode
 892  *
 893  * @details
 894  *
 895  *    Function : BuildNrMode
 896  *
 897  *    Functionality: Building the NR Mode
 898  *
 899  * @params[in] NR_Mode_Info_t *fdd
 900  * @return ROK     - success
 901  *         RFAILED - failure
 902  *
 903  * ****************************************************************/
 904 uint8_t BuildNrMode(NR_Mode_Info_t *mode)
 905 {
 906    uint8_t BuildDLNRInforet=0;
 907    uint8_t BuildULNRInforet=0;
 908    /* FDD Mode */
 909    mode->present = NR_Mode_Info_PR_fDD;
 910    if(mode->present == NR_Mode_Info_PR_fDD)
 911    {
 912       DU_ALLOC(mode->choice.fDD,sizeof(FDD_Info_t));
 913       if(mode->choice.fDD == NULLP)
 914       {
 915          return RFAILED;
 916       }
 917       BuildULNRInforet = BuildULNRInfo(&mode->choice.fDD->uL_NRFreqInfo);
 918       if(BuildULNRInforet != ROK)
 919       {
 920          return RFAILED;
 921       }
 922       BuildDLNRInforet = BuildDLNRInfo(&mode->choice.fDD->dL_NRFreqInfo);
 923       if(BuildDLNRInforet != ROK)
 924       {
 925          return RFAILED;
 926       }
 927    }
 928    mode->choice.fDD->uL_Transmission_Bandwidth.nRSCS = \
 929                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 930                                                        f1Mode.mode.fdd.ulTxBw.nrScs;
 931    mode->choice.fDD->uL_Transmission_Bandwidth.nRNRB = \
 932                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 933                                                        f1Mode.mode.fdd.ulTxBw.nrb;
 934    mode->choice.fDD->dL_Transmission_Bandwidth.nRSCS = \
 935                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 936                                                        f1Mode.mode.fdd.dlTxBw.nrScs;
 937    mode->choice.fDD->dL_Transmission_Bandwidth.nRNRB = \
 938                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 939                                                        f1Mode.mode.fdd.dlTxBw.nrb;
 940    return ROK;
 941 }
 942 /*******************************************************************
 943  *
 944  * @brief Builds IE Extensions for Served PLMNs
 945  *
 946  * @details
 947  *
 948  *    Function : BuildExtensions
 949  *
 950  *    Functionality: Building the IE Extensions
 951  *
 952  * @params[in] struct ProtocolExtensionContainer_4624P3 *buildextend
 953  * @return ROK     - success
 954  *         RFAILED - failure
 955  *
 956  * ****************************************************************/
 957 uint8_t BuildExtensions(ProtocolExtensionContainer_4624P3_t **ieExtend)
 958 {
 959    uint8_t idx;
 960    uint8_t plmnidx;
 961    uint8_t extensionCnt=1;
 962    uint8_t sliceId=0;
 963    uint8_t sdId;
 964    DU_ALLOC(*ieExtend,sizeof(ProtocolExtensionContainer_4624P3_t));
 965    if((*ieExtend) == NULLP)
 966    {
 967       return RFAILED;
 968    }
 969    (*ieExtend)->list.count = extensionCnt;
 970    (*ieExtend)->list.size = \
 971                             extensionCnt * sizeof(ServedPLMNs_ItemExtIEs_t *);
 972    DU_ALLOC((*ieExtend)->list.array,(*ieExtend)->list.size);
 973    if((*ieExtend)->list.array == NULLP)
 974    {
 975       return RFAILED;
 976    }
 977    for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
 978    {
 979       DU_ALLOC((*ieExtend)->list.array[plmnidx],\
 980             sizeof(ServedPLMNs_ItemExtIEs_t));
 981       if((*ieExtend)->list.array[plmnidx] == NULLP)
 982       {
 983          return RFAILED;
 984       }
 985    }
 986    idx = 0;
 987    (*ieExtend)->list.array[idx]->id = ProtocolIE_ID_id_TAISliceSupportList;
 988    (*ieExtend)->list.array[idx]->criticality = Criticality_ignore;
 989    (*ieExtend)->list.array[idx]->extensionValue.present = \
 990                                                           ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
 991    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 992       list.count = 1;
 993    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 994       list.size = sizeof(SliceSupportItem_t *);
 995    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 996          list.array,sizeof(SliceSupportItem_t *));
 997    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 998          list.array == NULLP)
 999    {
1000       return RFAILED;
1001    }
1002    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1003          list.array[sliceId],sizeof(SliceSupportItem_t));
1004    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1005          list.array[sliceId] == NULLP)
1006    {
1007       return RFAILED;
1008    }
1009    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1010       list.array[sliceId]->sNSSAI.sST.size = sizeof(uint8_t);
1011    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
1012          .list.array[sliceId]->sNSSAI.sST.buf,(*ieExtend)->list.array[idx]->\
1013          extensionValue.choice.SliceSupportList.\
1014          list.array[sliceId]->sNSSAI.sST.size);
1015    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
1016          .list.array[sliceId]->sNSSAI.sST.buf == NULLP)
1017    {
1018       return RFAILED;
1019    }
1020    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1021       list.array[sliceId]->sNSSAI.sST.buf[0] = 3;
1022    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1023          list.array[sliceId]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1024    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1025          list.array[sliceId]->sNSSAI.sD == NULLP)
1026    {
1027       return RFAILED;
1028    }
1029    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1030       list.array[sliceId]->sNSSAI.sD->size = 3*sizeof(uint8_t);
1031    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1032          list.array[sliceId]->sNSSAI.sD->buf,(*ieExtend)->list.array[idx]->extensionValue.choice.\
1033          SliceSupportList.list.array[sliceId]->sNSSAI.sD->size);
1034    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1035          list.array[sliceId]->sNSSAI.sD->buf == NULLP)
1036    {
1037       return RFAILED;
1038    }
1039    sdId = 0;
1040    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1041       list.array[sliceId]->sNSSAI.sD->buf[sdId] = 3;
1042    sdId++;
1043    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1044       list.array[sliceId]->sNSSAI.sD->buf[sdId] = 6;
1045    sdId++;
1046    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1047       list.array[sliceId]->sNSSAI.sD->buf[sdId] = 9;
1048    return ROK;
1049 }
1050 /*******************************************************************
1051  *
1052  * @brief Builds Served PLMN
1053  *
1054  * @details
1055  *
1056  *    Function : BuildServedPlmn
1057  *
1058  *    Functionality: Building the Served PLMN
1059  *
1060  * @params[in] GNB_DU_Served_Cells_Item_t *srvCellItem
1061  * @return ROK     - success
1062  *         RFAILED - failure
1063  *
1064  * ****************************************************************/
1065 uint8_t  BuildServedPlmn(ServedPLMNs_List_t *srvplmn)
1066 {
1067    uint8_t  plmnidx;
1068    uint8_t  servPlmnCnt=1;
1069    uint8_t buildPlmnIdret=0;
1070    uint8_t BuildExtensionsret=0;
1071    srvplmn->list.count = servPlmnCnt;
1072    srvplmn->list.size = \
1073                         servPlmnCnt*sizeof(ServedPLMNs_Item_t *);
1074    DU_ALLOC(srvplmn->list.array,srvplmn->list.size);
1075    if(srvplmn->list.array == NULLP)
1076    {
1077       return RFAILED;
1078    }
1079    for(plmnidx=0; plmnidx<servPlmnCnt; plmnidx++)
1080    {
1081       DU_ALLOC(srvplmn->list.array[plmnidx],\
1082             sizeof(ServedPLMNs_Item_t));
1083       if(srvplmn->list.array[plmnidx] == NULLP)
1084       {
1085          return RFAILED;
1086       }
1087    }
1088    srvplmn->list.array[0]->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
1089    DU_ALLOC(srvplmn->list.array[0]->pLMN_Identity.buf, srvplmn->list.array[0]->pLMN_Identity.size);
1090    buildPlmnIdret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
1091          srvplmn->list.array[0]->pLMN_Identity.buf);
1092    if(buildPlmnIdret!= ROK)
1093    {
1094       return RFAILED;
1095    }
1096    BuildExtensionsret = BuildExtensions(&srvplmn->list.array[0]->iE_Extensions);
1097    if(BuildExtensionsret!= ROK)
1098    {
1099       return RFAILED;
1100    }
1101    return ROK;
1102 }
1103 /*******************************************************************
1104  *
1105  * @brief Builds Served Cell List
1106  *
1107  * @details
1108  *
1109  *    Function : BuildServedCellList
1110  *
1111  *    Functionality: Building Served Cell List
1112  *
1113  * @params[in] PLMNID plmn
1114  * @return ROK     - success
1115  *         RFAILED - failure
1116  *
1117  * ****************************************************************/
1118
1119 uint8_t BuildServedCellList(GNB_DU_Served_Cells_List_t *duServedCell)
1120 {
1121    uint8_t  BuildNrcgiret=0;
1122    uint8_t  BuildFiveGSTacret=0;
1123    uint8_t  BuildServedPlmnret=0;
1124    uint8_t  BuildNrModeret=0;
1125    uint8_t  idx;
1126    uint8_t  plmnidx;
1127    uint8_t  plmnCnt=1;
1128    GNB_DU_Served_Cells_Item_t *srvCellItem;
1129    duServedCell->list.size = plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t *);
1130    duServedCell->list.count = plmnCnt;
1131
1132    DU_ALLOC(duServedCell->list.array, duServedCell->list.size);
1133    if(duServedCell->list.array == NULLP)
1134    {
1135       return RFAILED;
1136    }
1137    for(plmnidx=0; plmnidx<plmnCnt; plmnidx++)
1138    {
1139       DU_ALLOC(duServedCell->list.array[plmnidx],\
1140             sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1141       if(duServedCell->list.array[plmnidx] == NULLP)
1142       {
1143          return RFAILED;
1144       }
1145    }
1146    idx = 0;
1147    duServedCell->list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_Served_Cells_Item;
1148    duServedCell->list.array[idx]->criticality = Criticality_reject;
1149    duServedCell->list.array[idx]->value.present = \
1150                                                   GNB_DU_Served_Cells_ItemIEs__value_PR_GNB_DU_Served_Cells_Item;
1151    srvCellItem = \
1152                  &duServedCell->list.array[idx]->value.choice.GNB_DU_Served_Cells_Item;
1153    /*nRCGI*/
1154    BuildNrcgiret = BuildNrcgi(&srvCellItem->served_Cell_Information.nRCGI);
1155    if(BuildNrcgiret != ROK)
1156    {
1157       return RFAILED;
1158    }
1159    /*nRPCI*/
1160    srvCellItem->served_Cell_Information.nRPCI = \
1161                                                 duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
1162
1163    /*fiveGS_TAC*/
1164    BuildFiveGSTacret = BuildFiveGSTac(&srvCellItem->served_Cell_Information);
1165    if(BuildFiveGSTacret != ROK)
1166    {
1167       return RFAILED;
1168    }
1169    /*Served PLMNs*/
1170    BuildServedPlmnret = BuildServedPlmn(&srvCellItem->served_Cell_Information.servedPLMNs);
1171    if(BuildServedPlmnret !=ROK)
1172    {
1173       return RFAILED;
1174    }
1175    /*nR Mode Info with FDD*/
1176    BuildNrModeret = BuildNrMode(&srvCellItem->served_Cell_Information.nR_Mode_Info);
1177    if(BuildNrModeret != ROK)
1178    {
1179       return RFAILED;
1180    }
1181    /*Measurement timing Config*/
1182    srvCellItem->served_Cell_Information.measurementTimingConfiguration.\
1183       size = sizeof(uint8_t);
1184    DU_ALLOC(srvCellItem->served_Cell_Information.\
1185          measurementTimingConfiguration.buf,srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1186    if(srvCellItem->served_Cell_Information.\
1187          measurementTimingConfiguration.buf == NULLP)
1188    {
1189       return RFAILED;
1190    }
1191    srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf[0] = \
1192                                                                                 duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
1193
1194    /* GNB DU System Information */
1195    DU_ALLOC(srvCellItem->gNB_DU_System_Information,
1196          sizeof(GNB_DU_System_Information_t));
1197    if(!srvCellItem->gNB_DU_System_Information)
1198    {
1199       return RFAILED;
1200    }
1201    /* MIB */
1202    srvCellItem->gNB_DU_System_Information->mIB_message.size = duCfgParam.srvdCellLst[0].duSysInfo.mibLen;
1203    DU_ALLOC(srvCellItem->gNB_DU_System_Information->mIB_message.buf,
1204          srvCellItem->gNB_DU_System_Information->mIB_message.size);
1205    if(!srvCellItem->gNB_DU_System_Information->mIB_message.buf)
1206    {
1207       return RFAILED;
1208    }
1209    memcpy(srvCellItem->gNB_DU_System_Information->mIB_message.buf, duCfgParam.srvdCellLst[0].duSysInfo.mibMsg, \
1210                    srvCellItem->gNB_DU_System_Information->mIB_message.size);
1211
1212    /* SIB1 */
1213    srvCellItem->gNB_DU_System_Information->sIB1_message.size =\
1214                                                               duCfgParam.srvdCellLst[0].duSysInfo.sib1Len;
1215
1216    DU_ALLOC(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,
1217          srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1218    if(!srvCellItem->gNB_DU_System_Information->sIB1_message.buf)
1219    {
1220       return RFAILED;
1221    }
1222    for(int x=0; x<srvCellItem->gNB_DU_System_Information->sIB1_message.size; x++)
1223    {
1224       srvCellItem->gNB_DU_System_Information->sIB1_message.buf[x]=\
1225                                                                   duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg[x];
1226    }
1227    return ROK;
1228 }
1229 /*******************************************************************
1230  *
1231  * @brief Builds RRC Version
1232  *
1233  * @details
1234  *
1235  *    Function : BuildRrcVer
1236  *
1237  *    Functionality: Building RRC Version
1238  *
1239  * @params[in] int idx,int elementCnt,RRC_Version_t *rrcver
1240  * @return ROK     - success
1241  *         RFAILED - failure
1242  *
1243  * ****************************************************************/
1244 uint8_t BuildRrcVer(RRC_Version_t *rrcVer)
1245 {
1246    uint8_t rrcExt;
1247    uint8_t rrcLatest;
1248    rrcVer->latest_RRC_Version.size = sizeof(uint8_t);
1249    DU_ALLOC(rrcVer->latest_RRC_Version.buf,sizeof(uint8_t));
1250    if(rrcVer->latest_RRC_Version.buf == NULLP)
1251    {
1252       return RFAILED;
1253    }
1254    rrcVer->latest_RRC_Version.buf[0] = 0;
1255    rrcVer->latest_RRC_Version.bits_unused = 5;
1256    DU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1257    if(rrcVer->iE_Extensions == NULLP)
1258    {
1259       return RFAILED;
1260    }
1261    rrcVer->iE_Extensions->list.count = 1;
1262    rrcVer->iE_Extensions->list.size = sizeof(RRC_Version_ExtIEs_t *);
1263    DU_ALLOC(rrcVer->iE_Extensions->list.array,rrcVer->iE_Extensions->list.size);
1264    if(rrcVer->iE_Extensions->list.array == NULLP)
1265    {
1266       return RFAILED;
1267    }
1268    rrcExt = 0;
1269    DU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
1270          sizeof(RRC_Version_ExtIEs_t));
1271    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
1272    {
1273       return RFAILED;
1274    }
1275    rrcVer->iE_Extensions->list.array[rrcExt]->id = \
1276                                                    ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
1277    rrcVer->iE_Extensions->list.array[rrcExt]->criticality = Criticality_reject;
1278    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.present =\
1279                                                                       RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
1280    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1281       .Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
1282    DU_ALLOC(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1283          .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1284          array[rrcExt]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1285    if(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1286          .Latest_RRC_Version_Enhanced.buf == NULLP)
1287    {
1288       return RFAILED;
1289    }
1290    rrcLatest = 0;
1291    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1292       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 15;
1293    rrcLatest++;
1294    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1295       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 5;
1296    rrcLatest++;
1297    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1298       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 0;
1299    return ROK;
1300 }
1301 /*******************************************************************
1302  *
1303  * @brief Sends F1 msg over SCTP
1304  *
1305  * @details
1306  *
1307  *    Function : sendF1APMsg
1308  *
1309  *    Functionality: Sends F1 msg over SCTP
1310  *
1311  * @params[in] Region region
1312  *             Pool pool
1313  * @return ROK     - success
1314  *         RFAILED - failure
1315  *
1316  * ****************************************************************/
1317 uint8_t sendF1APMsg()
1318 {
1319    Buffer *mBuf = NULLP;
1320
1321    if(ODU_GET_MSG_BUF(DU_APP_MEM_REGION, DU_POOL, &mBuf) == ROK)
1322    {
1323       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
1324       {
1325             ODU_PRINT_MSG(mBuf, 0,0);
1326
1327             if(sctpSend(mBuf, F1_INTERFACE) != ROK)
1328             {
1329                DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
1330                ODU_PUT_MSG_BUF(mBuf);
1331                return RFAILED;
1332             }
1333       }
1334       else
1335       {
1336          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
1337          ODU_PUT_MSG_BUF(mBuf);
1338          return RFAILED;
1339       }
1340       ODU_PUT_MSG_BUF(mBuf);
1341    }
1342    else
1343    {
1344       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
1345       return RFAILED;
1346    }
1347    return ROK;
1348 } /* sendF1APMsg */
1349
1350 /*******************************************************************
1351  *
1352  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1353  *
1354  * @details
1355  *
1356  *    Function :  FreeRrcVer
1357  *
1358  *    Functionality: deallocating the memory of function BuildRrcVer
1359  *
1360  * @params[in] RRC_Version_t *rrcVer
1361  *
1362  * @return void
1363  *
1364  *****************************************************************/
1365 void FreeRrcVer(RRC_Version_t *rrcVer)
1366 {
1367    if(rrcVer->latest_RRC_Version.buf != NULLP)
1368    {
1369       if(rrcVer->iE_Extensions != NULLP)
1370       {
1371          if(rrcVer->iE_Extensions->list.array != NULLP)
1372          {
1373             if(rrcVer->iE_Extensions->list.array[0] != NULLP)
1374             {
1375                if(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf
1376                      != NULLP)
1377                {
1378                   DU_FREE(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice\
1379                         .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1380                         array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1381                }
1382                DU_FREE(rrcVer->iE_Extensions->list.array[0],sizeof(RRC_Version_ExtIEs_t));
1383             }
1384             DU_FREE(rrcVer->iE_Extensions->list.array,sizeof(RRC_Version_ExtIEs_t*));
1385          }
1386          DU_FREE(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1387       }
1388       DU_FREE(rrcVer->latest_RRC_Version.buf,rrcVer->latest_RRC_Version.size);
1389    }
1390 }
1391 /*******************************************************************
1392  *
1393  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1394  *
1395  * @details
1396  *
1397  *    Function :  FreeServedCellList
1398  *
1399  *    Functionality:  deallocating the memory of function BuildServedCellList
1400
1401  *
1402  * @params[in] GNB_DU_Served_Cells_List_t *duServedCell
1403  *
1404  * @return void
1405  *
1406  * ****************************************************************/
1407 void FreeServedCellList( GNB_DU_Served_Cells_List_t *duServedCell)
1408 {
1409    uint8_t   plmnCnt=1;
1410    uint8_t  sliceId=0;
1411    uint8_t  extensionCnt=1;
1412    uint8_t  plmnIdx=0;
1413    GNB_DU_Served_Cells_Item_t *srvCellItem;
1414    ServedPLMNs_Item_t  *servedPlmnItem;
1415    SliceSupportItem_t  *sliceSupportItem;
1416
1417    if(duServedCell->list.array!=NULLP)
1418    {
1419       if(duServedCell->list.array[0]!=NULLP)
1420       {
1421          srvCellItem= &duServedCell->list.array[0]->value.choice.GNB_DU_Served_Cells_Item;
1422
1423          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1424                srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size * sizeof(uint8_t));
1425          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1426                srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size * sizeof(uint8_t));
1427
1428          if(srvCellItem->served_Cell_Information.fiveGS_TAC!=NULLP)
1429          {
1430             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
1431                   sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
1432             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,sizeof(FiveGS_TAC_t));
1433          }
1434
1435          if(srvCellItem->served_Cell_Information.servedPLMNs.list.array!=NULLP)
1436          {
1437             if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx] != NULLP)
1438             {
1439                servedPlmnItem = srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx];
1440                DU_FREE(servedPlmnItem->pLMN_Identity.buf, servedPlmnItem->pLMN_Identity.size * sizeof(uint8_t));
1441
1442                if(servedPlmnItem->iE_Extensions != NULLP)
1443                {
1444                   if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1445                   {
1446                      if(servedPlmnItem->iE_Extensions->list.array[0] != NULLP)
1447                      {
1448                         if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.list.\
1449                               array != NULLP)
1450                         {
1451                            if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.list.\
1452                                  array[sliceId] != NULLP)
1453                            {
1454                               sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1455                                                  SliceSupportList.list.array[sliceId];
1456
1457                               DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sizeof(uint8_t));
1458
1459                               if(sliceSupportItem->sNSSAI.sD != NULLP)
1460                               {
1461                                  DU_FREE(sliceSupportItem->sNSSAI.sD->buf, sliceSupportItem->sNSSAI.sD->size);
1462                                  DU_FREE(sliceSupportItem->sNSSAI.sD, sizeof(OCTET_STRING_t));
1463                               }
1464
1465                               DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1466                                     list.array[sliceId], sizeof(SliceSupportItem_t));
1467                            }
1468                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1469                                  list.array, sizeof(SliceSupportItem_t*));
1470                         }
1471                         DU_FREE(servedPlmnItem->iE_Extensions->list.array[0], sizeof(ServedPLMNs_ItemExtIEs_t));
1472                      }
1473                      DU_FREE(servedPlmnItem->iE_Extensions->list.array, extensionCnt*sizeof(ServedPLMNs_ItemExtIEs_t*));
1474                   }
1475                   DU_FREE(servedPlmnItem->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P3_t));
1476                }
1477                DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx], sizeof(ServedPLMNs_Item_t));
1478             }
1479             DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array, sizeof(ServedPLMNs_Item_t *));
1480          }
1481
1482          if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD != NULLP)
1483          {
1484             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
1485                   freqBandListNr.list.array != NULLP)
1486             {
1487                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.\
1488                      list.array[0],sizeof(FreqBandNrItem_t));
1489                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.\
1490                      list.array,sizeof(FreqBandNrItem_t*));
1491             }
1492
1493             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1494                   freqBandListNr.list.array)
1495             {
1496                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1497                      freqBandListNr.list.array[0],sizeof(FreqBandNrItem_t));
1498                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1499                      freqBandListNr.list.array,sizeof(FreqBandNrItem_t *));
1500             }
1501             DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD, sizeof(FDD_Info_t));
1502          }
1503
1504          DU_FREE(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1505                srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1506
1507          if(srvCellItem->gNB_DU_System_Information != NULLP)
1508          {
1509             if(srvCellItem->gNB_DU_System_Information->mIB_message.buf != NULLP)
1510             {
1511                DU_FREE(srvCellItem->gNB_DU_System_Information->mIB_message.buf,\
1512                      srvCellItem->gNB_DU_System_Information->mIB_message.size);
1513             }
1514
1515             if(srvCellItem->gNB_DU_System_Information->sIB1_message.buf != NULLP)
1516             {
1517                DU_FREE(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,\
1518                      srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1519             }
1520
1521             DU_FREE(srvCellItem->gNB_DU_System_Information, sizeof(GNB_DU_System_Information_t));
1522          }
1523
1524          DU_FREE(duServedCell->list.array[0], sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1525       }
1526       DU_FREE(duServedCell->list.array, plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t*));
1527    }
1528 }
1529
1530 /*******************************************************************
1531  *
1532  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1533  *
1534  * @details
1535  *
1536  *    Function :  FreeF1SetupReq
1537  *
1538  *    Functionality:  deallocating the memory of function BuildAndSendF1SetupReq
1539  *
1540  * @params[in] F1AP_PDU_t *f1apMsg
1541  *
1542  * @return void
1543  *
1544  * ****************************************************************/
1545 void FreeF1SetupReq(F1AP_PDU_t *f1apMsg)
1546 {
1547    uint8_t ieIdx, ieIdx2;
1548    F1SetupRequest_t *f1SetupReq=NULLP;
1549
1550    if(f1apMsg != NULLP)
1551    {
1552       if(f1apMsg->choice.initiatingMessage != NULLP)
1553       {
1554          f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1555          if(f1SetupReq->protocolIEs.list.array != NULLP)
1556          {
1557             for(ieIdx = 0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
1558             {
1559                if(f1SetupReq->protocolIEs.list.array[ieIdx] != NULLP)
1560                {
1561                   switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
1562                   {
1563                      case ProtocolIE_ID_id_TransactionID:
1564                         break;
1565                      case ProtocolIE_ID_id_gNB_DU_ID:
1566                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1567                               f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1568                         break;
1569                      case ProtocolIE_ID_id_gNB_DU_Name:
1570                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,\
1571                               strlen((char *)duCfgParam.duName));
1572                         break;
1573                      case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
1574                         FreeServedCellList(&f1SetupReq->protocolIEs.list.\
1575                               array[ieIdx]->value.choice.GNB_DU_Served_Cells_List);
1576                         break;
1577                      case ProtocolIE_ID_id_GNB_DU_RRC_Version:
1578                         FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version);
1579                         break;
1580                      default:
1581                         DU_LOG("\nERROR  -->  Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id);
1582                         break;
1583                   }
1584                }
1585             }
1586             for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++)
1587             {
1588                DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx2],sizeof(F1SetupRequestIEs_t));
1589             }
1590             DU_FREE(f1SetupReq->protocolIEs.list.array,\
1591                   f1SetupReq->protocolIEs.list.size);
1592          }
1593          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1594       }
1595       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1596    }
1597 }
1598 /*******************************************************************
1599  *
1600  * @brief Builds and Send the F1SetupRequest
1601  *
1602  * @details
1603  *
1604  *    Function : BuildAndSendF1SetupReq
1605  *
1606  * Functionality:Fills the F1SetupRequest
1607  *
1608  * @return ROK     - success
1609  *         RFAILED - failure
1610  *
1611  ******************************************************************/
1612 uint8_t BuildAndSendF1SetupReq()
1613 {
1614    uint8_t   ret, ieIdx, elementCnt;
1615    F1AP_PDU_t                 *f1apMsg = NULLP;
1616    F1SetupRequest_t           *f1SetupReq=NULLP;
1617    GNB_DU_Served_Cells_List_t *duServedCell=NULLP;
1618    RRC_Version_t              *rrcVer=NULLP;
1619    asn_enc_rval_t             encRetVal;        /* Encoder return value */
1620    ret= RFAILED;
1621
1622    DU_LOG("\nINFO   -->  F1AP : Building F1 Setup Request\n");
1623    do
1624    {
1625       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1626       if(f1apMsg == NULLP)
1627       {
1628          break;
1629       }
1630       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1631       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1632       if(f1apMsg->choice.initiatingMessage == NULLP)
1633       {
1634          break;
1635       }
1636       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_F1Setup;
1637       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
1638       f1apMsg->choice.initiatingMessage->value.present = \
1639                                                          InitiatingMessage__value_PR_F1SetupRequest;
1640
1641       f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1642
1643       elementCnt = (duCfgParam.duName != NULL) ? 5 : 4;
1644
1645       f1SetupReq->protocolIEs.list.count = elementCnt;
1646       f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t );
1647
1648       /* Initialize the F1Setup members */
1649       DU_ALLOC(f1SetupReq->protocolIEs.list.array,f1SetupReq->protocolIEs.list.size);
1650       if(f1SetupReq->protocolIEs.list.array == NULLP)
1651       {
1652          break;
1653       }
1654       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
1655       {
1656          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx],\
1657                sizeof(F1SetupRequestIEs_t));
1658          if(f1SetupReq->protocolIEs.list.array[ieIdx] == NULLP)
1659          {
1660             break;
1661          }
1662       }
1663
1664       ieIdx = 0;
1665       /*TransactionID*/
1666       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransactionID;
1667       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1668       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present =\
1669                                                                F1SetupRequestIEs__value_PR_TransactionID;
1670       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = \
1671                                                                              TRANS_ID;
1672
1673       /*DU ID*/
1674       ieIdx++;
1675       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
1676       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1677       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1678                                                                 F1SetupRequestIEs__value_PR_GNB_DU_ID;
1679       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size =\
1680                                                                              sizeof(uint8_t);
1681
1682       DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1683             f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1684       if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == \
1685             NULLP)
1686       {
1687          break;
1688       }
1689
1690       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] =\
1691          duCfgParam.duId;
1692
1693       /*DU Name*/
1694       if(duCfgParam.duName != NULL)
1695       {
1696          ieIdx++;
1697          f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_Name;
1698          f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
1699          f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = F1SetupRequestIEs__value_PR_GNB_DU_Name;
1700          f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.size =\
1701             strlen((char *)duCfgParam.duName);
1702          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.\
1703                GNB_DU_Name.buf, strlen((char *)duCfgParam.duName));
1704          if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.\
1705                buf == NULLP)
1706          {
1707             break;
1708          }
1709          strcpy((char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.\
1710                choice.GNB_DU_Name.buf,
1711                (char*)&duCfgParam.duName);
1712
1713       }
1714
1715       /*Served Cell list */
1716       ieIdx++;
1717       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1718                                                      ProtocolIE_ID_id_gNB_DU_Served_Cells_List;
1719       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1720       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1721                                                                 F1SetupRequestIEs__value_PR_GNB_DU_Served_Cells_List;
1722       duServedCell = &f1SetupReq->protocolIEs.list.\
1723                      array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
1724       if(BuildServedCellList(duServedCell))
1725       {
1726          break;
1727       }
1728       /*RRC Version*/
1729       ieIdx++;
1730       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1731                                                      ProtocolIE_ID_id_GNB_DU_RRC_Version ;
1732       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1733       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1734                                                                 F1SetupRequestIEs__value_PR_RRC_Version;
1735       rrcVer = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
1736       if(BuildRrcVer(rrcVer))
1737       {
1738          break;
1739       }
1740       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1741
1742       /* Encode the F1SetupRequest type as APER */
1743       memset(encBuf, 0, ENC_BUF_MAX_LEN);
1744       encBufSize = 0;
1745       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1746             encBuf);
1747
1748       /* Encode results */
1749       if(encRetVal.encoded == ENCODE_FAIL)
1750       {
1751          DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupRequest structure (at %s)\n",\
1752                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1753          break;
1754       }
1755       else
1756       {
1757          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1SetupRequest\n");
1758          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
1759          {
1760             printf("%x",encBuf[ieIdx]);
1761          }
1762       }
1763
1764       /* Sending msg */
1765       if(sendF1APMsg() != ROK)
1766       {
1767          DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup request failed");
1768          break;
1769       }
1770
1771       ret=ROK;
1772       break;
1773    }while(true);
1774
1775    FreeF1SetupReq(f1apMsg);
1776
1777    return ret;
1778 }/* End of BuildAndSendF1SetupReq */
1779
1780 /*******************************************************************
1781  *
1782  * @brief Deallocating memory allocated for Served_Cells_To_Modify_Item_t
1783  *
1784  * @details
1785  *
1786  *    Function : freeCellsToModifyItem
1787  *
1788  *    Functionality: Deallocating memory of variables allocated in
1789  *                    BuildAndSendDUConfigUpdate function
1790  *
1791  * @params[in]  Served_Cells_To_Modify_Item_t *modifyItem
1792  *
1793  * @return ROK     - void
1794  *
1795  * ****************************************************************/
1796
1797 void freeCellsToModifyItem(Served_Cells_To_Modify_Item_t *modifyItem)
1798 {
1799    uint8_t arrIdx=0,i=0;
1800    ServedPLMNs_Item_t *servedPlmnItem = NULLP;
1801    SliceSupportItem_t *sliceSupportItem = NULLP;
1802
1803    DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf, modifyItem->oldNRCGI.pLMN_Identity.size);
1804    DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf, modifyItem->oldNRCGI.nRCellIdentity.size);
1805
1806    DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1807            modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
1808    DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1809          modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
1810
1811    if(modifyItem->served_Cell_Information.servedPLMNs.list.array != NULLP)
1812    {
1813       if(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx] != NULLP)
1814       {
1815          servedPlmnItem = modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx];
1816
1817          DU_FREE(servedPlmnItem->pLMN_Identity.buf,servedPlmnItem->pLMN_Identity.size);
1818
1819          if(servedPlmnItem->iE_Extensions != NULLP)
1820          {
1821             if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1822             {
1823                if(servedPlmnItem->iE_Extensions->list.array[arrIdx] != NULLP)
1824                {
1825                   if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.list.array != NULLP)
1826                   {
1827                      if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.list.array[arrIdx] != NULLP)
1828                      {
1829                         sliceSupportItem = modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx]->iE_Extensions->\
1830                                            list.array[arrIdx]->extensionValue.choice.SliceSupportList.list.array[arrIdx];
1831
1832                         DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sliceSupportItem->sNSSAI.sST.size);
1833                         if(sliceSupportItem->sNSSAI.sD != NULLP)
1834                         {
1835                            DU_FREE(sliceSupportItem->sNSSAI.sD->buf, sliceSupportItem->sNSSAI.sD->size);
1836                            DU_FREE(sliceSupportItem->sNSSAI.sD,sizeof(OCTET_STRING_t));
1837                         }
1838                         DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1839                               list.array[arrIdx], sizeof(SliceSupportItem_t));
1840                      }
1841                      DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.list.array,
1842                            servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.list.size);
1843                   }
1844                }
1845                for(i=0; i < servedPlmnItem->iE_Extensions->list.count ; i++)
1846                {
1847                   DU_FREE(servedPlmnItem->iE_Extensions->list.array[i], sizeof(ServedPLMNs_ItemExtIEs_t ));
1848                }
1849                DU_FREE(servedPlmnItem->iE_Extensions->list.array, servedPlmnItem->iE_Extensions->list.size);
1850             }
1851             DU_FREE(servedPlmnItem->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1852          }
1853       }
1854       for(i=0;i<modifyItem->served_Cell_Information.servedPLMNs.list.count;i++)
1855       {
1856          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[i], sizeof(ServedPLMNs_Item_t));
1857       }
1858       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1859             modifyItem->served_Cell_Information.servedPLMNs.list.size);
1860    }
1861
1862    if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD != NULLP)
1863    {
1864       if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1865       {
1866          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
1867                array[arrIdx], sizeof(FreqBandNrItem_t));
1868          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array, \
1869                modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1870       }
1871
1872       if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1873       {
1874          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.\
1875              array[arrIdx], sizeof(FreqBandNrItem_t));
1876          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,\
1877                modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1878       }
1879       DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD,sizeof(FDD_Info_t));
1880    }
1881
1882    DU_FREE(modifyItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1883       modifyItem->served_Cell_Information.measurementTimingConfiguration.size);
1884 }
1885
1886 /*******************************************************************
1887  *
1888  * @brief Deallocating memory of BuildAndSendDUConfigUpdate
1889  *
1890  * @details
1891  *
1892  *    Function : FreeDUConfigUpdate
1893  *
1894  *    Functionality: Deallocating memory of variables allocated in
1895  *                    BuildAndSendDUConfigUpdate function
1896  *
1897  * @params[in]  F1AP_PDU_t *f1apDuCfg
1898  *
1899  * @return ROK     - void
1900  *
1901  * ****************************************************************/
1902 void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg)
1903 {
1904    uint8_t  ieIdx=0, cellModifyIdx=0, cellDeleteIdx=0;
1905    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
1906    Served_Cells_To_Modify_List_t  *cellsToModify=NULLP;
1907    Served_Cells_To_Delete_List_t  *cellsToDelete=NULLP;
1908    Served_Cells_To_Delete_Item_t  *deleteItem = NULLP;
1909    Served_Cells_To_Delete_ItemIEs_t *deleteItemIe = NULLP;
1910
1911    if(f1apDuCfg != NULLP)
1912    {
1913       if(f1apDuCfg->choice.initiatingMessage != NULLP)
1914       {
1915          duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->\
1916                        value.choice.GNBDUConfigurationUpdate;
1917          if(duCfgUpdate->protocolIEs.list.array != NULLP)
1918          {
1919             for(ieIdx=0; ieIdx<duCfgUpdate->protocolIEs.list.count; ieIdx++)
1920             {
1921                if(duCfgUpdate->protocolIEs.list.array[ieIdx] != NULLP)
1922                {
1923                   switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
1924                   {
1925                      case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
1926                         {
1927                            cellsToModify = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1928                                            value.choice.Served_Cells_To_Modify_List;
1929                            if(cellsToModify->list.array != NULLP)
1930                            {
1931                               for(cellModifyIdx=0; cellModifyIdx<cellsToModify->list.count ;cellModifyIdx++)
1932                               {
1933                                  if(cellsToModify->list.array[cellModifyIdx] != NULLP)
1934                                  {
1935                                     freeCellsToModifyItem(&cellsToModify->list.array[cellModifyIdx]->value.choice.\
1936                                           Served_Cells_To_Modify_Item);
1937                                     DU_FREE(cellsToModify->list.array[cellModifyIdx],\
1938                                           sizeof(Served_Cells_To_Modify_ItemIEs_t));
1939                                  }
1940                               }
1941                               DU_FREE(cellsToModify->list.array,cellsToModify->list.size);
1942                            }
1943                            break;
1944                         }
1945                      case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
1946                         {
1947                            cellsToDelete = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1948                                            value.choice.Served_Cells_To_Delete_List;
1949                            if(cellsToDelete->list.array != NULLP)
1950                            {
1951                               for(cellDeleteIdx=0; cellDeleteIdx<cellsToDelete->list.count ;cellDeleteIdx++)
1952                               {
1953                                  if(cellsToDelete->list.array[cellDeleteIdx] != NULLP)
1954                                  {
1955                                     deleteItemIe = ((Served_Cells_To_Delete_ItemIEs_t*)\
1956                                           cellsToDelete->list.array[cellDeleteIdx]);
1957                                     deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
1958                                     DU_FREE(deleteItem->oldNRCGI.pLMN_Identity.buf,\
1959                                           deleteItem->oldNRCGI.pLMN_Identity.size);
1960                                     DU_FREE(deleteItem->oldNRCGI.nRCellIdentity.buf,\
1961                                           deleteItem->oldNRCGI.nRCellIdentity.size);
1962                                     DU_FREE(cellsToDelete->list.array[cellDeleteIdx],\
1963                                           sizeof(Served_Cells_To_Delete_ItemIEs_t));
1964                                  }
1965                               }
1966                               DU_FREE(cellsToDelete->list.array,cellsToDelete->list.size);
1967                            }
1968
1969                            break;
1970                         }
1971                      case ProtocolIE_ID_id_gNB_DU_ID:
1972                         {
1973                            DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1974                                  duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1975                            break;
1976                         }
1977                   }
1978                   DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx],\
1979                         sizeof(GNBDUConfigurationUpdateIEs_t));
1980                }
1981             }
1982             DU_FREE(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
1983          }
1984          DU_FREE(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
1985       }
1986       DU_FREE(f1apDuCfg, (Size)sizeof(F1AP_PDU_t));
1987    }
1988 }
1989
1990 /*******************************************************************
1991  *
1992  * @brief Fills Served Plmns required in ServCellInfo IE
1993  *
1994  * @details
1995  *
1996  *    Function : fillServedPlmns
1997  *
1998  *    Functionality: Fills Served Plmns required in ServCellInfo IE
1999  *
2000  * @params[in] Pointer to ServedPLMNs_List_t *
2001  *
2002  * @return ROK     - success
2003  *         RFAILED - failure
2004  *
2005  *****************************************************************/
2006
2007 uint8_t fillServedPlmns(ServedPLMNs_List_t *servedPlmn)
2008 {
2009    uint8_t ieIdx, ieListCnt;
2010
2011    servedPlmn->list.array[0]->pLMN_Identity.size = 3*sizeof(uint8_t);
2012    DU_ALLOC(servedPlmn->list.array[0]->pLMN_Identity.buf, servedPlmn->list.\
2013          array[0]->pLMN_Identity.size);
2014    if(servedPlmn->list.array[0]->pLMN_Identity.buf == NULLP)
2015    {
2016       return RFAILED;
2017    }
2018    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.plmn[0],\
2019          servedPlmn->list.array[0]->pLMN_Identity.buf);
2020    DU_ALLOC(servedPlmn->list.array[0]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
2021    if(servedPlmn->list.array[0]->iE_Extensions == NULLP)
2022    {
2023       return RFAILED;
2024    }
2025
2026    ieListCnt=1;
2027    servedPlmn->list.array[0]->iE_Extensions->list.count = ieListCnt;
2028    servedPlmn->list.array[0]->iE_Extensions->list.size = ieListCnt *sizeof(ServedPLMNs_ItemExtIEs_t *);
2029    DU_ALLOC(servedPlmn->list.array[0]->iE_Extensions->list.array,servedPlmn->list.array[0]->\
2030          iE_Extensions->list.size);
2031    if(servedPlmn->list.array[0]->iE_Extensions->list.array == NULLP)
2032    {
2033       return RFAILED;
2034    }
2035    for(ieIdx=0;ieIdx<ieListCnt;ieIdx++)
2036    {
2037       DU_ALLOC(servedPlmn->list.array[0]->iE_Extensions->list.array[ieIdx],\
2038             sizeof(ServedPLMNs_ItemExtIEs_t));
2039       if(servedPlmn->list.array[0]->iE_Extensions->list.array[ieIdx] == NULLP)
2040       {
2041          return RFAILED;
2042       }
2043    }
2044    //plmnIeExt = servedPlmn->list.array[0]->iE_Extensions;
2045    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->id =ProtocolIE_ID_id_TAISliceSupportList;
2046    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->criticality = Criticality_ignore;
2047    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->extensionValue.present = \
2048       ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
2049    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2050       list.count = 1;
2051    servedPlmn->list.array[0]->\
2052       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2053       list.size = sizeof(SliceSupportItem_t *);
2054    DU_ALLOC(servedPlmn->list.array[0]->\
2055          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2056          list.array,servedPlmn->list.array[0]->\
2057          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.list.size);
2058    if(servedPlmn->list.array[0]->\
2059          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2060          list.array == NULLP)
2061    {
2062       return RFAILED;
2063    }
2064
2065    DU_ALLOC(servedPlmn->list.array[0]->\
2066          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2067          list.array[0],sizeof( SliceSupportItem_t));
2068    if(servedPlmn->list.array[0]->\
2069          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2070          list.array[0] == NULLP)
2071    {
2072       return RFAILED;
2073    }
2074    servedPlmn->list.array[0]->\
2075       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2076       list.array[0]->sNSSAI.sST.size = sizeof(uint8_t);
2077    DU_ALLOC(servedPlmn->list.array[0]->\
2078          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2079          list.array[0]->sNSSAI.sST.buf,servedPlmn->list.array[0]->\
2080          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.list.array[0]->sNSSAI.sST.size);
2081    if(servedPlmn->list.array[0]->\
2082          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2083          list.array[0]->sNSSAI.sST.buf == NULLP)
2084    {
2085       return RFAILED;
2086    }
2087    servedPlmn->list.array[0]->\
2088       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2089       list.array[0]->sNSSAI.sST.buf[0] = 3;
2090    DU_ALLOC(servedPlmn->list.array[0]->\
2091          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2092          list.array[0]->sNSSAI.sD,sizeof(OCTET_STRING_t));
2093    if(servedPlmn->list.array[0]->\
2094          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2095          list.array[0]->sNSSAI.sD == NULLP)
2096    {
2097       return RFAILED;
2098    }
2099    servedPlmn->list.array[0]->\
2100       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2101       list.array[0]->sNSSAI.sD->size = 3*sizeof(uint8_t);
2102    DU_ALLOC(servedPlmn->list.array[0]->\
2103          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2104          list.array[0]->sNSSAI.sD->buf,servedPlmn->list.array[0]->\
2105          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2106          list.array[0]->sNSSAI.sD->size);
2107    if(servedPlmn->list.array[0]->\
2108          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2109          list.array[0]->sNSSAI.sD->buf == NULLP)
2110    {
2111       return RFAILED;
2112    }
2113    servedPlmn->list.array[0]->\
2114       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2115       list.array[0]->sNSSAI.sD->buf[0] = 3;
2116    servedPlmn->list.array[0]->\
2117       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2118       list.array[0]->sNSSAI.sD->buf[1] = 6;
2119    servedPlmn->list.array[0]->\
2120       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2121       list.array[0]->sNSSAI.sD->buf[2] = 9;
2122    return ROK;
2123 }
2124
2125 /*******************************************************************
2126  *
2127  * @brief Fills Nr Fdd Info required in ServCellInfo IE
2128  *
2129  * @details
2130  *
2131  *    Function : fillNrFddInfo
2132  *
2133  *    Functionality: Fills Nr Fdd Info required in ServCellInfo IE
2134  *
2135  * @params[in] Pointer to NR_Mode_Info_t *
2136  *
2137  * @return ROK     - success
2138  *         RFAILED - failure
2139  *
2140  *****************************************************************/
2141
2142 uint8_t fillNrFddInfo(NR_Mode_Info_t *nrFdd)
2143 {
2144    nrFdd->choice.fDD->uL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.\
2145       f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn;
2146    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.count = 1;
2147    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t*);
2148    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
2149          array, nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size);
2150    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2151    {
2152       return RFAILED;
2153    }
2154    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0], \
2155       sizeof(FreqBandNrItem_t));
2156    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2157    {
2158       return RFAILED;
2159    }
2160    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2161       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
2162       freqBand[0].nrFreqBand;
2163    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2164    nrFdd->choice.fDD->dL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.\
2165       dlNrFreqInfo.nrArfcn;
2166    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.count = 1;
2167    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
2168    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,nrFdd->\
2169          choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
2170    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2171    {
2172       return RFAILED;
2173    }
2174    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0],\
2175          sizeof(FreqBandNrItem_t));
2176    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2177    {
2178       return RFAILED;
2179    }
2180    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2181       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
2182       freqBand[0].nrFreqBand;
2183    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2184
2185    /*Transmission Bandwidth*/
2186    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2187       f1Mode.mode.fdd.ulTxBw.nrScs;
2188    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2189       f1Mode.mode.fdd.ulTxBw.nrb;
2190    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2191       f1Mode.mode.fdd.dlTxBw.nrScs;
2192    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2193       f1Mode.mode.fdd.dlTxBw.nrb;
2194
2195    return ROK;
2196 }
2197
2198 /*******************************************************************
2199  *
2200  * @brief Fills ServCellInfo IE
2201  *
2202  * @details
2203  *
2204  *    Function : fillServedCellInfo
2205  *
2206  *    Functionality: Fills ServCellInfo
2207  *
2208  * @params[in] Pointer to Served_Cell_Information_t *
2209  *
2210  * @return ROK     - success
2211  *         RFAILED - failure
2212  *
2213  *****************************************************************/
2214
2215 uint8_t fillServedCellInfo(Served_Cell_Information_t *srvCellInfo)
2216 {
2217    uint8_t tmp, ieIdx, ieListCnt;
2218
2219    /*nRCGI*/
2220    srvCellInfo->nRCGI.pLMN_Identity.size =3*sizeof(uint8_t);
2221    DU_ALLOC(srvCellInfo->nRCGI.pLMN_Identity.buf,\
2222          srvCellInfo->nRCGI.pLMN_Identity.size);
2223    if(srvCellInfo->nRCGI.pLMN_Identity.buf == NULLP)
2224    {
2225       return RFAILED;
2226    }
2227    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2228          srvCellInfo->nRCGI.pLMN_Identity.buf);
2229    srvCellInfo->nRCGI.nRCellIdentity.size =5*sizeof(uint8_t);
2230    DU_ALLOC(srvCellInfo->nRCGI.nRCellIdentity.buf,\
2231          srvCellInfo->nRCGI.nRCellIdentity.size);
2232    if(srvCellInfo->nRCGI.nRCellIdentity.buf == NULLP)
2233    {
2234       return RFAILED;
2235    }
2236    for (tmp = 0 ; tmp < srvCellInfo->\
2237          nRCGI.nRCellIdentity.size-1 ; tmp++)
2238    {
2239       srvCellInfo->nRCGI.nRCellIdentity.buf[tmp] = 0;
2240    }
2241    srvCellInfo->nRCGI.nRCellIdentity.buf[4] = 16;
2242    srvCellInfo->nRCGI.nRCellIdentity.bits_unused =4;
2243
2244    /*nRPCI*/
2245    srvCellInfo->nRPCI = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
2246
2247    /*servedPLMNs*/
2248    ieListCnt = 1;
2249    srvCellInfo->servedPLMNs.list.count = ieListCnt;
2250    srvCellInfo->servedPLMNs.list.size = ieListCnt*sizeof(ServedPLMNs_Item_t *);
2251    DU_ALLOC(srvCellInfo->servedPLMNs.list.array,\
2252          srvCellInfo->servedPLMNs.list.size);
2253    if(srvCellInfo->servedPLMNs.list.array == NULLP)
2254    {
2255       return RFAILED;
2256    }
2257    for(ieIdx=0; ieIdx < ieListCnt; ieIdx++)
2258    {
2259       DU_ALLOC(srvCellInfo->servedPLMNs.list.array[ieIdx],\
2260             sizeof(ServedPLMNs_Item_t));
2261       if(srvCellInfo->servedPLMNs.list.array[ieIdx]== NULLP)
2262       {
2263          return RFAILED;
2264       }
2265    }
2266    if(fillServedPlmns(&srvCellInfo->servedPLMNs))
2267    {
2268       return RFAILED;
2269    }
2270
2271    /*nR Mode Info with FDD*/
2272    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_fDD;
2273    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.fDD,\
2274          sizeof(FDD_Info_t));
2275    if(srvCellInfo->nR_Mode_Info.choice.fDD == NULLP)
2276    {
2277       return RFAILED;
2278    }
2279    if(fillNrFddInfo(&srvCellInfo->nR_Mode_Info))
2280       return RFAILED;
2281
2282    /*Measurement timing Config*/
2283    srvCellInfo->measurementTimingConfiguration.size = sizeof(uint8_t);
2284    DU_ALLOC(srvCellInfo->measurementTimingConfiguration.\
2285          buf,srvCellInfo->measurementTimingConfiguration.size);
2286    if(srvCellInfo->measurementTimingConfiguration.buf == NULLP)
2287    {
2288       return RFAILED;
2289    }
2290    srvCellInfo->measurementTimingConfiguration.\
2291          buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
2292
2293    return ROK;
2294 }
2295
2296 /*******************************************************************
2297  *
2298  * @brief Fills ServCellToModItem IE
2299  *
2300  * @details
2301  *
2302  *    Function : fillServCellToModItem
2303  *
2304  *    Functionality: Fills ServCellToModItem IE
2305  *
2306  * @params[in] Pointer to Served_Cells_To_Modify_Item_t *
2307  *
2308  * @return ROK     - success
2309  *         RFAILED - failure
2310  *
2311  *****************************************************************/
2312
2313 uint8_t fillServCellToModItem(Served_Cells_To_Modify_Item_t *modifyItem)
2314 {
2315    uint8_t ieIdx;
2316
2317    /*pLMN_Identity*/
2318    modifyItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2319    DU_ALLOC(modifyItem->oldNRCGI.pLMN_Identity.buf,modifyItem->oldNRCGI.pLMN_Identity.size);
2320    if(modifyItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2321    {
2322       return RFAILED;
2323    }
2324    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2325          modifyItem->oldNRCGI.pLMN_Identity.buf);
2326
2327    /*nRCellIdentity*/
2328    modifyItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2329    DU_ALLOC(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2330          modifyItem->oldNRCGI.nRCellIdentity.size);
2331    if(modifyItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2332    {
2333       return RFAILED;
2334    }
2335    for(ieIdx = 0; ieIdx < modifyItem->oldNRCGI.nRCellIdentity.size-1; ieIdx++)
2336    {
2337       modifyItem->oldNRCGI.nRCellIdentity.buf[ieIdx] = 0;
2338    }
2339    modifyItem->oldNRCGI.nRCellIdentity.buf[4] = 16;
2340    modifyItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
2341
2342    if(fillServedCellInfo(&modifyItem->served_Cell_Information))
2343       return RFAILED;
2344    else
2345       return ROK;
2346 }
2347
2348 /*******************************************************************
2349  *
2350  * @brief Builds ServCellToModList
2351  *
2352  * @details
2353  *
2354  *    Function : buildServCellToModList
2355  *
2356  *    Functionality: Builds the serv cell to Mod List
2357  *
2358  * @params[in] Pointer to Served_Cells_To_Modify_List_t *
2359  *
2360  * @return ROK     - success
2361  *         RFAILED - failure
2362  *
2363  *****************************************************************/
2364
2365 uint8_t buildServCellToModList(Served_Cells_To_Modify_List_t *cellsToModify)
2366 {
2367    uint8_t ieListCnt, ieIdx;
2368    Served_Cells_To_Modify_Item_t *modifyItem = NULLP;
2369
2370    ieListCnt = 1;
2371    cellsToModify->list.count = ieListCnt;
2372    cellsToModify->list.size = ieListCnt*sizeof(Served_Cells_To_Modify_ItemIEs_t *);
2373    DU_ALLOC(cellsToModify->list.array,cellsToModify->list.size);
2374    if(cellsToModify->list.array == NULLP)
2375    {
2376       return RFAILED;
2377    }
2378    for(ieIdx=0; ieIdx< ieListCnt; ieIdx++)
2379    {
2380       DU_ALLOC(cellsToModify->list.array[ieIdx],sizeof(Served_Cells_To_Modify_ItemIEs_t));
2381       if(cellsToModify->list.array[ieIdx] == NULLP)
2382       {
2383          return RFAILED;
2384       }
2385    }
2386    cellsToModify->list.array[0]->id = ProtocolIE_ID_id_Served_Cells_To_Modify_Item;
2387    cellsToModify->list.array[0]->criticality = Criticality_reject;
2388    cellsToModify->list.array[0]->value.present =\
2389       Served_Cells_To_Modify_ItemIEs__value_PR_Served_Cells_To_Modify_Item;
2390    modifyItem=&cellsToModify->list.array[0]->value.choice.Served_Cells_To_Modify_Item;
2391
2392    if(fillServCellToModItem(modifyItem))
2393       return RFAILED;
2394    else
2395       return ROK;
2396 }
2397 /*******************************************************************
2398  *
2399  * @brief filling the DeleteItemList
2400  *
2401  * @details
2402  *
2403  *    Function : fillCellToDeleteItem
2404  *
2405  *    Functionality: Filling the DeleteItemIe
2406  *
2407  * @params[in] Pointer to Served_Cells_To_Delete_ItemIEs_t
2408  *
2409  * @return ROK     - success
2410  *         RFAILED - failure
2411  *
2412  *****************************************************************/
2413 uint8_t fillCellToDeleteItem(struct Served_Cells_To_Delete_ItemIEs *deleteItemIe)
2414 {
2415    uint8_t arrIdx;
2416    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
2417
2418    deleteItemIe->id = ProtocolIE_ID_id_Served_Cells_To_Delete_Item;
2419    deleteItemIe->criticality = Criticality_reject;
2420    deleteItemIe->value.present =\
2421    Served_Cells_To_Delete_ItemIEs__value_PR_Served_Cells_To_Delete_Item;
2422    deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
2423
2424    /*pLMN_Identity*/
2425    deleteItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2426    DU_ALLOC(deleteItem->oldNRCGI.pLMN_Identity.buf,deleteItem->oldNRCGI.pLMN_Identity.size);
2427    if(deleteItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2428    {
2429       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2430       return RFAILED;
2431    }
2432    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2433          deleteItem->oldNRCGI.pLMN_Identity.buf);
2434
2435    /*nRCellIdentity*/
2436    deleteItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2437    DU_ALLOC(deleteItem->oldNRCGI.nRCellIdentity.buf,\
2438          deleteItem->oldNRCGI.nRCellIdentity.size);
2439    if(deleteItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2440    {
2441       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2442       return RFAILED;
2443    }
2444    for(arrIdx = 0; arrIdx < deleteItem->oldNRCGI.nRCellIdentity.size-1; arrIdx++)
2445    {
2446       deleteItem->oldNRCGI.nRCellIdentity.buf[arrIdx] = 0;
2447    }
2448    deleteItem->oldNRCGI.nRCellIdentity.buf[4] = 16;
2449    deleteItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
2450    return ROK;
2451 }
2452 /*******************************************************************
2453  *
2454  * @brief Builds ServCellToDeleteList
2455  *
2456  * @details
2457  *
2458  *    Function : buildServCellToDeleteList
2459  *
2460  *    Functionality: Builds the serv cell to delete List
2461  *
2462  * @params[in] Pointer to Served_Cells_To_Delete_List_t *
2463  *
2464  * @return ROK     - success
2465  *         RFAILED - failure
2466  *
2467  *****************************************************************/
2468
2469 uint8_t buildServCellToDeleteList(Served_Cells_To_Delete_List_t *cellsToDelete)
2470 {
2471    uint8_t ieListCnt, arrIdx;
2472
2473    ieListCnt = 1;
2474    cellsToDelete->list.count = ieListCnt;
2475    cellsToDelete->list.size = ieListCnt*sizeof(Served_Cells_To_Delete_ItemIEs_t *);
2476
2477    DU_ALLOC(cellsToDelete->list.array,cellsToDelete->list.size);
2478    if(cellsToDelete->list.array == NULLP)
2479    {
2480       DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2481       return RFAILED;
2482    }
2483
2484    for(arrIdx=0; arrIdx< ieListCnt; arrIdx++)
2485    {
2486       DU_ALLOC(cellsToDelete->list.array[arrIdx],sizeof(Served_Cells_To_Delete_ItemIEs_t));
2487       if(cellsToDelete->list.array[arrIdx] == NULLP)
2488       {
2489          DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2490          return RFAILED;
2491       }
2492    }
2493
2494    arrIdx=0;
2495    if(fillCellToDeleteItem((Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx]) !=ROK)
2496    {
2497       DU_LOG("\nERROR  -->  F1AP: buildServCellToDeleteList(): failed to fill Served_Cells_To_Delete_ItemIEs");
2498       return RFAILED;
2499    }
2500    return ROK;
2501 }
2502
2503 /*******************************************************************
2504  *
2505  * @brief Builds and sends the DUConfigUpdate
2506  *
2507  * @details
2508  *
2509  *    Function : BuildAndSendDUConfigUpdate
2510  *
2511  *    Functionality: Constructs the DU Update message and sends
2512  *                   it to the CU through SCTP.
2513  *
2514  * @params[in] void **buf,Buffer to which encoded pattern is written into
2515  * @params[in] int *size,size of buffer
2516  *
2517  * @return ROK     - success
2518  *         RFAILED - failure
2519  *
2520  * ****************************************************************/
2521 uint8_t BuildAndSendDUConfigUpdate(ServCellAction servCellAction)
2522 {
2523    uint8_t ret =0, ieIdx=0, elementCnt=0;
2524    bool memAlloctionFailure = false;
2525    F1AP_PDU_t                 *f1apDuCfg = NULLP;
2526    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
2527    asn_enc_rval_t encRetVal;     /* Encoder return value */
2528
2529    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2530    ret= RFAILED;
2531
2532    while(true)
2533    {
2534       DU_LOG("\nINFO   -->  F1AP : Building DU config update\n");
2535       /* Allocate the memory for F1DuCfg */
2536       DU_ALLOC(f1apDuCfg, sizeof(F1AP_PDU_t));
2537       if(f1apDuCfg == NULLP)
2538       {
2539          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2540          break;
2541       }
2542
2543       f1apDuCfg->present = F1AP_PDU_PR_initiatingMessage;
2544       DU_ALLOC(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2545       if(f1apDuCfg->choice.initiatingMessage == NULLP)
2546       {
2547          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2548          break;
2549       }
2550
2551       f1apDuCfg->choice.initiatingMessage->procedureCode = \
2552                                                            ProcedureCode_id_gNBDUConfigurationUpdate;
2553       f1apDuCfg->choice.initiatingMessage->criticality = Criticality_reject;
2554       f1apDuCfg->choice.initiatingMessage->value.present = \
2555                                                            InitiatingMessage__value_PR_GNBDUConfigurationUpdate;
2556       duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\
2557                     choice.GNBDUConfigurationUpdate;
2558       elementCnt = 3;
2559       duCfgUpdate->protocolIEs.list.count = elementCnt;
2560       duCfgUpdate->protocolIEs.list.size = \
2561                                            elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t*);
2562
2563       /* Initialize the F1Setup members */
2564       DU_ALLOC(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2565       if(duCfgUpdate->protocolIEs.list.array == NULLP)
2566       {
2567          DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2568          break;
2569       }
2570       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
2571       {
2572          DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx],sizeof(GNBDUConfigurationUpdateIEs_t));
2573          if(duCfgUpdate->protocolIEs.list.array[ieIdx] == NULLP)
2574          {
2575             DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2576             memAlloctionFailure = true;
2577             break;
2578          }
2579       }
2580
2581       if(memAlloctionFailure == true)
2582       {
2583          break;
2584       }
2585       /*TransactionID*/
2586       ieIdx = 0;
2587       duCfgUpdate->protocolIEs.list.array[ieIdx]->id=ProtocolIE_ID_id_TransactionID;
2588       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
2589       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2590       GNBDUConfigurationUpdateIEs__value_PR_TransactionID;
2591       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = TRANS_ID;
2592
2593       ieIdx++;
2594       if(servCellAction == SERV_CELL_TO_MODIFY)
2595       {
2596          /*Served Cell to Modify */
2597          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2598          ProtocolIE_ID_id_Served_Cells_To_Modify_List;
2599          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2600          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2601          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Modify_List;
2602          if(buildServCellToModList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2603                   Served_Cells_To_Modify_List))
2604          {
2605             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToModList");
2606             break;
2607          }
2608       }
2609       else
2610       {
2611          /*Served Cell to Delete */
2612          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2613          ProtocolIE_ID_id_Served_Cells_To_Delete_List;
2614          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2615          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2616          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Delete_List;
2617          if(buildServCellToDeleteList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2618          Served_Cells_To_Delete_List)!=ROK)
2619          {
2620             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToDeleteList");
2621             break;
2622          }
2623
2624       }
2625       // NOTE :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
2626       /*GNB DU ID */
2627       ieIdx++;
2628       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
2629       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
2630       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2631       GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID;
2632       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size = sizeof(uint8_t);
2633       DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2634             duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2635       if(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == NULLP)
2636       {
2637          DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): Memory allocation failed for GNB_DU_ID");
2638          break;
2639       }
2640       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] = duCfgParam.duId;
2641
2642       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
2643
2644       /* Encode the DU Config Update type as APER */
2645       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
2646       encBufSize = 0;
2647       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
2648
2649       /* Checking encode results */
2650       if(encRetVal.encoded == ENCODE_FAIL)
2651       {
2652          DU_LOG("ERROR  -->  F1AP : Could not encode DUConfigUpdate structure (at %s)\n",\
2653                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2654          break;
2655       }
2656       else
2657       {
2658          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DUConfigUpdate\n");
2659          for(ieIdx =0; ieIdx < encBufSize; ieIdx++)
2660          {
2661             printf("%x",encBuf[ieIdx]);
2662          }
2663       }
2664       /* Sending msg */
2665       if(sendF1APMsg() != ROK)
2666       {
2667          DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update failed");
2668          break;
2669       }
2670
2671       ret = ROK;
2672       break;
2673    }
2674
2675    addToReservedF1apPduList(TRANS_ID,f1apDuCfg);
2676    return ret;
2677 }
2678
2679
2680 /*******************************************************************
2681  *
2682  * @brief free the ULRRCMessageTransfer
2683  *
2684  * @details
2685  *
2686  *    Function : FreeULRRCMessageTransfer
2687  *
2688  *    Functionality: Deallocating the memory of variable allocated in
2689  *                      FreeULRRCMessageTransfer
2690  *
2691  * @params[in]
2692  *
2693  * @return ROK     - void
2694  *
2695  ******************************************************************/
2696 void FreeULRRCMessageTransfer( F1AP_PDU_t *f1apMsg)
2697 {
2698    uint8_t idx1;
2699    ULRRCMessageTransfer_t  *ulRRCMsg;
2700
2701    if(f1apMsg != NULLP)
2702    {
2703       if(f1apMsg->choice.initiatingMessage != NULLP)
2704       {
2705          ulRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2706          if(ulRRCMsg->protocolIEs.list.array != NULLP)
2707          {
2708             for(idx1=0;idx1<ulRRCMsg->protocolIEs.list.count;idx1++)
2709             {
2710                if(ulRRCMsg->protocolIEs.list.array[idx1] != NULLP)
2711                {
2712                   if(ulRRCMsg->protocolIEs.list.array[idx1]->value.present ==
2713                         ULRRCMessageTransferIEs__value_PR_RRCContainer)
2714                   {
2715                      DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2716                            ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2717                   }
2718                   DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1],sizeof(ULRRCMessageTransferIEs_t));
2719                }
2720             }
2721             DU_FREE(ulRRCMsg->protocolIEs.list.array,ulRRCMsg->protocolIEs.list.size );
2722          }
2723          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2724       }
2725       DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
2726    }
2727 }
2728 /*******************************************************************
2729  *
2730  * @brief Builds and sends the ULRRCMessageTransfer
2731  *
2732  * @details
2733  *
2734  *    Function : BuildAndSendULRRCMessageTransfer
2735  *
2736  *    Functionality: Constructs the UL RRC Message Transfer and sends
2737  *                   it to the CU through SCTP.
2738  *
2739  * @params[in]
2740  *
2741  * @return ROK     - success
2742  *         RFAILED - failure
2743  *
2744  * ****************************************************************/
2745 uint8_t BuildAndSendULRRCMessageTransfer(DuUeCb  ueCb, uint8_t lcId, \
2746       uint16_t msgLen, uint8_t *rrcMsg)
2747 {
2748    uint8_t   elementCnt =0;
2749    uint8_t   idx1 =0;
2750    uint8_t   idx =0;
2751    F1AP_PDU_t                   *f1apMsg = NULLP;
2752    ULRRCMessageTransfer_t       *ulRRCMsg = NULLP;
2753    asn_enc_rval_t               encRetVal;        /* Encoder return value */
2754    uint8_t ret =RFAILED;
2755
2756    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2757
2758    while(true)
2759    {
2760       DU_LOG("\n INFO   -->  F1AP : Building UL RRC Message Transfer Message\n");
2761
2762       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
2763       if(f1apMsg == NULLP)
2764       {
2765          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2766          break;
2767       }
2768       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
2769       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2770       if(f1apMsg->choice.initiatingMessage == NULLP)
2771       {
2772          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
2773          break;
2774       }
2775       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_ULRRCMessageTransfer;
2776       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
2777       f1apMsg->choice.initiatingMessage->value.present = \
2778                                                          InitiatingMessage__value_PR_ULRRCMessageTransfer;
2779       ulRRCMsg =
2780          &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2781       elementCnt = 4;
2782       ulRRCMsg->protocolIEs.list.count = elementCnt;
2783       ulRRCMsg->protocolIEs.list.size = \
2784                                         elementCnt * sizeof(ULRRCMessageTransferIEs_t *);
2785
2786       /* Initialize the F1Setup members */
2787       DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size);
2788       if(ulRRCMsg->protocolIEs.list.array == NULLP)
2789       {
2790          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
2791          break;
2792       }
2793       for(idx=0; idx<elementCnt; idx++)
2794       {
2795          DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t));
2796          if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP)
2797          {
2798             break;
2799          }
2800       }
2801
2802       idx1 = 0;
2803
2804       /*GNB CU UE F1AP ID*/
2805       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
2806       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2807       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2808                                                               ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
2809       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = ueCb.gnbCuUeF1apId;
2810
2811       /*GNB DU UE F1AP ID*/
2812       idx1++;
2813       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
2814       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2815       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2816                                                               ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
2817       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = ueCb.gnbDuUeF1apId;
2818
2819       /*SRBID*/
2820       idx1++;
2821       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
2822       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2823       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2824                                                               ULRRCMessageTransferIEs__value_PR_SRBID;
2825       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = lcId;
2826
2827       /*RRCContainer*/
2828       idx1++;
2829       ulRRCMsg->protocolIEs.list.array[idx1]->id  = ProtocolIE_ID_id_RRCContainer;
2830       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2831       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2832                                                               ULRRCMessageTransferIEs__value_PR_RRCContainer;
2833       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size = msgLen;
2834       DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2835             ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
2836       if(!ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
2837       {
2838          DU_LOG(" ERROR  -->  F1AP : Memory allocation for BuildAndSendULRRCMessageTransfer failed");
2839          break;
2840       }
2841       memset(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, 0, msgLen);
2842       memcpy(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, \
2843             rrcMsg, ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2844
2845       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2846
2847       /* Encode the F1SetupRequest type as APER */
2848       memset(encBuf, 0, ENC_BUF_MAX_LEN);
2849       encBufSize = 0;
2850       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
2851             encBuf);
2852       /* Encode results */
2853       if(encRetVal.encoded == ENCODE_FAIL)
2854       {
2855          DU_LOG( "\nERROR  -->  F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
2856                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2857          break;
2858       }
2859       else
2860       {
2861          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
2862          for(int i=0; i< encBufSize; i++)
2863          {
2864             printf("%x",encBuf[i]);
2865          }
2866       }
2867
2868       /* Sending  msg  */
2869       if(sendF1APMsg()  !=      ROK)
2870       {
2871          DU_LOG("\nERROR  -->   F1AP : Sending  UL RRC Message Transfer Failed");
2872          break;
2873       }
2874       ret = ROK;
2875       break;
2876    }
2877    FreeULRRCMessageTransfer(f1apMsg);
2878
2879    return ret;
2880 }/* End of BuildAndSendULRRCMessageTransfer*/
2881
2882 /*******************************************************************
2883  *
2884  * @brief Builds tag config
2885  *
2886  * @details
2887  *
2888  *    Function : BuildTagConfig
2889  *
2890  *    Functionality: Builds tag config in MacCellGroupConfig
2891  *
2892  * @params[in] TAG_Config *tag_Config
2893  *
2894  * @return ROK     - success
2895  *         RFAILED - failure
2896  *
2897  * ****************************************************************/
2898 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
2899 {
2900    struct TAG_Config__tag_ToAddModList *tagList;
2901    uint8_t                     idx, elementCnt;
2902
2903    tagConfig->tag_ToReleaseList = NULLP;
2904    tagConfig->tag_ToAddModList = NULLP;
2905    DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
2906    if(!tagConfig->tag_ToAddModList)
2907    {
2908       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2909       return RFAILED;
2910    }
2911
2912    elementCnt = 1; //ODU_VALUE_ONE;
2913    tagList = tagConfig->tag_ToAddModList;
2914    tagList->list.count = elementCnt;
2915    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
2916
2917    tagList->list.array = NULLP;
2918    DU_ALLOC(tagList->list.array, tagList->list.size);
2919    if(!tagList->list.array)
2920    {
2921       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2922       return RFAILED;
2923    }
2924
2925    for(idx=0; idx<tagList->list.count; idx++)
2926    {
2927       tagList->list.array[idx] = NULLP;
2928       DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
2929       if(!tagList->list.array[idx])
2930       {
2931          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2932          return RFAILED;
2933       }
2934    }
2935
2936    idx = 0;
2937    tagList->list.array[idx]->tag_Id = TAG_ID;
2938    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
2939
2940    return ROK;
2941 }
2942
2943 /*******************************************************************
2944  *
2945  * @brief Builds PHR Config
2946  *
2947  * @details
2948  *
2949  *    Function : BuildPhrConfig
2950  *
2951  *    Functionality: Builds phrConfig in MacCellGroupConfig
2952  *
2953  * @params[in] PHR Config *
2954  *
2955  * @return ROK     - success
2956  *         RFAILED - failure
2957  *
2958  * ****************************************************************/
2959 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
2960 {
2961
2962    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
2963    phrConfig->choice.setup = NULLP;
2964    DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
2965    if(!phrConfig->choice.setup)
2966    {
2967       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
2968       return RFAILED;
2969    }
2970
2971    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
2972    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
2973    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
2974    phrConfig->choice.setup->multiplePHR              = false;
2975    phrConfig->choice.setup->dummy                    = false;
2976    phrConfig->choice.setup->phr_Type2OtherCell       = false;
2977    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
2978
2979    return ROK;
2980 }
2981
2982 /*******************************************************************
2983  *
2984  * @brief Builds BSR Config
2985  *
2986  * @details
2987  *
2988  *    Function : BuildBsrConfig
2989  *
2990  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
2991  *
2992  * @params[in] BSR_Config *bsrConfig
2993  *
2994  * @return ROK     - success
2995  *         RFAILED - failure
2996  *
2997  * ****************************************************************/
2998 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
2999 {
3000    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
3001    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
3002    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
3003
3004    return ROK;
3005 }
3006
3007 /*******************************************************************
3008  *
3009  * @brief Builds scheduling request config
3010  *
3011  * @details
3012  *
3013  *    Function : BuildSchedulingReqConfig
3014  *
3015  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
3016  *
3017  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
3018  *
3019  * @return ROK     - success
3020  *         RFAILED - failure
3021  *
3022  * ****************************************************************/
3023 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
3024 {
3025    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
3026    uint8_t                     idx, elementCnt;
3027
3028    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
3029    DU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
3030          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
3031    if(!schedulingRequestConfig->schedulingRequestToAddModList)
3032    {
3033       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3034       return RFAILED;
3035    }
3036
3037    elementCnt = 1; //ODU_VALUE_ONE;
3038    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
3039    schReqList->list.count = elementCnt;
3040    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
3041
3042    schReqList->list.array = NULLP;
3043    DU_ALLOC(schReqList->list.array, schReqList->list.size);
3044    if(!schReqList->list.array)
3045    {
3046       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3047       return RFAILED;
3048    }
3049
3050    for(idx=0;idx<schReqList->list.count; idx++)
3051    {
3052       schReqList->list.array[idx] = NULLP;
3053       DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
3054       if(!schReqList->list.array[idx])
3055       {
3056          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3057          return RFAILED;
3058       }
3059    }
3060
3061    idx = 0;
3062    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
3063
3064    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
3065    DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
3066    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
3067    {
3068       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3069       return RFAILED;
3070    }
3071    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
3072    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
3073    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
3074
3075    return ROK;
3076 }
3077
3078 /*******************************************************************
3079  *
3080  * @brief Builds RLC Config
3081  *
3082  * @details
3083  *
3084  *    Function : BuildRlcConfig
3085  *
3086  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
3087  *
3088  * @params[in] RLC_Config *rlcConfig
3089  *
3090  * @return ROK     - success
3091  *         RFAILED - failure
3092  *
3093  * ****************************************************************/
3094 uint8_t BuildRlcConfig(struct RLC_Config *rlcConfig)
3095 {
3096
3097    rlcConfig->present = RLC_Config_PR_am;
3098
3099    rlcConfig->choice.am = NULLP;
3100    DU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
3101    if(!rlcConfig->choice.am)
3102    {
3103       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3104       return RFAILED;
3105    }
3106
3107    /* UL */
3108    rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
3109    DU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3110    if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
3111    {
3112       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3113       return RFAILED;
3114    }
3115    *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3116    rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
3117    rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
3118    rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
3119    rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
3120
3121    /* DL */
3122    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
3123    DU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3124    if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
3125    {
3126       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3127       return RFAILED;
3128    }
3129    *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3130    rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
3131    rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
3132
3133    return ROK;
3134 }
3135
3136 /*******************************************************************
3137  *
3138  * @brief Builds MAC LC Config
3139  *
3140  * @details
3141  *
3142  *    Function : BuildMacLCConfig
3143  *
3144  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
3145  *
3146  * @params[in] struct LogicalChannelConfig macLcConfig
3147  *
3148  * @return ROK     - success
3149  *         RFAILED - failure
3150  *
3151  * ****************************************************************/
3152 uint8_t BuildMacLCConfig(struct LogicalChannelConfig *macLcConfig)
3153 {
3154
3155    macLcConfig->ul_SpecificParameters = NULLP;
3156    DU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
3157    if(!macLcConfig->ul_SpecificParameters)
3158    {
3159       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3160       return RFAILED;
3161    }
3162
3163    macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
3164    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     PRIORTISIED_BIT_RATE;
3165    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     BUCKET_SIZE_DURATION;
3166    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
3167    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
3168    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
3169    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
3170
3171    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
3172    DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
3173    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
3174    {
3175       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3176       return RFAILED;
3177    }
3178    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
3179
3180    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
3181    DU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
3182    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
3183    {
3184       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3185       return RFAILED;
3186    }
3187    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
3188
3189    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
3190    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
3191    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
3192
3193    return ROK;
3194 }
3195
3196 /*******************************************************************
3197  *
3198  * @brief Builds RLC Bearer to Add/Mod list
3199  *
3200  * @details
3201  *
3202  *    Function :BuildRlcBearerToAddModList
3203  *
3204  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
3205  *
3206  * @params[in] rlc_BearerToAddModList
3207  *
3208  * @return ROK     - success
3209  *         RFAILED - failure
3210  *
3211  * ****************************************************************/
3212 uint8_t BuildRlcBearerToAddModList(struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
3213 {
3214    uint8_t                     idx, elementCnt;
3215
3216    elementCnt = 1;
3217    rlcBearerList->list.count = elementCnt;
3218    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
3219
3220    rlcBearerList->list.array = NULLP;
3221    DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
3222    if(!rlcBearerList->list.array)
3223    {
3224       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3225       return RFAILED;
3226    }
3227
3228    for(idx=0; idx<rlcBearerList->list.count; idx++)
3229    {
3230       rlcBearerList->list.array[idx] = NULLP;
3231       DU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
3232       if(!rlcBearerList->list.array[idx])
3233       {
3234          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3235          return RFAILED;
3236       }
3237    }
3238
3239    idx = 0;
3240    rlcBearerList->list.array[idx]->logicalChannelIdentity = SRB1_LCID;
3241
3242    DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, \
3243       sizeof(struct RLC_BearerConfig__servedRadioBearer));
3244    if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3245    {
3246       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3247       return RFAILED;
3248    }
3249
3250    rlcBearerList->list.array[idx]->servedRadioBearer->present = \
3251       RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
3252    rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = \
3253       SRB1_LCID;
3254
3255    rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3256    rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3257    DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3258    if(!rlcBearerList->list.array[idx]->rlc_Config)
3259    {
3260       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3261       return RFAILED;
3262    }
3263
3264    if(BuildRlcConfig(rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3265    {
3266       DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3267       return RFAILED;
3268    }
3269
3270    rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3271    DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, \
3272       sizeof(struct LogicalChannelConfig));
3273    if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3274    {
3275       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3276       return RFAILED;
3277    }
3278
3279    if(BuildMacLCConfig(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3280    {
3281       DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3282       return RFAILED;
3283    }
3284
3285    return ROK;
3286 }
3287
3288 /*******************************************************************
3289  *
3290  * @brief Build Control resource set to add/modify list
3291  *
3292  * @details
3293  *
3294  *    Function : BuildControlRSetToAddModList
3295  *
3296  *    Functionality: Build Control resource set to add/modify list
3297  *
3298  * @params[in]
3299  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3300  *
3301  * @return ROK     - success
3302  *         RFAILED - failure
3303  *
3304  * ****************************************************************/
3305    uint8_t BuildControlRSetToAddModList
3306 (
3307  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3308  )
3309 {
3310    uint8_t idx;
3311    uint8_t elementCnt;
3312    uint8_t numBytes, bitsUnused;
3313    struct ControlResourceSet *controlRSet;
3314    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3315    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3316
3317
3318    elementCnt = 1;
3319    controlRSetList->list.count = elementCnt;
3320    controlRSetList->list.size = \
3321                                 elementCnt * sizeof(struct ControlResourceSet *);
3322
3323    controlRSetList->list.array = NULLP;
3324    DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3325    if(!controlRSetList->list.array)
3326    {
3327       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3328       return RFAILED;
3329    }
3330
3331    for(idx = 0; idx < elementCnt; idx++)
3332    {
3333       controlRSetList->list.array[idx] = NULLP;
3334       DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3335       if(!controlRSetList->list.array[idx])
3336       {
3337          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3338          return RFAILED;
3339       }
3340    }
3341
3342    idx=0;
3343    controlRSet = controlRSetList->list.array[idx];
3344
3345    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3346
3347    /* size 6 bytes
3348     * 3 LSBs unsued
3349     * Bit string stored ff0000000000
3350     */
3351    numBytes = 6;
3352    bitsUnused = 3;
3353    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3354
3355    controlRSet->frequencyDomainResources.buf = NULLP;
3356    DU_ALLOC(controlRSet->frequencyDomainResources.buf, \
3357          controlRSet->frequencyDomainResources.size);
3358    if(!controlRSet->frequencyDomainResources.buf)
3359    {
3360       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3361       return RFAILED;
3362    }
3363
3364    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3365    coreset0EndPrb = CORESET0_END_PRB;
3366    coreset1StartPrb = coreset0EndPrb + 6;
3367    coreset1NumPrb = CORESET1_NUM_PRB;
3368    /* calculate the PRBs */
3369    freqDomRscAllocType0(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3370    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3371    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3372
3373    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3374    controlRSet->cce_REG_MappingType.present = \
3375                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3376
3377    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3378    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3379    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3380    controlRSet->tci_PresentInDCI = NULLP;
3381 #if 0
3382    uint8_t tciStateIdx;
3383
3384    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3385          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3386    if(!controlRset->tci_StatesPDCCH_ToAddList)
3387    {
3388       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3389       return RFAILED;
3390    }
3391
3392    elementCnt = 1;
3393    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3394    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3395    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3396          controlRset->tci_StatesPDCCH_ToAddList->list.size)
3397       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3398       {
3399          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3400          return RFAILED;
3401       }
3402
3403    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3404    {
3405       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3406       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3407       {
3408          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3409          return RFAILED;
3410       }
3411    }
3412
3413    tciStateIdx = 0;
3414    /* TODO */
3415    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3416
3417    DU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3418    if(!controlRset->tci_PresentInDCI)
3419    {
3420       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3421       return RFAILED;
3422    }
3423    /* TODO */
3424    *(controlRset->tci_PresentInDCI);
3425 #endif
3426
3427    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3428    DU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3429    if(!controlRSet->pdcch_DMRS_ScramblingID)
3430    {
3431       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3432       return RFAILED;
3433    }
3434    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3435
3436    return ROK;
3437 } /* End BuildControlRSetToAddModList */
3438
3439 /*******************************************************************
3440  *
3441  * @brief Build search space to add/modify list
3442  *
3443  * @details
3444  *
3445  *    Function : BuildSearchSpcToAddModList
3446  *
3447  *    Functionality: Build search space to add/modify list
3448  *
3449  * @params[in]
3450  * @return ROK     - success
3451  *         RFAILED - failure
3452  *
3453  * ****************************************************************/
3454    uint8_t BuildSearchSpcToAddModList
3455 (
3456  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
3457  )
3458 {
3459    uint8_t idx;
3460    uint8_t numBytes;
3461    uint8_t byteIdx;
3462    uint8_t bitsUnused;
3463    uint8_t elementCnt;
3464    struct SearchSpace *searchSpc;
3465
3466    elementCnt = 1;
3467    searchSpcList->list.count = elementCnt;
3468    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3469
3470    searchSpcList->list.array = NULLP;
3471    DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3472    if(!searchSpcList->list.array)
3473    {
3474       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3475       return RFAILED;
3476    }
3477
3478    for(idx = 0; idx < elementCnt; idx++)
3479    {
3480       searchSpcList->list.array[idx] = NULLP;
3481       DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3482       if(!searchSpcList->list.array[idx])
3483       {
3484          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3485          return RFAILED;
3486       }
3487    }
3488
3489    idx = 0;
3490    searchSpc = searchSpcList->list.array[idx];
3491
3492    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3493
3494    searchSpc->controlResourceSetId = NULLP;
3495    DU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3496    if(!searchSpc->controlResourceSetId)
3497    {
3498       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3499       return RFAILED;
3500    }
3501    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3502
3503    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3504    DU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
3505          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3506    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3507    {
3508       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3509       return RFAILED;
3510    }
3511    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
3512                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3513
3514    searchSpc->duration = NULLP;
3515    searchSpc->monitoringSymbolsWithinSlot = NULLP;
3516    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3517    if(!searchSpc->monitoringSymbolsWithinSlot)
3518    {
3519       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3520       return RFAILED;
3521    }
3522
3523    /* Values taken from reference logs :
3524     * size 2 bytes
3525     * 2 LSBs unsued
3526     * Bit string stores 8000
3527     */
3528    numBytes = 2;
3529    bitsUnused = 2;
3530
3531    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3532    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3533    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
3534          searchSpc->monitoringSymbolsWithinSlot->size);
3535    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3536    {
3537       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3538       return RFAILED;
3539    }
3540
3541    byteIdx = 0;
3542    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
3543                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3544    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3545    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3546
3547    searchSpc->nrofCandidates = NULLP;
3548    DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3549    if(!searchSpc->nrofCandidates)
3550    {
3551       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3552       return RFAILED;
3553    }
3554
3555    searchSpc->nrofCandidates->aggregationLevel1 = \
3556                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3557    searchSpc->nrofCandidates->aggregationLevel2 = \
3558                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3559    searchSpc->nrofCandidates->aggregationLevel4 = \
3560                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3561    searchSpc->nrofCandidates->aggregationLevel8 = \
3562                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3563    searchSpc->nrofCandidates->aggregationLevel16 = \
3564                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3565
3566    searchSpc->searchSpaceType = NULLP;
3567    DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3568    if(!searchSpc->searchSpaceType)
3569    {
3570       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3571       return RFAILED;
3572    }
3573
3574    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3575
3576    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3577    DU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
3578          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3579    if(!searchSpc->searchSpaceType->choice.ue_Specific)
3580    {
3581       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3582       return RFAILED;
3583    }
3584    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
3585                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3586
3587    return ROK;
3588 }/* End BuildSearchSpcToAddModList */
3589
3590 /*******************************************************************
3591  *
3592  * @brief Builds BWP DL dedicated PDCCH config
3593  *
3594  * @details
3595  *
3596  *    Function : BuildBWPDlDedPdcchCfg
3597  *
3598  *    Functionality: Builds BWP DL dedicated PDCCH config
3599  *
3600  * @params[in] struct PDCCH_Config *pdcchCfg
3601  *
3602  * @return ROK     - success
3603  *         RFAILED - failure
3604  *
3605  * ****************************************************************/
3606 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
3607 {
3608    pdcchCfg->controlResourceSetToAddModList = NULLP;
3609    DU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
3610          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3611    if(!pdcchCfg->controlResourceSetToAddModList)
3612    {
3613       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3614       return RFAILED;
3615    }
3616
3617    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
3618    {
3619       return RFAILED;
3620    }
3621
3622    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3623
3624    pdcchCfg->searchSpacesToAddModList = NULLP;
3625    DU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3626          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3627    if(!pdcchCfg->searchSpacesToAddModList)
3628    {
3629       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3630       return RFAILED;
3631    }
3632
3633    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3634    {
3635       return RFAILED;
3636    }
3637
3638    pdcchCfg->searchSpacesToReleaseList = NULLP;
3639    pdcchCfg->downlinkPreemption = NULLP;
3640    pdcchCfg->tpc_PUSCH = NULLP;
3641    pdcchCfg->tpc_PUCCH = NULLP;
3642    pdcchCfg->tpc_SRS = NULLP;
3643
3644    return ROK;
3645 }
3646
3647 /*******************************************************************
3648  *
3649  * @brief Builds DMRS DL PDSCH Mapping type A
3650  *
3651  * @details
3652  *
3653  *    Function : BuildDMRSDLPdschMapTypeA
3654  *
3655  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3656  *
3657  * @params[in]
3658  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3659  * @return ROK     - success
3660  *         RFAILED - failure
3661  *
3662  * ****************************************************************/
3663    uint8_t BuildDMRSDLPdschMapTypeA
3664 (
3665  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3666  )
3667 {
3668    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3669    dmrsDlCfg->choice.setup = NULLP;
3670    DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3671    if(!dmrsDlCfg->choice.setup)
3672    {
3673       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3674       return RFAILED;
3675    }
3676
3677    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3678    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3679    DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3680    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3681    {
3682       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3683       return RFAILED;
3684    }
3685    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3686
3687    dmrsDlCfg->choice.setup->maxLength = NULLP;
3688    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3689    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3690    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3691
3692    return ROK;
3693 }
3694
3695 /*******************************************************************
3696  *
3697  * @brief Builds TCI states to add/modify list
3698  *
3699  * @details
3700  *
3701  *    Function : BuildTCIStatesToAddModList
3702  *
3703  *    Functionality:Builds TCI states to add/modify list
3704  *
3705  * @params[in]
3706  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3707  *
3708  * @return ROK     - success
3709  *         RFAILED - failure
3710  *
3711  * ****************************************************************/
3712 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3713 {
3714    return ROK;
3715 }
3716
3717 /*******************************************************************
3718  *
3719  * @brief Builds PDSCH time domain allocation list
3720  *
3721  * @details
3722  *
3723  *    Function : BuildPdschTimeDomAllocList
3724  *
3725  *    Functionality: Builds PDSCH time domain allocation list
3726  *
3727  * @params[in]
3728  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3729  *
3730  * @return ROK     - success
3731  *         RFAILED - failure
3732  *
3733  * ****************************************************************/
3734    uint8_t BuildPdschTimeDomAllocList
3735 (
3736  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3737  )
3738 {
3739    uint8_t idx;
3740    uint8_t elementCnt;
3741    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3742
3743    timeDomAllocList->present = \
3744                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3745
3746    timeDomAllocList->choice.setup = NULLP;
3747    DU_ALLOC(timeDomAllocList->choice.setup, \
3748          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3749    if(!timeDomAllocList->choice.setup)
3750    {
3751       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3752       return RFAILED;
3753    }
3754
3755    elementCnt = 1;
3756    timeDomAllocList->choice.setup->list.count = elementCnt;
3757    timeDomAllocList->choice.setup->list.size = \
3758                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3759
3760    timeDomAllocList->choice.setup->list.array = NULLP;
3761    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3762          timeDomAllocList->choice.setup->list.size);
3763    if(!timeDomAllocList->choice.setup->list.array)
3764    {
3765       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3766       return RFAILED;
3767    }
3768
3769    for(idx = 0; idx < elementCnt; idx++)
3770    {
3771       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3772       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3773             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3774       if(!timeDomAllocList->choice.setup->list.array[idx])
3775       {
3776          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3777          return RFAILED;
3778       }
3779    }
3780
3781    idx = 0;
3782    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3783
3784    timeDomAlloc->k0 = NULLP;
3785    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3786    timeDomAlloc->startSymbolAndLength = \
3787                                         calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
3788
3789    return ROK;
3790 }
3791
3792 /*******************************************************************
3793  *
3794  * @brief Builds PDSCH PRB Bundling type
3795  *
3796  * @details
3797  *
3798  *    Function : BuildPdschPrbBundlingType
3799  *
3800  *    Functionality: Builds PDSCH PRB Bundling type
3801  *
3802  * @params[in]
3803  * struct PDSCH_Config__prb_BundlingType *prbBndlType
3804  *
3805  * @return ROK     - success
3806  *         RFAILED - failure
3807  *
3808  * ****************************************************************/
3809    uint8_t BuildPdschPrbBundlingType
3810 (
3811  struct PDSCH_Config__prb_BundlingType *prbBndlType
3812  )
3813 {
3814    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
3815
3816    prbBndlType->choice.staticBundling = NULLP;
3817    DU_ALLOC(prbBndlType->choice.staticBundling, \
3818          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
3819    if(!prbBndlType->choice.staticBundling)
3820    {
3821       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
3822       return RFAILED;
3823    }
3824    prbBndlType->choice.staticBundling->bundleSize = NULLP;
3825
3826    return ROK;
3827 }
3828
3829 /*******************************************************************
3830  *
3831  * @brief Builds BWP DL dedicated PDSCH config
3832  *
3833  * @details
3834  *
3835  *    Function : BuildBWPDlDedPdschCfg
3836  *
3837  *    Functionality: Builds BWP DL dedicated PDSCH config
3838  *
3839  * @params[in] struct PDSCH_Config *pdschCfg
3840  *
3841  * @return ROK     - success
3842  *         RFAILED - failure
3843  *
3844  * ****************************************************************/
3845 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
3846 {
3847    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
3848
3849    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
3850    DU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
3851          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
3852    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
3853    {
3854       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3855       return RFAILED;
3856    }
3857
3858    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
3859    {
3860       return RFAILED;
3861    }
3862
3863    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
3864    pdschCfg->tci_StatesToAddModList = NULLP;
3865    pdschCfg->tci_StatesToReleaseList = NULLP;
3866    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
3867 #if 0
3868    DU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
3869    if(!pdschCfg->tci_StatesToAddModList)
3870    {
3871       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3872       return RFAILED;
3873    }
3874    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
3875    {
3876       return RFAILED;
3877    }
3878 #endif
3879
3880    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
3881
3882    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
3883    DU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
3884          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
3885    if(!pdschCfg->pdsch_TimeDomainAllocationList)
3886    {
3887       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3888       return RFAILED;
3889    }
3890
3891    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
3892    {
3893       return RFAILED;
3894    }
3895
3896    pdschCfg->pdsch_AggregationFactor = NULLP;
3897    pdschCfg->rateMatchPatternToAddModList = NULLP;
3898    pdschCfg->rateMatchPatternToReleaseList = NULLP;
3899    pdschCfg->rateMatchPatternGroup1 = NULLP;
3900    pdschCfg->rateMatchPatternGroup2 = NULLP;
3901    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
3902    pdschCfg->mcs_Table = NULLP;
3903
3904    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
3905    DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
3906    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
3907    {
3908       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3909       return RFAILED;
3910    }
3911    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
3912
3913    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
3914    {
3915       return RFAILED;
3916    }
3917
3918    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
3919    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
3920    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3921    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3922    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3923    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3924    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
3925
3926    return ROK;
3927 }
3928
3929 /*******************************************************************
3930  *
3931  * @brief Builds intitial DL BWP
3932  * @details
3933  *
3934  *    Function : BuildInitialDlBWP
3935  *
3936  *    Functionality: Builds intitial DL BWP in spCellCfgDed
3937  *
3938  * @params[in] BWP_DownlinkDedicated_t *dlBwp
3939  *
3940  * @return ROK     - success
3941  *         RFAILED - failure
3942  *
3943  * ****************************************************************/
3944 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
3945 {
3946    dlBwp->pdcch_Config = NULLP;
3947    DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
3948    if(!dlBwp->pdcch_Config)
3949    {
3950       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3951       return RFAILED;
3952    }
3953    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
3954
3955    dlBwp->pdcch_Config->choice.setup = NULLP;
3956    DU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
3957    if(!dlBwp->pdcch_Config->choice.setup)
3958    {
3959       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3960       return RFAILED;
3961    }
3962    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
3963    {
3964       return RFAILED;
3965    }
3966
3967    dlBwp->pdsch_Config = NULLP;
3968    DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
3969    if(!dlBwp->pdsch_Config)
3970    {
3971       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3972       return RFAILED;
3973    }
3974    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
3975
3976    dlBwp->pdsch_Config->choice.setup = NULLP;
3977    DU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
3978    if(!dlBwp->pdsch_Config->choice.setup)
3979    {
3980       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3981       return RFAILED;
3982    }
3983
3984    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
3985    {
3986       return RFAILED;
3987    }
3988
3989    dlBwp->sps_Config = NULLP;
3990    dlBwp->radioLinkMonitoringConfig = NULLP;
3991    return ROK;
3992 }
3993
3994 /*******************************************************************
3995  *
3996  * @brief Builds DMRS UL Pusch Mapping type A
3997  *
3998  * @details
3999  *
4000  *    Function : BuildDMRSULPuschMapTypeA
4001  *
4002  *    Functionality: Builds DMRS UL Pusch Mapping type A
4003  *
4004  * @params[in]
4005  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4006  * @return ROK     - success
4007  *         RFAILED - failure
4008  *
4009  * ****************************************************************/
4010    uint8_t BuildDMRSULPuschMapTypeA
4011 (
4012  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4013  )
4014 {
4015    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
4016    dmrsUlCfg->choice.setup= NULLP;
4017    DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
4018    if(!dmrsUlCfg->choice.setup)
4019    {
4020       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4021       return RFAILED;
4022    }
4023
4024    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
4025    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
4026    DU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
4027    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4028    {
4029       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4030       return RFAILED;
4031    }
4032    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
4033
4034    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
4035    dmrsUlCfg->choice.setup->maxLength = NULLP;
4036    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
4037    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
4038          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4039    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4040    {
4041       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4042       return RFAILED;
4043    }
4044
4045    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
4046    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4047          sizeof(long));
4048    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
4049    {
4050       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4051       return RFAILED;
4052    }
4053    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
4054
4055    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
4056    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
4057    return ROK;
4058 }
4059
4060 /*******************************************************************
4061  *
4062  * @brief Build PUSCH time domain allocation list
4063  *
4064  * @details
4065  *
4066  *    Function : BuildPuschTimeDomAllocList
4067  *
4068  *    Functionality: Build PUSCH time domain allocation list
4069  *
4070  * @params[in]
4071  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4072  *
4073  * @return ROK     - success
4074  *         RFAILED - failure
4075  *
4076  * ****************************************************************/
4077    uint8_t BuildPuschTimeDomAllocList
4078 (
4079  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4080  )
4081 {
4082    uint8_t idx;
4083    uint8_t elementCnt;
4084    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
4085
4086    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
4087    timeDomAllocList->choice.setup = NULLP;
4088    DU_ALLOC(timeDomAllocList->choice.setup, \
4089          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4090    if(!timeDomAllocList->choice.setup)
4091    {
4092       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4093       return RFAILED;
4094    }
4095
4096    elementCnt = 1;
4097    timeDomAllocList->choice.setup->list.count = elementCnt;
4098    timeDomAllocList->choice.setup->list.size = \
4099                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
4100    timeDomAllocList->choice.setup->list.array = NULLP;
4101    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
4102          timeDomAllocList->choice.setup->list.size);
4103    if(!timeDomAllocList->choice.setup->list.array)
4104    {
4105       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4106       return RFAILED;
4107    }
4108
4109    for(idx = 0; idx < elementCnt; idx++)
4110    {
4111       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4112       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
4113             sizeof(PUSCH_TimeDomainResourceAllocation_t));
4114       if(!timeDomAllocList->choice.setup->list.array[idx])
4115       {
4116          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4117          return RFAILED;
4118       }
4119    }
4120
4121    idx = 0;
4122    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4123    DU_ALLOC(timeDomAlloc->k2, sizeof(long));
4124    if(!timeDomAlloc->k2)
4125    {
4126       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4127       return RFAILED;
4128    }
4129    *(timeDomAlloc->k2) = PUSCH_K2;
4130    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4131    timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
4132    return ROK;
4133 }
4134
4135 /*******************************************************************
4136  *
4137  * @brief Builds BWP UL dedicated PUSCH Config
4138  *
4139  * @details
4140  *
4141  *    Function : BuildBWPUlDedPuschCfg
4142  *
4143  *    Functionality:
4144  *      Builds BWP UL dedicated PUSCH Config
4145  *
4146  * @params[in] : PUSCH_Config_t *puschCfg
4147  *
4148  * @return ROK     - success
4149  *         RFAILED - failure
4150  *
4151  * ****************************************************************/
4152 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
4153 {
4154    puschCfg->dataScramblingIdentityPUSCH = NULLP;
4155    DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4156    if(!puschCfg->dataScramblingIdentityPUSCH)
4157    {
4158       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4159       return RFAILED;
4160    }
4161    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
4162
4163    puschCfg->txConfig = NULLP;
4164    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4165    DU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4166          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4167    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4168    {
4169       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4170       return RFAILED;
4171    }
4172
4173    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4174    {
4175       return RFAILED;
4176    }
4177
4178    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4179    puschCfg->pusch_PowerControl = NULLP;
4180    puschCfg->frequencyHopping = NULLP;
4181    puschCfg->frequencyHoppingOffsetLists = NULLP;
4182    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4183
4184    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4185    DU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
4186          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4187    if(!puschCfg->pusch_TimeDomainAllocationList)
4188    {
4189       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4190       return RFAILED;
4191    }
4192
4193    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
4194    {
4195       return RFAILED;
4196    }
4197
4198    puschCfg->pusch_AggregationFactor = NULLP;
4199    puschCfg->mcs_Table = NULLP;
4200    puschCfg->mcs_TableTransformPrecoder = NULLP;
4201    puschCfg->transformPrecoder = NULLP;
4202    DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4203    if(!puschCfg->transformPrecoder)
4204    {
4205       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4206       return RFAILED;
4207    }
4208    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4209
4210    puschCfg->codebookSubset = NULLP;
4211    puschCfg->maxRank = NULLP;
4212    puschCfg->rbg_Size = NULLP;
4213    puschCfg->uci_OnPUSCH = NULLP;
4214    puschCfg->tp_pi2BPSK = NULLP;
4215
4216    return ROK;
4217 }
4218
4219 /*******************************************************************
4220  *
4221  * @brief Fills SRS resource to add/modify list
4222  *
4223  * @details
4224  *
4225  *    Function : BuildSrsRsrcAddModList
4226  *
4227  *    Functionality: Fills SRS resource to add/modify list
4228  *
4229  * @params[in]
4230  * @return ROK     - success
4231  *         RFAILED - failure
4232  *
4233  * ****************************************************************/
4234 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
4235 {
4236    uint8_t   elementCnt;
4237    uint8_t   rsrcIdx;
4238
4239    elementCnt = 1;
4240    resourceList->list.count = elementCnt;
4241    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
4242    resourceList->list.array = NULLP;
4243    DU_ALLOC(resourceList->list.array, resourceList->list.size);
4244    if(!resourceList->list.array)
4245    {
4246       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4247       return RFAILED;
4248    }
4249
4250    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4251    {
4252       DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4253       if(!resourceList->list.array[rsrcIdx])
4254       {
4255          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4256          return RFAILED;
4257       }
4258    }
4259
4260    rsrcIdx = 0;
4261    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
4262    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
4263    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
4264
4265    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
4266    DU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
4267          sizeof(struct SRS_Resource__transmissionComb__n2));
4268    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
4269    {
4270       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4271       return RFAILED;
4272    }
4273    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
4274       = SRS_COMB_OFFSET_N2;
4275    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
4276       = SRS_CYCLIC_SHIFT_N2;
4277
4278    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
4279                                                                       PUSCH_START_SYMBOL;
4280    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
4281                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
4282    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
4283                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
4284
4285    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
4286    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
4287    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
4288    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
4289    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
4290    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
4291                                                                SRS_Resource__groupOrSequenceHopping_neither;
4292
4293    /* Setting resource type to aperiodic for intergration purposes */
4294    resourceList->list.array[rsrcIdx]->resourceType.present = \
4295                                                              SRS_Resource__resourceType_PR_aperiodic;
4296    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
4297    DU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
4298          sizeof(struct SRS_Resource__resourceType__aperiodic));
4299    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
4300    {
4301       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4302       return RFAILED;
4303    }
4304    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
4305
4306    return ROK;
4307 }
4308
4309 /*******************************************************************
4310  *
4311  * @brief Build SRS resource set Add/mod list
4312  *
4313  * @details
4314  *
4315  *    Function : BuildSrsRsrcSetAddModList
4316  *
4317  *    Functionality: Build SRS resource set Add/mod list
4318  *
4319  * @params[in]
4320  * @return ROK     - success
4321  *         RFAILED - failure
4322  *
4323  * ****************************************************************/
4324    uint8_t BuildSrsRsrcSetAddModList
4325 (
4326  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
4327  )
4328 {
4329    uint8_t  elementCnt;
4330    uint8_t  rSetIdx;
4331    uint8_t  rsrcIdx;
4332    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
4333
4334    elementCnt = 1;
4335    rsrcSetList->list.count = elementCnt;
4336    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
4337    rsrcSetList->list.array = NULLP;
4338    DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
4339    if(!rsrcSetList->list.array)
4340    {
4341       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4342       return RFAILED;
4343    }
4344
4345    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4346    {
4347       DU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4348       if(!rsrcSetList->list.array[rSetIdx])
4349       {
4350          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4351          return RFAILED;
4352       }
4353    }
4354
4355    rSetIdx = 0;
4356    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
4357
4358    /* Fill Resource Id list in resource set */
4359    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
4360    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4361          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4362    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4363    {
4364       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4365       return RFAILED;
4366    }
4367
4368    elementCnt = 1;
4369    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4370    rsrcIdList->list.count = elementCnt;
4371    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
4372    rsrcIdList->list.array = NULLP;
4373    DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
4374    if(!rsrcIdList->list.array)
4375    {
4376       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4377       return RFAILED;
4378    }
4379
4380    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4381    {
4382       DU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4383       if(!rsrcIdList->list.array[rsrcIdx])
4384       {
4385          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4386          return RFAILED;
4387       }
4388    }
4389
4390    rsrcIdx = 0;
4391    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
4392
4393    /* Fill resource type */
4394    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
4395                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
4396
4397    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
4398    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4399          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4400    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
4401    {
4402       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4403       return RFAILED;
4404    }
4405    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
4406       = APERIODIC_SRS_RESRC_TRIGGER;
4407
4408    /* TODO : Fill values for below IEs as expected by Viavi */
4409    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
4410    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
4411
4412
4413    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
4414    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
4415    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
4416    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
4417    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
4418
4419    return ROK;
4420 }
4421
4422 /*******************************************************************
4423  *
4424  * @brief Builds BWP UL dedicated SRS Config
4425  *
4426  * @details
4427  *
4428  *    Function : BuildBWPUlDedSrsCfg
4429  *
4430  *    Functionality: Builds BWP UL dedicated SRS Config
4431  *
4432  * @params[in] SRS Config
4433  * @return ROK     - success
4434  *         RFAILED - failure
4435  *
4436  * ****************************************************************/
4437 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
4438 {
4439    srsCfg->srs_ResourceSetToReleaseList = NULLP;
4440    srsCfg->srs_ResourceSetToAddModList = NULLP;
4441    DU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
4442          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4443    if(!srsCfg->srs_ResourceSetToAddModList)
4444    {
4445       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4446       return RFAILED;
4447    }
4448    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
4449    {
4450       return RFAILED;
4451    }
4452
4453    srsCfg->srs_ResourceToReleaseList = NULLP;
4454
4455    /* Resource to Add/Modify list */
4456    srsCfg->srs_ResourceToAddModList = NULLP;
4457    DU_ALLOC(srsCfg->srs_ResourceToAddModList, \
4458          sizeof(struct SRS_Config__srs_ResourceToAddModList));
4459    if(!srsCfg->srs_ResourceToAddModList)
4460    {
4461       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4462       return RFAILED;
4463    }
4464
4465    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
4466    {
4467       return RFAILED;
4468    }
4469
4470    srsCfg->tpc_Accumulation = NULLP;
4471
4472    return ROK;
4473 }
4474
4475
4476
4477 /*******************************************************************
4478  *
4479  * @brief Builds Pusch Serving cell Config
4480  *
4481  * @details
4482  *
4483  *    Function : BuildPuschSrvCellCfg
4484  *
4485  *    Functionality: Builds Pusch Serving cell Config
4486  *
4487  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
4488  *
4489  * @return ROK     - success
4490  *         RFAILED - failure
4491  *
4492  * ****************************************************************/
4493 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
4494 {
4495    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
4496    puschCfg->choice.setup = NULLP;
4497    DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4498    if(!puschCfg->choice.setup)
4499    {
4500       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4501       return RFAILED;
4502    }
4503
4504    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4505    puschCfg->choice.setup->rateMatching = NULLP;
4506    puschCfg->choice.setup->xOverhead = NULLP;
4507    puschCfg->choice.setup->ext1 = NULLP;
4508    DU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
4509    if(!puschCfg->choice.setup->ext1)
4510    {
4511       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4512       return RFAILED;
4513    }
4514
4515    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
4516    DU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
4517    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
4518    {
4519       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4520       return RFAILED;
4521    }
4522    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
4523
4524    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
4525    DU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
4526    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
4527    {
4528       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4529       return RFAILED;
4530    }
4531    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
4532    return ROK;
4533 }
4534
4535 /*******************************************************************
4536  *
4537  * @brief Builds inital UL BWP
4538  *
4539  * @details
4540  *
4541  *    Function : BuildInitialUlBWP
4542  *
4543  *    Functionality: Builds initial UL BWP
4544  *
4545  * @params[in] BWP_UplinkDedicated_t *ulBwp
4546  * @return ROK     - success
4547  *         RFAILED - failure
4548  *
4549  * ****************************************************************/
4550 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4551 {
4552    ulBwp->pucch_Config = NULLP;
4553
4554    /* Fill BWP UL dedicated PUSCH config */
4555    ulBwp->pusch_Config = NULLP;
4556    DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4557    if(!ulBwp->pusch_Config)
4558    {
4559       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4560       return RFAILED;
4561    }
4562
4563    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
4564    ulBwp->pusch_Config->choice.setup = NULLP;
4565    DU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4566    if(!ulBwp->pusch_Config->choice.setup)
4567    {
4568       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4569       return RFAILED;
4570    }
4571
4572    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
4573    {
4574       return RFAILED;
4575    }
4576
4577    ulBwp->configuredGrantConfig = NULLP;
4578
4579    /* Fill BPW UL dedicated SRS config */
4580    ulBwp->srs_Config = NULLP;
4581    DU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4582    if(!ulBwp->srs_Config)
4583    {
4584       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4585       return RFAILED;
4586    }
4587
4588    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
4589    ulBwp->srs_Config->choice.setup = NULLP;
4590    DU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4591    if(!ulBwp->srs_Config->choice.setup)
4592    {
4593       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4594       return RFAILED;
4595    }
4596
4597    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
4598    {
4599       return RFAILED;
4600    }
4601
4602    ulBwp->beamFailureRecoveryConfig = NULLP;
4603
4604    return ROK;
4605 }
4606
4607 /*******************************************************************
4608  *
4609  * @brief Builds UL config
4610  * @details
4611  *
4612  *    Function : BuildUlCfg
4613  *
4614  *    Functionality: Builds UL config in spCellCfgDed
4615  *
4616  * @params[in] UplinkConfig_t *ulCfg
4617  *
4618  * @return ROK     - success
4619  *         RFAILED - failure
4620  *
4621  * ****************************************************************/
4622 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
4623 {
4624    ulCfg->initialUplinkBWP = NULLP;
4625    DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4626    if(!ulCfg->initialUplinkBWP)
4627    {
4628       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4629       return RFAILED;
4630    }
4631
4632    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
4633    {
4634       return RFAILED;
4635    }
4636
4637    ulCfg->uplinkBWP_ToReleaseList = NULLP;
4638    ulCfg->uplinkBWP_ToAddModList = NULLP;
4639    ulCfg->firstActiveUplinkBWP_Id = NULLP;
4640    DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4641    if(!ulCfg->firstActiveUplinkBWP_Id)
4642    {
4643       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4644       return RFAILED;
4645    }
4646    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
4647
4648    ulCfg->pusch_ServingCellConfig = NULLP;
4649    DU_ALLOC(ulCfg->pusch_ServingCellConfig, \
4650          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4651    if(!ulCfg->pusch_ServingCellConfig)
4652    {
4653       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4654       return RFAILED;
4655    }
4656
4657    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
4658    {
4659       return RFAILED;
4660    }
4661
4662    ulCfg->carrierSwitching = NULLP;
4663    ulCfg->ext1 = NULLP;
4664    return ROK;
4665 }
4666
4667 /*******************************************************************
4668  *
4669  * @brief Builds PDSCH serving cell config
4670  * @details
4671  *
4672  *    Function : BuildPdschSrvCellCfg
4673  *
4674  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
4675  *
4676  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
4677  *
4678  * @return ROK     - success
4679  *         RFAILED - failure
4680  *
4681  * ****************************************************************/
4682 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
4683 {
4684    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
4685    pdschCfg->choice.setup = NULLP;
4686    DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
4687    if(!pdschCfg->choice.setup)
4688    {
4689       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4690       return RFAILED;
4691    }
4692
4693    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4694    pdschCfg->choice.setup->xOverhead = NULLP;
4695    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
4696    DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
4697    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
4698    {
4699       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4700       return RFAILED;
4701    }
4702    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
4703    pdschCfg->choice.setup->pucch_Cell = NULLP;
4704    pdschCfg->choice.setup->ext1 = NULLP;
4705
4706    return ROK;
4707 }
4708
4709 /*******************************************************************
4710  *
4711  * @brief Builds CSI Meas config
4712  * @details
4713  *
4714  *    Function : BuildCsiMeasCfg
4715  *
4716  *    Functionality: Builds CSI Meas config in spCellCfgDed
4717  *
4718  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
4719  *
4720  * @return ROK     - success
4721  *         RFAILED - failure
4722  *
4723  * ****************************************************************/
4724 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
4725 {
4726
4727    return ROK;
4728 }
4729
4730 /*******************************************************************
4731  *
4732  * @brief Builds Spcell config dedicated
4733  * @details
4734  *
4735  *    Function : BuildSpCellCfgDed
4736  *
4737  *    Functionality: Builds sp cell config dedicated in spCellCfg
4738  *
4739  * @params[in] ServingCellConfig_t srvCellCfg
4740  *
4741  * @return ROK     - success
4742  *         RFAILED - failure
4743  *
4744  * ****************************************************************/
4745 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
4746 {
4747    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
4748    DU_ALLOC(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
4749    if(!srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
4750    {
4751       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4752       return RFAILED;
4753    }
4754
4755    srvCellCfg->initialDownlinkBWP = NULLP;
4756    DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
4757    if(!srvCellCfg->initialDownlinkBWP)
4758    {
4759       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4760       return RFAILED;
4761    }
4762
4763    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
4764    {
4765       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
4766       return RFAILED;
4767    }
4768    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
4769    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
4770
4771    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
4772    DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
4773    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
4774    {
4775       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4776       return RFAILED;
4777    }
4778    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4779
4780    srvCellCfg->bwp_InactivityTimer = NULLP;
4781
4782    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
4783    DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
4784    if(!srvCellCfg->defaultDownlinkBWP_Id)
4785    {
4786       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4787       return RFAILED;
4788    }
4789    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4790
4791    srvCellCfg->uplinkConfig = NULLP;
4792    DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
4793    if(!srvCellCfg->uplinkConfig)
4794    {
4795       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4796       return RFAILED;
4797    }
4798
4799    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
4800    {
4801       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
4802       return RFAILED;
4803    }
4804    srvCellCfg->supplementaryUplink = NULLP;
4805    srvCellCfg->pdcch_ServingCellConfig = NULLP;
4806
4807    srvCellCfg->pdsch_ServingCellConfig = NULLP;
4808    DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
4809    if(!srvCellCfg->pdsch_ServingCellConfig)
4810    {
4811       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4812       return RFAILED;
4813    }
4814
4815    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
4816    {
4817       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
4818       return RFAILED;
4819    }
4820
4821    srvCellCfg->csi_MeasConfig = NULLP;
4822 #if 0
4823    DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
4824       if(!srvCellCfg->csi_MeasConfig)
4825       {
4826          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4827          return RFAILED;
4828       }
4829
4830    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
4831    {
4832       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
4833       return RFAILED;
4834    }
4835 #endif
4836    srvCellCfg->sCellDeactivationTimer = NULLP;
4837    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
4838    srvCellCfg->tag_Id = TAG_ID;
4839    srvCellCfg->dummy = NULLP;
4840    srvCellCfg->pathlossReferenceLinking = NULLP;
4841    srvCellCfg->servingCellMO = NULLP;
4842    srvCellCfg->ext1 = NULLP;
4843
4844    return ROK;
4845 }
4846 /*******************************************************************
4847  *
4848  * @brief Builds Spcell config
4849  *
4850  * @details
4851  *
4852  *    Function : BuildSpCellCfg
4853  *
4854  *    Functionality: Builds sp cell config in DuToCuRrcContainer
4855  *
4856  * @params[in] SpCellConfig_t spCellCfg
4857  *
4858  * @return ROK     - success
4859  *         RFAILED - failure
4860  *
4861  * ****************************************************************/
4862 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
4863 {
4864
4865    spCellCfg->servCellIndex = NULLP;
4866    DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
4867    if(!spCellCfg->servCellIndex)
4868    {
4869       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4870       return RFAILED;
4871    }
4872    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
4873
4874    spCellCfg->reconfigurationWithSync = NULLP;
4875    spCellCfg->rlf_TimersAndConstants = NULLP;
4876    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
4877    DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
4878    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
4879    {
4880       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4881       return RFAILED;
4882    }
4883    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
4884
4885    spCellCfg->spCellConfigDedicated = NULLP;
4886    DU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
4887    if(!spCellCfg->spCellConfigDedicated)
4888    {
4889       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4890       return RFAILED;
4891    }
4892    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
4893    {
4894       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
4895       return RFAILED;
4896    }
4897    return ROK;
4898 }
4899 /*******************************************************************
4900  *
4901  * @brief Builds Phy cell group config
4902  *
4903  * @details
4904  *
4905  *    Function : BuildPhyCellGrpCfg
4906  *
4907  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
4908  *
4909  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
4910  *
4911  * @return ROK     - success
4912  *         RFAILED - failure
4913  *
4914  * ****************************************************************/
4915 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
4916 {
4917    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
4918    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
4919
4920    phyCellGrpCfg->p_NR_FR1 = NULLP;
4921    DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
4922    if(!phyCellGrpCfg->p_NR_FR1)
4923    {
4924       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
4925       return RFAILED;
4926    }
4927    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
4928    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
4929    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
4930    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
4931    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
4932    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
4933    phyCellGrpCfg->cs_RNTI = NULLP;
4934    phyCellGrpCfg->ext1 = NULLP;
4935    phyCellGrpCfg->ext2 = NULLP;
4936
4937    return ROK;
4938 }
4939 /*******************************************************************
4940  *
4941  * @brief Builds Mac cell group config
4942  *
4943  * @details
4944  *
4945  *    Function : BuildMacCellGrpCfg
4946  *
4947  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
4948  *
4949  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
4950  *
4951  * @return ROK     - success
4952  *         RFAILED - failure
4953  *
4954  * ****************************************************************/
4955 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
4956 {
4957    macCellGrpCfg->drx_Config = NULLP;
4958    macCellGrpCfg->schedulingRequestConfig = NULLP;
4959    DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
4960    if(!macCellGrpCfg->schedulingRequestConfig)
4961    {
4962       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4963       return RFAILED;
4964    }
4965
4966    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
4967    {
4968       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
4969       return RFAILED;
4970    }
4971
4972    macCellGrpCfg->bsr_Config = NULLP;
4973    DU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
4974    if(!macCellGrpCfg->bsr_Config)
4975    {
4976       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4977       return RFAILED;
4978    }
4979
4980    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
4981    {
4982       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
4983       return RFAILED;
4984    }
4985
4986    macCellGrpCfg->tag_Config = NULLP;
4987    DU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
4988    if(!macCellGrpCfg->tag_Config)
4989    {
4990       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
4991       return RFAILED;
4992    }
4993
4994    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
4995    {
4996       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
4997       return RFAILED;
4998    }
4999
5000    macCellGrpCfg->phr_Config = NULLP;
5001    DU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
5002    if(!macCellGrpCfg->phr_Config)
5003    {
5004       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5005       return RFAILED;
5006    }
5007
5008    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
5009    {
5010       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
5011       return RFAILED;
5012    }
5013
5014    macCellGrpCfg->skipUplinkTxDynamic = false;
5015    macCellGrpCfg->ext1 = NULLP;
5016
5017    return ROK;
5018 }
5019 /*******************************************************************
5020  *
5021  * @brief Frees memeory allocated for SearchSpcToAddModList
5022  *
5023  * @details
5024  *
5025  *    Function : FreeSearchSpcToAddModList
5026  *
5027  *    Functionality: Deallocating memory of SearchSpcToAddModList
5028  *
5029  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
5030  *
5031  * @return void
5032  *
5033  4221 * ****************************************************************/
5034 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
5035 {
5036    uint8_t idx1=0;
5037    uint8_t idx2=0;
5038    struct  SearchSpace *searchSpc=NULLP;
5039
5040    if(searchSpcList->list.array)
5041    {
5042       if(searchSpcList->list.array[idx2])
5043       {
5044          searchSpc = searchSpcList->list.array[idx2];
5045          if(searchSpc->controlResourceSetId)
5046          {
5047             if(searchSpc->monitoringSlotPeriodicityAndOffset)
5048             {
5049                if(searchSpc->monitoringSymbolsWithinSlot)
5050                {
5051                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
5052                   {
5053                      if(searchSpc->nrofCandidates)
5054                      {
5055                         if(searchSpc->searchSpaceType)
5056                         {
5057                            DU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
5058                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
5059                            DU_FREE(searchSpc->searchSpaceType, sizeof(struct
5060                                     SearchSpace__searchSpaceType));
5061                         }
5062                         DU_FREE(searchSpc->nrofCandidates,
5063                               sizeof(struct SearchSpace__nrofCandidates));
5064                      }
5065                      DU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
5066                            searchSpc->monitoringSymbolsWithinSlot->size);
5067                   }
5068                   DU_FREE(searchSpc->monitoringSymbolsWithinSlot,
5069                         sizeof(BIT_STRING_t));
5070                }
5071                DU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
5072                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
5073             }
5074             DU_FREE(searchSpc->controlResourceSetId,
5075                   sizeof(ControlResourceSetId_t));
5076          }
5077       }
5078       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
5079       {
5080          DU_FREE(searchSpcList->list.array[idx1],
5081                sizeof(struct SearchSpace));
5082       }
5083       DU_FREE(searchSpcList->list.array,searchSpcList->list.size);
5084    }
5085 }
5086 /*******************************************************************
5087  *
5088  * @brief Frees memory allocated for PdschTimeDomAllocList
5089  *
5090  * @details
5091  *
5092  *    Function : FreePdschTimeDomAllocList
5093  *
5094  *    Functionality: Deallocating memory of PdschTimeDomAllocList
5095  *
5096  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
5097  *
5098  * @return void
5099  *
5100  4221 * ****************************************************************/
5101 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
5102 {
5103    uint8_t idx1=0;
5104
5105    if(timeDomAllocList->choice.setup)
5106    {
5107       if(timeDomAllocList->choice.setup->list.array)
5108       {
5109          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
5110          {
5111             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
5112                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
5113          }
5114          DU_FREE(timeDomAllocList->choice.setup->list.array, \
5115                timeDomAllocList->choice.setup->list.size);
5116       }
5117       DU_FREE(timeDomAllocList->choice.setup,\
5118             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
5119    }
5120 }
5121 /*******************************************************************
5122  *
5123  * @brief Frees memory allocated for PuschTimeDomAllocList
5124  *
5125  *@details
5126  *
5127  *    Function : FreePuschTimeDomAllocList
5128  *
5129  *    Functionality: Deallocating memory of PuschTimeDomAllocList
5130  *
5131  * @params[in] PUSCH_Config_t *puschCfg
5132  *
5133  * @return void
5134  *
5135  * ****************************************************************/
5136 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
5137 {
5138    uint8_t idx1=0;
5139    uint8_t idx2=0;
5140    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
5141
5142    if(puschCfg->pusch_TimeDomainAllocationList)
5143    {
5144       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
5145       if(timeDomAllocList_t->choice.setup)
5146       {
5147          if(timeDomAllocList_t->choice.setup->list.array)
5148          {
5149             DU_FREE(timeDomAllocList_t->choice.setup->list.array[idx2]->k2, sizeof(long));
5150             for(idx1 = 0; idx1<timeDomAllocList_t->choice.setup->list.count; idx1++)
5151             {
5152                DU_FREE(timeDomAllocList_t->choice.setup->list.array[idx1],\
5153                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
5154             }
5155             DU_FREE(timeDomAllocList_t->choice.setup->list.array, \
5156                   timeDomAllocList_t->choice.setup->list.size);
5157          }
5158          DU_FREE(timeDomAllocList_t->choice.setup, \
5159                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
5160       }
5161       DU_FREE(puschCfg->transformPrecoder, sizeof(long));
5162       DU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
5163             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
5164    }
5165
5166 }
5167 /*******************************************************************
5168  *
5169  * @brief Frees memory allocated for InitialUlBWP
5170  *
5171  * @details
5172  *
5173  *    Function : FreeInitialUlBWP
5174  *
5175  *    Functionality: Deallocating memory of InitialUlBWP
5176  *
5177  * @params[in] BWP_UplinkDedicated_t *ulBwp
5178  *
5179  * @return void
5180  *
5181  * ****************************************************************/
5182 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5183 {
5184    uint8_t  rSetIdx, rsrcIdx;
5185    SRS_Config_t   *srsCfg = NULLP;
5186    PUSCH_Config_t *puschCfg = NULLP;
5187    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
5188    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
5189    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
5190    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
5191
5192    if(ulBwp->pusch_Config)
5193    {
5194       if(ulBwp->pusch_Config->choice.setup)
5195       {
5196          puschCfg=ulBwp->pusch_Config->choice.setup;
5197          if(puschCfg->dataScramblingIdentityPUSCH)
5198          {
5199             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
5200             {
5201                FreePuschTimeDomAllocList(puschCfg);
5202                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
5203                if(dmrsUlCfg->choice.setup)
5204                {
5205                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
5206                   {
5207                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
5208                      {
5209                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
5210                               sizeof(long));
5211                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
5212                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
5213                      }
5214                      DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
5215                            sizeof(long));
5216                   }
5217                   DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
5218                }
5219                DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
5220                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
5221             }
5222             DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
5223          }
5224          DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5225       }
5226       DU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5227
5228       /* Free SRS-Config */
5229       if(ulBwp->srs_Config)
5230       {
5231          if(ulBwp->srs_Config->choice.setup)
5232          {
5233             srsCfg = ulBwp->srs_Config->choice.setup;
5234
5235             /* Free Resource Set to add/mod list */
5236             if(srsCfg->srs_ResourceSetToAddModList)
5237             {
5238                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
5239                if(rsrcSetList->list.array)
5240                {
5241                   rSetIdx = 0;
5242
5243                   /* Free SRS resource Id list in this SRS resource set */
5244                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5245                   {
5246                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5247
5248                      if(rsrcIdList->list.array)
5249                      {
5250                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5251                         {
5252                            DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5253                         }
5254                         DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
5255                      }
5256                      DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5257                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5258                   }
5259
5260                   /* Free resource type info for this SRS resource set */
5261                   DU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5262                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5263
5264                   /* Free memory for each resource set */
5265                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5266                   {
5267                      DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5268                   }
5269                   DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
5270                }
5271                DU_FREE(srsCfg->srs_ResourceSetToAddModList, \
5272                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5273             }
5274
5275             /* Free resource to add/modd list */
5276             if(srsCfg->srs_ResourceToAddModList)
5277             {
5278                resourceList = srsCfg->srs_ResourceToAddModList;
5279                if(resourceList->list.array)
5280                {
5281                   rsrcIdx = 0;
5282                   DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
5283                         sizeof(struct SRS_Resource__transmissionComb__n2));
5284                   DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
5285                         sizeof(struct SRS_Resource__resourceType__aperiodic));
5286
5287                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5288                   {
5289                      DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5290                   }
5291                   DU_FREE(resourceList->list.array, resourceList->list.size);
5292                }
5293                DU_FREE(srsCfg->srs_ResourceToAddModList, \
5294                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
5295             }
5296
5297             DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5298          }
5299          DU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5300       }
5301    }
5302 }
5303 /*******************************************************************
5304  *
5305  * @brief Frees memory allocated for initialUplinkBWP
5306  *
5307  * @details
5308  *
5309  *    Function : FreeinitialUplinkBWP
5310  *
5311  *    Functionality: Deallocating memory of initialUplinkBWP
5312  *
5313  * @params[in] UplinkConfig_t *ulCfg
5314  *
5315  * @return void
5316  *
5317  *
5318  * ****************************************************************/
5319 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
5320 {
5321    BWP_UplinkDedicated_t *ulBwp=NULLP;
5322    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
5323
5324    if(ulCfg->initialUplinkBWP)
5325    {
5326       ulBwp=ulCfg->initialUplinkBWP;
5327       if(ulCfg->firstActiveUplinkBWP_Id)
5328       {
5329          if(ulCfg->pusch_ServingCellConfig)
5330          {
5331             puschCfg=ulCfg->pusch_ServingCellConfig;
5332             if(puschCfg->choice.setup)
5333             {
5334                if(puschCfg->choice.setup->ext1)
5335                {
5336                   DU_FREE(puschCfg->choice.setup->ext1->\
5337                         processingType2Enabled,sizeof(BOOLEAN_t));
5338                   DU_FREE(puschCfg->choice.setup->ext1->\
5339                         maxMIMO_Layers,sizeof(long));
5340                   DU_FREE(puschCfg->choice.setup->ext1, \
5341                         sizeof(struct PUSCH_ServingCellConfig__ext1));
5342                }
5343                DU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5344             }
5345             DU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5346          }
5347          DU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5348       }
5349       FreeInitialUlBWP(ulBwp);
5350       DU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5351    }
5352 }
5353 /*******************************************************************
5354  *
5355  * @brief Frees emmory allocated for BWPDlDedPdschCfg
5356  *
5357  * @details
5358  *
5359  *    Function : FreeBWPDlDedPdschCfg
5360  *
5361  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
5362  *
5363  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5364  *
5365  * @return void
5366  *
5367  *
5368  * ****************************************************************/
5369 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
5370 {
5371    struct PDSCH_Config *pdschCfg=NULLP;
5372    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
5373    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
5374    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
5375
5376    if(dlBwp->pdsch_Config->choice.setup)
5377    {
5378       pdschCfg=dlBwp->pdsch_Config->choice.setup;
5379       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
5380       {
5381          if(pdschCfg->pdsch_TimeDomainAllocationList)
5382          {
5383             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
5384             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
5385             {
5386                prbBndlType=&pdschCfg->prb_BundlingType;
5387                DU_FREE(prbBndlType->choice.staticBundling,\
5388                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
5389                DU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
5390             }
5391             FreePdschTimeDomAllocList(timeDomAllocList);
5392             DU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
5393                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
5394          }
5395          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
5396          if(dmrsDlCfg->choice.setup)
5397          {
5398             DU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
5399                   sizeof(long));
5400             DU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
5401          }
5402          DU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
5403                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
5404       }
5405       DU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
5406    }
5407 }
5408 /*******************************************************************
5409  *
5410  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
5411  *
5412  * @details
5413  *
5414  *    Function : FreeBWPDlDedPdcchCfg
5415  *
5416  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
5417  *
5418  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5419  *
5420  * @return void
5421  *
5422  *
5423  * ****************************************************************/
5424 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
5425 {
5426    uint8_t idx1=0;
5427    uint8_t idx2=0;
5428    struct PDCCH_Config *pdcchCfg=NULLP;
5429    struct ControlResourceSet *controlRSet=NULLP;
5430    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
5431
5432    if(dlBwp->pdcch_Config->choice.setup)
5433    {
5434       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
5435       if(pdcchCfg->controlResourceSetToAddModList)
5436       {
5437          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
5438          if(controlRSetList->list.array)
5439          {
5440             controlRSet = controlRSetList->list.array[idx2];
5441             if(controlRSet)
5442             {
5443                if(controlRSet->frequencyDomainResources.buf)
5444                {
5445                   if(controlRSet->pdcch_DMRS_ScramblingID)
5446                   {
5447                      if(pdcchCfg->searchSpacesToAddModList)
5448                      {
5449                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
5450                         DU_FREE(pdcchCfg->searchSpacesToAddModList, \
5451                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
5452                      }
5453                      DU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
5454                   }
5455                   DU_FREE(controlRSet->frequencyDomainResources.buf, \
5456                         controlRSet->frequencyDomainResources.size);
5457                }
5458             }
5459             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
5460             {
5461                DU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
5462             }
5463             DU_FREE(controlRSetList->list.array, controlRSetList->list.size);
5464          }
5465          DU_FREE(pdcchCfg->controlResourceSetToAddModList, \
5466                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
5467       }
5468       DU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
5469    }
5470 }
5471
5472 /*******************************************************************
5473  *
5474  * @brief Frees emmory allocated for DUToCURRCContainer
5475  *
5476  * @details
5477  *
5478  *    Function : FreeMemDuToCuRrcCont
5479  *
5480  *    Functionality: Deallocating memory of DuToCuRrcContainer
5481  *
5482  * @params[in] DuToCuRRCContainer, DuToCuRRCContainer
5483  *
5484  * @return ROK     - success
5485  *         RFAILED - failure
5486  *
5487  * ****************************************************************/
5488 uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg)
5489 {
5490    uint8_t idx=0;
5491    SpCellConfig_t *spCellCfg=NULLP;
5492    ServingCellConfig_t *srvCellCfg=NULLP;
5493    BWP_DownlinkDedicated_t *dlBwp=NULLP;
5494    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
5495    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
5496    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
5497    struct RLC_Config *rlcConfig=NULLP;
5498    struct LogicalChannelConfig *macLcConfig=NULLP;
5499    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
5500    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
5501    struct TAG_Config *tagConfig=NULLP;
5502    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
5503    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
5504    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
5505
5506    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
5507    if(rlcBearerList)
5508    {
5509       if(rlcBearerList->list.array)
5510       {
5511          for(idx=0; idx<rlcBearerList->list.count; idx++)
5512          {
5513             if(rlcBearerList->list.array[idx])
5514             {
5515                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
5516                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
5517                if(rlcConfig)
5518                {
5519                   if(rlcConfig->choice.am)
5520                   {
5521                      DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5522                      DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5523                      DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
5524                   }
5525                   DU_FREE(rlcConfig, sizeof(struct RLC_Config));
5526                }
5527                DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
5528                if(macLcConfig)
5529                {
5530                   if(macLcConfig->ul_SpecificParameters)
5531                   {
5532                      DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
5533                      DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
5534                      DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
5535                   }
5536                   DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
5537                }
5538                DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
5539             }
5540          }
5541          DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
5542       }
5543       DU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5544    }
5545
5546    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
5547    if(macCellGrpCfg)
5548    {
5549       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
5550       if(schedulingRequestConfig)
5551       {
5552          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
5553          if(schReqList)
5554          {
5555             if(schReqList->list.array)
5556             {
5557                for(idx=0;idx<schReqList->list.count; idx++)
5558                {
5559                   if(schReqList->list.array[idx])
5560                   {
5561                      DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
5562                      DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
5563                   }
5564                }
5565                DU_FREE(schReqList->list.array, schReqList->list.size);
5566             }
5567             DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
5568                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
5569             DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5570       }
5571       if(macCellGrpCfg->bsr_Config)
5572       {
5573          DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5574       }
5575       tagConfig = macCellGrpCfg->tag_Config;
5576       if(tagConfig)
5577       {
5578          tagList = tagConfig->tag_ToAddModList;
5579          if(tagList)
5580          {
5581             if(tagList->list.array)
5582             {
5583                for(idx=0; idx<tagList->list.count; idx++)
5584                {
5585                   DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
5586                }
5587                DU_FREE(tagList->list.array, tagList->list.size);
5588             }
5589             DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
5590          }
5591          DU_FREE(tagConfig, sizeof(struct TAG_Config));
5592       }
5593
5594       phrConfig = macCellGrpCfg->phr_Config;
5595       if(phrConfig)
5596       {
5597          DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
5598          DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
5599       }
5600
5601       DU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
5602    }
5603
5604    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
5605    if(phyCellGrpCfg)
5606    {
5607       DU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5608       DU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
5609    }
5610
5611    spCellCfg = cellGrpCfg->spCellConfig;
5612    if(spCellCfg)
5613    {
5614       if(spCellCfg->servCellIndex)
5615       {
5616          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
5617          {
5618             if(spCellCfg->spCellConfigDedicated)
5619             {
5620                srvCellCfg = spCellCfg->spCellConfigDedicated;
5621                if(srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
5622                {
5623                   if(srvCellCfg->initialDownlinkBWP)
5624                   {
5625                      dlBwp = srvCellCfg->initialDownlinkBWP;
5626                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
5627                      {
5628                         if(srvCellCfg->defaultDownlinkBWP_Id)
5629                         {
5630                            if(srvCellCfg->uplinkConfig)
5631                            {
5632                               if(srvCellCfg->pdsch_ServingCellConfig)
5633                               {
5634                                  pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
5635                                  if(pdschCfg->choice.setup)
5636                                  {
5637                                     DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
5638                                     DU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5639                                  }
5640                                  DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
5641                                        ServingCellConfig__pdsch_ServingCellConfig));
5642                               }
5643                               FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
5644                               DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
5645                            }
5646                            DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
5647                         }
5648                         DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
5649                      }
5650                      if(dlBwp->pdcch_Config)
5651                      {
5652                         if(dlBwp->pdsch_Config)
5653                         {
5654                            FreeBWPDlDedPdschCfg(dlBwp);
5655                            DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
5656                         }
5657                         FreeBWPDlDedPdcchCfg(dlBwp);
5658                         DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
5659                     }
5660                     DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
5661                   }
5662                   DU_FREE(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
5663                }
5664                DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5665             }
5666             DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5667          }
5668          DU_FREE(spCellCfg->servCellIndex, sizeof(long));
5669       }
5670       DU_FREE(spCellCfg,sizeof(SpCellConfig_t));
5671    }
5672    return ROK;
5673 }
5674 /*******************************************************************
5675  *
5676  * @brief Builds DU To CU RRC Container
5677  *
5678  * @details
5679  *
5680  *    Function : BuildDuToCuRrcContainer
5681  *
5682  *    Functionality: Builds DuToCuRrcContainer
5683  *
5684  * @params[in] idx, index in F1AP msg
5685  *             DuToCuRRCContainer, DuToCuRRCContainer
5686  *
5687  * @return ROK     - success
5688  *         RFAILED - failure
5689  *
5690  * ****************************************************************/
5691 uint8_t BuildDuToCuRrcContainer(DUtoCURRCContainer_t *duToCuRrcContainer)
5692 {
5693    uint8_t  ret = ROK;
5694    CellGroupConfigRrc_t  cellGrpCfg;
5695    asn_enc_rval_t        encRetVal;
5696    memset(&cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
5697    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
5698
5699    while(true)
5700    {
5701       cellGrpCfg.cellGroupId = CELL_GRP_ID;
5702
5703       cellGrpCfg.rlc_BearerToAddModList = NULLP;
5704       DU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5705       if(!cellGrpCfg.rlc_BearerToAddModList)
5706       {
5707          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5708          ret = RFAILED;
5709          break;
5710       }
5711       if(BuildRlcBearerToAddModList(cellGrpCfg.rlc_BearerToAddModList) != ROK)
5712       {
5713          DU_LOG("\nERROR  -->  F1AP : BuildRlcBearerToAddModList failed");
5714          ret = RFAILED;
5715          break;
5716       }
5717
5718       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
5719       cellGrpCfg.mac_CellGroupConfig = NULLP;
5720       DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
5721       if(!cellGrpCfg.mac_CellGroupConfig)
5722       {
5723          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5724          ret = RFAILED;
5725          break;
5726       }
5727       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
5728       {
5729          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
5730          ret = RFAILED;
5731          break;
5732       }
5733
5734       cellGrpCfg.physicalCellGroupConfig = NULLP;
5735       DU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
5736       if(!cellGrpCfg.physicalCellGroupConfig)
5737       {
5738          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5739          ret = RFAILED;
5740          break;
5741       }
5742       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
5743       {
5744          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
5745          ret = RFAILED;
5746          break;
5747       }
5748
5749       cellGrpCfg.spCellConfig = NULLP;
5750       DU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
5751       if(!cellGrpCfg.spCellConfig)
5752       {
5753          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5754          ret = RFAILED;
5755          break;
5756       }
5757       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
5758       {
5759          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
5760          ret = RFAILED;
5761          break;
5762       }
5763
5764       cellGrpCfg.sCellToAddModList = NULLP;
5765       cellGrpCfg.sCellToReleaseList = NULLP;
5766       cellGrpCfg.ext1 = NULLP;
5767
5768       /* encode cellGrpCfg into duToCuRrcContainer */
5769       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
5770       memset(encBuf, 0, ENC_BUF_MAX_LEN);
5771       encBufSize = 0;
5772       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
5773       /* Encode results */
5774       if(encRetVal.encoded == ENCODE_FAIL)
5775       {
5776          DU_LOG( "\nERROR  --> F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
5777                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5778          ret = RFAILED;
5779          break;
5780       }
5781       else
5782       {
5783          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
5784          for(int i=0; i< encBufSize; i++)
5785          {
5786             printf("%x",encBuf[i]);
5787          }
5788       }
5789
5790       duToCuRrcContainer->size = encBufSize;
5791       DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
5792       if(!duToCuRrcContainer->buf)
5793       {
5794          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
5795          ret = RFAILED;
5796          break;
5797       }
5798       if(ret == ROK)
5799       {
5800          memcpy(duToCuRrcContainer->buf, encBuf, duToCuRrcContainer->size);
5801       }
5802       break;
5803    }
5804    FreeMemDuToCuRrcCont(&cellGrpCfg);
5805    return ret;
5806 }
5807
5808 /*******************************************************************
5809  *
5810  * @brief Free memory allocated in InitialULRRCMessage
5811  *
5812  * @details
5813  *
5814  *    Function : freeInitUlRrcMsgTransfer
5815  *
5816  *    Functionality: Free memory allocated in InitialULRRCMessage
5817  *
5818  * @params[in]F1AP_PDU_t  *f1apMsg)
5819  *
5820  * @return ROK     - success
5821  *         RFAILED - failure
5822  *
5823  * ****************************************************************/
5824
5825 uint8_t freeInitUlRrcMsgTransfer(F1AP_PDU_t  *f1apMsg)
5826 {
5827    uint8_t ieIdx, arrIdx;
5828    InitialULRRCMessageTransfer_t *initULRRCMsg=NULLP;
5829
5830    if(f1apMsg)
5831    {
5832       if(f1apMsg->choice.initiatingMessage)
5833       {
5834          initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.\
5835             choice.InitialULRRCMessageTransfer;
5836          if(initULRRCMsg->protocolIEs.list.array)
5837          {
5838             for(ieIdx = 0; ieIdx < initULRRCMsg->protocolIEs.list.count; ieIdx++)
5839             {
5840                switch(initULRRCMsg->protocolIEs.list.array[ieIdx]->id)
5841                {
5842                   case ProtocolIE_ID_id_NRCGI:
5843                   {
5844                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf)
5845                      {
5846                         if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf)
5847                         {
5848                            DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf,\
5849                            initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.size);
5850                         }
5851                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf,\
5852                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.size);
5853                      }
5854                      break;
5855                   }
5856                   case ProtocolIE_ID_id_RRCContainer:
5857                   {
5858                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
5859                      {
5860                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,\
5861                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
5862                      }
5863                      break;
5864                   }
5865                   case ProtocolIE_ID_id_DUtoCURRCContainer:
5866                   {
5867                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf)
5868                      {
5869                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf,
5870                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.size);
5871                      }
5872                      break;
5873                   }
5874                   default:
5875                      break;
5876                }
5877              }
5878              for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
5879              {
5880                 if(initULRRCMsg->protocolIEs.list.array[arrIdx])
5881                 {
5882                    DU_FREE(initULRRCMsg->protocolIEs.list.array[arrIdx],\
5883                       sizeof(InitialULRRCMessageTransferIEs_t));
5884                 }
5885              }
5886              DU_FREE(initULRRCMsg->protocolIEs.list.array, initULRRCMsg->protocolIEs.list.size);
5887           }
5888          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
5889       }
5890       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
5891    }
5892    else
5893    {
5894       DU_LOG("\nERROR  -->  DU_APP : Recevied F1ap Pdu is null at freeInitUlRrcMsgTransfer()");
5895       return RFAILED;
5896    }
5897    return ROK;
5898 }
5899
5900 /*******************************************************************
5901  *
5902  * @brief Builds and sends the InitialULRRCMessage
5903  *
5904  * @details
5905  *
5906  *    Function : BuildAndSendInitialRrcMsgTransfer
5907  *
5908  *    Functionality: Constructs the Initial UL RRC Message Transfer and sends
5909  *                   it to the CU through SCTP.
5910  *
5911  * @params[in]
5912  *
5913  * @return ROK     - success
5914  *         RFAILED - failure
5915  *
5916  * ****************************************************************/
5917 uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti,
5918       uint16_t rrcContSize, uint8_t *rrcContainer)
5919 {
5920    uint8_t   ret;
5921    uint8_t   elementCnt;
5922    uint8_t   ieIdx;
5923    asn_enc_rval_t  encRetVal;
5924    F1AP_PDU_t  *f1apMsg = NULLP;
5925    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
5926    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
5927
5928    while(true)
5929    {
5930       DU_LOG("\n INFO   -->  F1AP : Building RRC Setup Request\n");
5931       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
5932       if(f1apMsg == NULLP)
5933       {
5934          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
5935          break;
5936       }
5937       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
5938       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
5939       if(f1apMsg->choice.initiatingMessage == NULLP)
5940       {
5941          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
5942          break;
5943       }
5944       f1apMsg->choice.initiatingMessage->procedureCode =\
5945                                                         ProcedureCode_id_InitialULRRCMessageTransfer;
5946       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
5947       f1apMsg->choice.initiatingMessage->value.present = \
5948                                                          InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
5949       initULRRCMsg =\
5950                     &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
5951       elementCnt = 5;
5952       initULRRCMsg->protocolIEs.list.count = elementCnt;
5953       initULRRCMsg->protocolIEs.list.size = \
5954                                             elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *);
5955       /* Initialize the F1Setup members */
5956       DU_ALLOC(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
5957       if(initULRRCMsg->protocolIEs.list.array == NULLP)
5958       {
5959          DU_LOG(" ERROR  -->  F1AP : Memory allocation for\
5960                RRCSetupRequestMessageTransferIEs failed");
5961          break;
5962       }
5963       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
5964       {
5965          DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx],\
5966                sizeof(InitialULRRCMessageTransferIEs_t));
5967          if(initULRRCMsg->protocolIEs.list.array[ieIdx] == NULLP)
5968          {
5969             break;
5970          }
5971       }
5972       ieIdx = 0;
5973       /*GNB DU UE F1AP ID*/
5974       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
5975                                                         ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
5976       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  = Criticality_reject;
5977       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
5978                                                                   InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
5979       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
5980
5981
5982       /*NRCGI*/
5983       ieIdx++;
5984       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
5985                                                         ProtocolIE_ID_id_NRCGI;
5986       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  =Criticality_reject;
5987       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
5988                                                                   InitialULRRCMessageTransferIEs__value_PR_NRCGI;
5989
5990       ret =\
5991            BuildNrcgi(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
5992       if(ret!=ROK)
5993       {
5994          break;
5995       }
5996
5997       /*CRNTI*/
5998       ieIdx++;
5999       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6000                                                         ProtocolIE_ID_id_C_RNTI;
6001       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6002       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6003                                                                  InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
6004       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.C_RNTI = crnti;
6005
6006       /*RRCContainer*/
6007       ieIdx++;
6008       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6009                                                         ProtocolIE_ID_id_RRCContainer;
6010       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6011       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6012                                                                  InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
6013
6014       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = rrcContSize;
6015       DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
6016             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size)
6017       if(!initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
6018       {
6019          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
6020          break;
6021
6022       }
6023       memcpy(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, rrcContainer,
6024             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
6025
6026
6027       /*DUtoCURRCContainer*/
6028       ieIdx++;
6029       initULRRCMsg->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCContainer;
6030       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6031       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6032                                                                  InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
6033
6034       ret = BuildDuToCuRrcContainer(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer);
6035       if(ret != ROK)
6036       {
6037          break;
6038       }
6039
6040       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
6041
6042       /* Encode the F1SetupRequest type as APER */
6043       memset(encBuf, 0, ENC_BUF_MAX_LEN);
6044       encBufSize = 0;
6045       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
6046       /* Encode results */
6047       if(encRetVal.encoded == ENCODE_FAIL)
6048       {
6049          DU_LOG( "\nERROR  --> F1AP : Could not encode Initial UL RRC Message Transfer\
6050                structure (at %s)\n",encRetVal.failed_type ? \
6051                encRetVal.failed_type->name : "unknown");
6052          ret = RFAILED;
6053          break;
6054       }
6055       else
6056       {
6057
6058          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for Initial UL RRC\
6059                Message transfer\n");
6060          for(int i=0; i< encBufSize; i++)
6061          {
6062             printf("%x",encBuf[i]);
6063          }
6064       }
6065       /* Sending  msg  */
6066       if(sendF1APMsg() != ROK)
6067       {
6068          DU_LOG("\nERROR  -->  F1AP : Sending Initial UL RRC Message Transfer Failed");
6069          ret = RFAILED;
6070          break;
6071       }
6072       break;
6073    }
6074    freeInitUlRrcMsgTransfer(f1apMsg);
6075    return ret;
6076 }/* End of BuildAndSendInitialRrcMsgTransfer*/
6077
6078 /*****  UE SETUP REQUEST *****/
6079
6080 /*******************************************************************
6081  *
6082  * @brief Free Qos And Snssai Drb Info
6083  *
6084  * @details
6085  *
6086  *    Function : freeDrbQosAndSnssaiInfo
6087  *
6088  *    Functionality: Free Qos And Snssai Drb Info
6089  *
6090  * @params[in] LcCfg *lcCfg,
6091  * @return void
6092  *
6093  * ****************************************************************/
6094 void freeDrbQosAndSnssaiInfo(LcCfg *lcCfg)
6095 {
6096    if(lcCfg->snssai)
6097    {
6098       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6099    }
6100    if(lcCfg->drbQos)
6101    {
6102       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
6103    }
6104 }
6105
6106 /******************************************************************
6107 *
6108 * @brief Function to delete the RLC Lc cfg from UE APP DB
6109 *
6110 * @details
6111 *
6112 *  Function : freeRlcLcCfg
6113 *
6114 *  Functionality: Function to delete the RLC Lc cfg from UE APP DB
6115 *
6116 *
6117  *****************************************************************/
6118
6119 void freeRlcLcCfg(RlcBearerCfg *lcCfg)
6120 {
6121    switch(lcCfg->rlcMode)
6122    {
6123       case RLC_AM :
6124          {
6125             if(lcCfg->u.amCfg)
6126             {
6127                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.amCfg, sizeof(AmBearerCfg));
6128             }
6129             break;
6130          }
6131       case RLC_UM_BI_DIRECTIONAL :
6132          {
6133             if(lcCfg->u.umBiDirCfg)
6134             {
6135                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
6136             }
6137             break;
6138          }
6139       case RLC_UM_UNI_DIRECTIONAL_UL :
6140          {
6141             if(lcCfg->u.umUniDirUlCfg)
6142             {
6143                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
6144             }
6145             break;
6146
6147          }
6148       case RLC_UM_UNI_DIRECTIONAL_DL :
6149          {
6150             if(lcCfg->u.umUniDirDlCfg)
6151             {
6152                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
6153             }
6154             break;
6155          }
6156       default:
6157          DU_LOG("\nERROR  -->  DU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
6158          break;
6159    }
6160 }
6161
6162 /*******************************************************************
6163  *
6164  * @brief Function to free MacLcCfg
6165  *
6166  * @details
6167  *
6168  *    Function : freeMacLcCfg
6169  *
6170  *    Functionality: Function to free MacLcCfg
6171  *
6172  * @params[in] LcCfg *lcCfg,
6173  * @return void
6174  *
6175  * ****************************************************************/
6176
6177 void  freeMacLcCfg(LcCfg *lcCfg)
6178 {
6179     /* Deleting DRBQOS */
6180    if(lcCfg->drbQos)
6181    {
6182       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
6183    }
6184    /* Deleting SNSSAI */
6185    if(lcCfg->snssai)
6186    {
6187       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6188    }
6189 }
6190 /*******************************************************************
6191  *
6192  * @brief Free UE NR Capability received in UE Context setup request
6193  *
6194  * @details
6195  *
6196  *    Function : freeAperDecodeUeNrCapability
6197  *
6198  *    Functionality:
6199  *       Free UE NR Capability received in UE Context setup request
6200  *
6201  * @params[in]
6202  * @return ROK     - success
6203  *         RFAILED - failure
6204  *
6205  * ****************************************************************/
6206 void freeAperDecodeUeNrCapability(void *ueNrCapability)
6207 {
6208    uint8_t arrIdx =0;
6209    FeatureSets_t *featureSets =NULLP;
6210    UE_NR_Capability_t *ueNrCap = (UE_NR_Capability_t *)ueNrCapability;
6211
6212    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
6213    {
6214       for(arrIdx = 0; arrIdx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; arrIdx++)
6215       {
6216          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx])
6217             free(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx]);
6218       }
6219       free(ueNrCap->rf_Parameters.supportedBandListNR.list.array);
6220    }
6221
6222    if(ueNrCap->featureSets)
6223    {
6224       featureSets = ueNrCap->featureSets;
6225       if(featureSets->featureSetsDownlinkPerCC)
6226       {
6227          if(featureSets->featureSetsDownlinkPerCC->list.array)
6228          {
6229             for(arrIdx = 0; arrIdx < featureSets->featureSetsDownlinkPerCC->list.count; arrIdx++)
6230             {
6231                if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx])
6232                {
6233                   if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL)
6234                      free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL);
6235                   free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]);
6236                }
6237             }
6238             free(featureSets->featureSetsDownlinkPerCC->list.array);
6239          }
6240          free(featureSets->featureSetsDownlinkPerCC);
6241       }
6242       if(featureSets->featureSetsUplinkPerCC)
6243       {
6244          if(featureSets->featureSetsUplinkPerCC->list.array)
6245          {
6246             for(arrIdx = 0; arrIdx < featureSets->featureSetsUplinkPerCC->list.count; arrIdx++)
6247             {
6248                if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx])
6249                {
6250                   if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL)
6251                      free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL);
6252                   free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]);
6253                }
6254             }
6255             free(featureSets->featureSetsUplinkPerCC->list.array);
6256          }
6257          free(featureSets->featureSetsUplinkPerCC);
6258       }
6259       free(ueNrCap->featureSets);
6260    }
6261 }
6262
6263 /*******************************************************************
6264 *
6265 * @brief Function to free PdcchSearchSpcToAddModList
6266          where memory allocated by aper_decoder
6267 *
6268 * @details
6269 *
6270 *    Function : freeAperDecodePdcchSearchSpcToAddModList
6271 *
6272 *    Functionality: Function to free PdcchSearchSpcToAddModList
6273 *
6274 * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
6275 * @return void
6276 *
6277 * ****************************************************************/
6278
6279 void freeAperDecodePdcchSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
6280 {
6281    uint8_t searchSpcArrIdx=0;
6282    uint8_t searchSpcArrIdx1=0;
6283    struct  SearchSpace *searchSpc=NULLP;
6284
6285
6286    if(searchSpcList->list.array)
6287    {
6288       if(searchSpcList->list.array[searchSpcArrIdx1])
6289       {
6290          searchSpc = searchSpcList->list.array[searchSpcArrIdx1];
6291          if(searchSpc->controlResourceSetId)
6292          {
6293             if(searchSpc->monitoringSlotPeriodicityAndOffset)
6294             {
6295                if(searchSpc->monitoringSymbolsWithinSlot)
6296                {
6297                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
6298                   {
6299                      if(searchSpc->nrofCandidates)
6300                      {
6301                         if(searchSpc->searchSpaceType)
6302                         {
6303                            free(searchSpc->searchSpaceType->choice.ue_Specific);
6304                            free(searchSpc->searchSpaceType);
6305                         }
6306                         free(searchSpc->nrofCandidates);
6307                      }
6308                      free(searchSpc->monitoringSymbolsWithinSlot->buf);
6309                   }
6310                   free(searchSpc->monitoringSymbolsWithinSlot);
6311                }
6312                free(searchSpc->monitoringSlotPeriodicityAndOffset);
6313             }
6314             free(searchSpc->controlResourceSetId);
6315          }
6316       }
6317       for(searchSpcArrIdx = 0; searchSpcArrIdx < searchSpcList->list.count; searchSpcArrIdx++)
6318       {
6319          free(searchSpcList->list.array[searchSpcArrIdx]);
6320       }
6321       free(searchSpcList->list.array);
6322    }
6323 }
6324 /*******************************************************************
6325 *
6326 * @brief Function for free part for the memory allocated by aper_decoder
6327 *
6328 * @details
6329 *
6330 *    Function : freeAperDecodeBWPDlDedPdcchConfig
6331 *
6332 *    Functionality: Function to free BWPDlDedPdcchConfig
6333 *
6334 * @params[in]
6335 * @return void
6336 *
6337 * ****************************************************************/
6338
6339
6340 void freeAperDecodeBWPDlDedPdcchConfig(BWP_DownlinkDedicated_t *dlBwp)
6341 {
6342    uint8_t arrIdx1=0;
6343    uint8_t arrIdx2=0;
6344    struct PDCCH_Config *pdcchCfg=NULLP;
6345    struct ControlResourceSet *controlRSet=NULLP;
6346    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
6347
6348    if(dlBwp->pdcch_Config->choice.setup)
6349    {
6350       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
6351       if(pdcchCfg->controlResourceSetToAddModList)
6352       {
6353          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
6354          if(controlRSetList->list.array)
6355          {
6356             controlRSet = controlRSetList->list.array[arrIdx2];
6357             if(controlRSet)
6358             {
6359                if(controlRSet->frequencyDomainResources.buf)
6360                {
6361                   if(controlRSet->pdcch_DMRS_ScramblingID)
6362                   {
6363                      if(pdcchCfg->searchSpacesToAddModList)
6364                      {
6365                         freeAperDecodePdcchSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
6366                         free(pdcchCfg->searchSpacesToAddModList);
6367                      }
6368                      free(controlRSet->pdcch_DMRS_ScramblingID);
6369                   }
6370                   free(controlRSet->frequencyDomainResources.buf);
6371                }
6372             }
6373             for(arrIdx1 = 0; arrIdx1 <controlRSetList->list.count; arrIdx1++)
6374             {
6375                free(controlRSetList->list.array[arrIdx1]);
6376             }
6377             free(controlRSetList->list.array);
6378          }
6379          free(pdcchCfg->controlResourceSetToAddModList);
6380       }
6381       free(dlBwp->pdcch_Config->choice.setup);
6382    }
6383 }
6384 /*******************************************************************
6385 *
6386 * @brief Function to free PdschTimeDomAllocationList
6387 *     where the memory allocated by aper_decoder
6388 *
6389 * @details
6390 *
6391 *    Function : freeAperDecodePdschTimeDomAllocationList
6392 *
6393 *    Functionality: Function to free PdschTimeDomAllocationList
6394 *
6395 * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
6396 * @return void
6397 *
6398 * ****************************************************************/
6399
6400
6401 void freeAperDecodePdschTimeDomAllocationList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
6402 {
6403    uint8_t arrIdx=0;
6404
6405    if(timeDomAllocList->choice.setup)
6406    {
6407       if(timeDomAllocList->choice.setup->list.array)
6408       {
6409          for(arrIdx = 0; arrIdx <timeDomAllocList->choice.setup->list.count ; arrIdx++)
6410          {
6411             free(timeDomAllocList->choice.setup->list.array[arrIdx]);
6412          }
6413          free(timeDomAllocList->choice.setup->list.array);
6414       }
6415       free(timeDomAllocList->choice.setup);
6416    }
6417 }
6418
6419 /*******************************************************************
6420 *
6421 * @brief Function to free BWPDlDedPdschConfig
6422 *        where the memory allocated by aper_decoder
6423 *
6424 * @details
6425 *
6426 *    Function : freeAperDecodeBWPDlDedPdschConfig
6427 *
6428 *    Functionality: Function to free BWPDlDedPdschConfig
6429 *
6430 * @params[in] BWP_DownlinkDedicated_t *dlBwp
6431 * @return void
6432 *
6433 * ****************************************************************/
6434
6435
6436 void freeAperDecodeBWPDlDedPdschConfig(BWP_DownlinkDedicated_t *dlBwp)
6437 {
6438    struct PDSCH_Config *pdschCfg=NULLP;
6439    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
6440    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
6441    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
6442
6443    if(dlBwp->pdsch_Config->choice.setup)
6444    {
6445       pdschCfg=dlBwp->pdsch_Config->choice.setup;
6446       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
6447       {
6448          if(pdschCfg->pdsch_TimeDomainAllocationList)
6449          {
6450             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
6451             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
6452             {
6453                prbBndlType=&pdschCfg->prb_BundlingType;
6454                free(prbBndlType->choice.staticBundling);
6455                free(pdschCfg->maxNrofCodeWordsScheduledByDCI);
6456             }
6457             freeAperDecodePdschTimeDomAllocationList(timeDomAllocList);
6458             free(pdschCfg->pdsch_TimeDomainAllocationList);
6459          }
6460          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
6461          if(dmrsDlCfg->choice.setup)
6462          {
6463             free(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition);
6464             free(dmrsDlCfg->choice.setup);
6465          }
6466          free(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA);
6467       }
6468       free(dlBwp->pdsch_Config->choice.setup);
6469    }
6470 }
6471 /*******************************************************************
6472 *
6473 * @brief Function to free PuschTimeDomAllocListCfg
6474                  where the memory allocated by aper_decoder
6475 *
6476 * @details
6477 *
6478 *    Function : freeAperDecodePuschTimeDomAllocListCfg
6479 *
6480 *    Functionality: Function to free PuschTimeDomAllocListCfg
6481 *
6482 * @params[in] PUSCH_Config_t *puschCfg
6483 * @return void
6484 *
6485 * ****************************************************************/
6486
6487
6488 void freeAperDecodePuschTimeDomAllocListCfg(PUSCH_Config_t *puschCfg)
6489 {
6490    uint8_t arrIdx=0;
6491    uint8_t arrIdx1=0;
6492    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
6493
6494    if(puschCfg->pusch_TimeDomainAllocationList)
6495    {
6496       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
6497       if(timeDomAllocList_t->choice.setup)
6498       {
6499          if(timeDomAllocList_t->choice.setup->list.array)
6500          {
6501             free(timeDomAllocList_t->choice.setup->list.array[arrIdx1]->k2);
6502             for(arrIdx = 0; arrIdx<timeDomAllocList_t->choice.setup->list.count; arrIdx++)
6503             {
6504                free(timeDomAllocList_t->choice.setup->list.array[arrIdx]);
6505             }
6506             free(timeDomAllocList_t->choice.setup->list.array);
6507          }
6508          free(timeDomAllocList_t->choice.setup);
6509       }
6510       free(puschCfg->transformPrecoder);
6511       free(puschCfg->pusch_TimeDomainAllocationList);
6512    }
6513 }
6514 /*******************************************************************
6515 *
6516 * @brief Function to free InitialUlBWPConfig where memory allocated by aper_decoder
6517 *
6518 * @details
6519 *
6520 *    Function : freeAperDecodeInitialUlBWPConfig
6521 *
6522 *    Functionality: Function to free InitialUlBWPConfig
6523 *
6524 * @params[in]  BWP_UplinkDedicated_t *ulBwp
6525 * @return void
6526 *
6527 * ****************************************************************/
6528
6529
6530 void freeAperDecodeInitialUlBWPConfig(BWP_UplinkDedicated_t *ulBwp)
6531 {
6532    uint8_t  rSetIdx =0;
6533    uint8_t  rsrcIdx =0;
6534    SRS_Config_t   *srsCfg = NULLP;
6535    PUSCH_Config_t *puschCfg = NULLP;
6536    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
6537    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
6538    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
6539    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
6540
6541    if(ulBwp->pusch_Config)
6542    {
6543       if(ulBwp->pusch_Config->choice.setup)
6544       {
6545          puschCfg=ulBwp->pusch_Config->choice.setup;
6546          if(puschCfg->dataScramblingIdentityPUSCH)
6547          {
6548             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
6549             {
6550                freeAperDecodePuschTimeDomAllocListCfg(puschCfg);
6551                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
6552                if(dmrsUlCfg->choice.setup)
6553                {
6554                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
6555                   {
6556                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
6557                      {
6558                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0);
6559                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled);
6560                      }
6561                      free(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition);
6562                   }
6563                   free(dmrsUlCfg->choice.setup);
6564                }
6565                free(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA);
6566             }
6567             free(puschCfg->dataScramblingIdentityPUSCH);
6568          }
6569          free(ulBwp->pusch_Config->choice.setup);
6570       }
6571       free(ulBwp->pusch_Config);
6572
6573       /* Free SRS-Config */
6574       if(ulBwp->srs_Config)
6575       {
6576          if(ulBwp->srs_Config->choice.setup)
6577          {
6578             srsCfg = ulBwp->srs_Config->choice.setup;
6579
6580             /* Free Resource Set to add/mod list */
6581             if(srsCfg->srs_ResourceSetToAddModList)
6582             {
6583                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
6584                if(rsrcSetList->list.array)
6585                {
6586                   rSetIdx = 0;
6587
6588                   /* Free SRS resource Id list in this SRS resource set */
6589                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
6590                   {
6591                      rsrcIdList =
6592                         rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
6593
6594                      if(rsrcIdList->list.array)
6595                      {
6596                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count;
6597                               rsrcIdx++)
6598                         {
6599                            free(rsrcIdList->list.array[rsrcIdx]);
6600                         }
6601                         free(rsrcIdList->list.array);
6602                      }
6603                      free(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList);
6604                   }
6605
6606                   /* Free resource type info for this SRS resource set */
6607
6608                   free(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic);
6609
6610                   /* Free memory for each resource set */
6611                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
6612                   {
6613                      free(rsrcSetList->list.array[rSetIdx]);
6614                   }
6615                   free(rsrcSetList->list.array);
6616                }
6617                free(srsCfg->srs_ResourceSetToAddModList);
6618             }
6619
6620             /* Free resource to add/modd list */
6621             if(srsCfg->srs_ResourceToAddModList)
6622             {
6623                resourceList = srsCfg->srs_ResourceToAddModList;
6624                if(resourceList->list.array)
6625                {
6626                   rsrcIdx = 0;
6627
6628                   free(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2);
6629                   free(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic);
6630
6631                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
6632                   {
6633                      free(resourceList->list.array[rsrcIdx]);
6634                   }
6635                   free(resourceList->list.array);
6636                }
6637                free(srsCfg->srs_ResourceToAddModList);
6638             }
6639
6640             free(ulBwp->srs_Config->choice.setup);
6641          }
6642          free(ulBwp->srs_Config);
6643       }
6644    }
6645 }
6646 /*******************************************************************
6647 *
6648 * @brief Function to free initialUplinkBWPConfig where memory allocated by aper_decoder
6649 *
6650 * @details
6651 *
6652 *    Function : freeAperDecodeinitialUplinkBWPConfig
6653 *
6654 *    Functionality: Function to free initialUplinkBWPConfig
6655 *
6656 * @params[in] UplinkConfig_t *ulCfg
6657 * @return void
6658 *
6659 * ****************************************************************/
6660
6661
6662 void freeAperDecodeinitialUplinkBWPConfig(UplinkConfig_t *ulCfg)
6663 {
6664    BWP_UplinkDedicated_t *ulBwp=NULLP;
6665    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
6666
6667    if(ulCfg->initialUplinkBWP)
6668    {
6669       ulBwp=ulCfg->initialUplinkBWP;
6670       if(ulCfg->firstActiveUplinkBWP_Id)
6671       {
6672          if(ulCfg->pusch_ServingCellConfig)
6673          {
6674             puschCfg=ulCfg->pusch_ServingCellConfig;
6675             if(puschCfg->choice.setup)
6676             {
6677                if(puschCfg->choice.setup->ext1)
6678                {
6679                   free(puschCfg->choice.setup->ext1->processingType2Enabled);
6680                   free(puschCfg->choice.setup->ext1->maxMIMO_Layers);
6681                   free(puschCfg->choice.setup->ext1);
6682                }
6683                free(puschCfg->choice.setup);
6684             }
6685             free(ulCfg->pusch_ServingCellConfig);
6686          }
6687          free(ulCfg->firstActiveUplinkBWP_Id);
6688       }
6689       freeAperDecodeInitialUlBWPConfig(ulBwp);
6690       free(ulCfg->initialUplinkBWP);
6691    }
6692 }
6693
6694 /*******************************************************************
6695  *
6696  * @brief Function to free DuUeCfg
6697  *
6698  * @details
6699  *
6700  *    Function : freeDuUeCfg
6701  *
6702  *    Functionality: Function to free DuUeCfg
6703  *
6704  * @params[in] DuUeCfg *ueCfg
6705  * @return void
6706  *
6707  * ****************************************************************/
6708 void freeDuUeCfg(DuUeCfg *ueCfg)
6709 {
6710    uint8_t lcIdx = 0;
6711    uint8_t arrIdx = 0;
6712    SpCellConfig_t *spCellCfg = NULLP;
6713    ServingCellConfig_t *srvCellCfg = NULLP;
6714    BWP_DownlinkDedicated_t *dlBwp = NULLP;
6715    MAC_CellGroupConfig_t *macCellGrpCfg = NULLP;
6716    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
6717    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList = NULLP;
6718    struct RLC_Config *rlcConfig = NULLP;
6719    struct LogicalChannelConfig *macLcConfig = NULLP;
6720    struct SchedulingRequestConfig *schedulingRequestConfig = NULLP;
6721    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList = NULLP;
6722    struct TAG_Config *tagConfig = NULLP;
6723    struct TAG_Config__tag_ToAddModList *tagList = NULLP;
6724    struct MAC_CellGroupConfig__phr_Config *phrConfig = NULLP;
6725    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg = NULLP;
6726    CellGroupConfigRrc_t *cellGrpCfg = ueCfg->cellGrpCfg;
6727
6728    if(ueCfg->ueNrCapability)
6729    {
6730       freeAperDecodeUeNrCapability(ueCfg->ueNrCapability);
6731       DU_FREE(ueCfg->ueNrCapability, sizeof(UE_NR_Capability_t));
6732       ueCfg->ueNrCapability = NULLP;
6733    }
6734
6735    if(ueCfg->cellGrpCfg)
6736    {
6737
6738       rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6739       if(rlcBearerList)
6740       {
6741          if(rlcBearerList->list.array)
6742          {
6743             for(arrIdx=0; arrIdx<rlcBearerList->list.count; arrIdx++)
6744             {
6745                if(rlcBearerList->list.array[arrIdx])
6746                {
6747                   rlcConfig   = rlcBearerList->list.array[arrIdx]->rlc_Config;
6748                   macLcConfig = rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig;
6749
6750                   if(rlcBearerList->list.array[arrIdx]->servedRadioBearer)
6751                   {
6752                      free(rlcBearerList->list.array[arrIdx]->servedRadioBearer);
6753                   }
6754                   if(rlcConfig)
6755                   {
6756                      if(rlcConfig->choice.am)
6757                      {
6758                         free(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength);
6759                         free(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength);
6760                         free(rlcConfig->choice.am);
6761                      }
6762                      free(rlcBearerList->list.array[arrIdx]->rlc_Config);
6763                   }
6764                   if(macLcConfig)
6765                   {
6766                      if(macLcConfig->ul_SpecificParameters)
6767                      {
6768                         free(macLcConfig->ul_SpecificParameters->schedulingRequestID);
6769                         free(macLcConfig->ul_SpecificParameters->logicalChannelGroup);
6770                         free(macLcConfig->ul_SpecificParameters);
6771                      }
6772                      free(rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig);
6773                   }
6774                   free(rlcBearerList->list.array[arrIdx]);
6775                }
6776             }
6777             free(rlcBearerList->list.array);
6778          }
6779          free(cellGrpCfg->rlc_BearerToAddModList);
6780       }
6781
6782       macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
6783       if(macCellGrpCfg)
6784       {
6785          schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
6786          if(schedulingRequestConfig)
6787          {
6788             schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
6789             if(schReqList)
6790             {
6791                if(schReqList->list.array)
6792                {
6793                   for(arrIdx=0;arrIdx<schReqList->list.count; arrIdx++)
6794                   {
6795                      if(schReqList->list.array[arrIdx])
6796                      {
6797                         free(schReqList->list.array[arrIdx]->sr_ProhibitTimer);
6798                         free(schReqList->list.array[arrIdx]);
6799                      }
6800                   }
6801                   free(schReqList->list.array);
6802                }
6803                free(schedulingRequestConfig->schedulingRequestToAddModList);
6804             }
6805             free(macCellGrpCfg->schedulingRequestConfig);
6806          }
6807          if(macCellGrpCfg->bsr_Config)
6808          {
6809             free(macCellGrpCfg->bsr_Config);
6810          }
6811          tagConfig = macCellGrpCfg->tag_Config;
6812          if(tagConfig)
6813          {
6814             tagList = tagConfig->tag_ToAddModList;
6815             if(tagList)
6816             {
6817                if(tagList->list.array)
6818                {
6819                   for(arrIdx=0; arrIdx<tagList->list.count; arrIdx++)
6820                   {
6821                      free(tagList->list.array[arrIdx]);
6822                   }
6823                   free(tagList->list.array);
6824                }
6825                free(tagConfig->tag_ToAddModList);
6826             }
6827             free(tagConfig);
6828          }
6829
6830          phrConfig = macCellGrpCfg->phr_Config;
6831          if(phrConfig)
6832          {
6833             free(phrConfig->choice.setup);
6834             free(phrConfig);
6835          }
6836
6837          free(macCellGrpCfg);
6838       }
6839
6840       phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
6841       if(phyCellGrpCfg)
6842       {
6843          free(phyCellGrpCfg->p_NR_FR1);
6844          free(phyCellGrpCfg);
6845       }
6846
6847       spCellCfg = cellGrpCfg->spCellConfig;
6848       if(spCellCfg)
6849       {
6850          if(spCellCfg->servCellIndex)
6851          {
6852             if(spCellCfg->rlmInSyncOutOfSyncThreshold)
6853             {
6854                if(spCellCfg->spCellConfigDedicated)
6855                {
6856                   srvCellCfg = spCellCfg->spCellConfigDedicated;
6857                   if(srvCellCfg->initialDownlinkBWP)
6858                   {
6859                      dlBwp = srvCellCfg->initialDownlinkBWP;
6860                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
6861                      {
6862                         if(srvCellCfg->defaultDownlinkBWP_Id)
6863                         {
6864                            if(srvCellCfg->uplinkConfig)
6865                            {
6866
6867                               if(srvCellCfg->pdsch_ServingCellConfig)
6868                               {
6869                                  pdschCfg=
6870                                     srvCellCfg->pdsch_ServingCellConfig;
6871                                  if(pdschCfg->choice.setup)
6872                                  {
6873
6874                                     free(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH);
6875                                     free(pdschCfg->choice.setup);
6876                                  }
6877
6878                                  free(srvCellCfg->pdsch_ServingCellConfig);
6879                               }
6880
6881                               freeAperDecodeinitialUplinkBWPConfig(srvCellCfg->uplinkConfig);
6882                               free(srvCellCfg->uplinkConfig);
6883                            }
6884                            free(srvCellCfg->defaultDownlinkBWP_Id);
6885                         }
6886
6887                         free(srvCellCfg->firstActiveDownlinkBWP_Id);
6888                      }
6889                      if(dlBwp->pdcch_Config)
6890                      {
6891                         if(dlBwp->pdsch_Config)
6892                         {
6893                            freeAperDecodeBWPDlDedPdschConfig(dlBwp);
6894                            free(dlBwp->pdsch_Config);
6895                         }
6896                         freeAperDecodeBWPDlDedPdcchConfig(dlBwp);
6897                         free(dlBwp->pdcch_Config);
6898                      }
6899                      free(srvCellCfg->initialDownlinkBWP);
6900                   }
6901
6902                   free(spCellCfg->spCellConfigDedicated);
6903                }
6904                free(spCellCfg->rlmInSyncOutOfSyncThreshold);
6905             }
6906             free(spCellCfg->servCellIndex);
6907          }
6908          free(spCellCfg);
6909       }
6910       DU_FREE(ueCfg->cellGrpCfg, sizeof(CellGroupConfigRrc_t));
6911       ueCfg->cellGrpCfg = NULLP;
6912    }
6913    if(ueCfg->ambrCfg)
6914    {
6915       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->ambrCfg, sizeof(AmbrCfg));
6916    }
6917    for(lcIdx = 0; lcIdx < ueCfg->numRlcLcs; lcIdx++)
6918    {
6919       freeRlcLcCfg(&ueCfg->rlcLcCfg[lcIdx]);
6920    }
6921    for(lcIdx = 0; lcIdx < ueCfg->numMacLcs; lcIdx++)
6922    {
6923       freeMacLcCfg(&ueCfg->macLcCfg[lcIdx]);
6924    }
6925    for(lcIdx = 0; lcIdx < ueCfg->numDrb; lcIdx++)
6926    {
6927       DU_FREE(ueCfg->upTnlInfo[lcIdx].tnlCfg1, sizeof(GtpTnlCfg));
6928    }
6929 }
6930
6931 /*******************************************************************
6932  *
6933  * @brief Function to free UecontextSetupDb
6934  *
6935  * @details
6936  *
6937  *    Function : freeF1UeDb
6938  *
6939  *    Functionality: Function to free UecontextSetupDb
6940  *
6941  * @params[in] UecontextSetupDb *
6942  * @return void
6943  *
6944  * ****************************************************************/
6945
6946 void freeF1UeDb(F1UeContextSetupDb *f1UeDb)
6947 {
6948
6949    if(f1UeDb->dlRrcMsg)
6950    {
6951       if(f1UeDb->dlRrcMsg->rrcMsgPdu)
6952       {
6953         //DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,\
6954                f1UeDb->dlRrcMsg->rrcMsgPdu, f1UeDb->dlRrcMsg->rrcMsgSize);
6955       }
6956       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
6957    }
6958    freeDuUeCfg(&f1UeDb->duUeCfg);
6959    memset(f1UeDb, 0, sizeof(F1UeContextSetupDb));
6960    DU_FREE(f1UeDb, sizeof(F1UeContextSetupDb));
6961 }
6962
6963 /*******************************************************************
6964  *
6965  * @brief Function to build Am cfg Info
6966  *
6967  * @details
6968  *
6969  *    Function : extractRlcAmCfg
6970  *
6971  *    Functionality: Function to build Am cfg Info
6972  *
6973  * @params[in] AmBearerCfg *
6974  *             void *
6975  *
6976  * @return ROK/RFAILED
6977  *
6978  * ****************************************************************/
6979
6980 void extractRlcAmCfg(AmBearerCfg *amCfgToSet, struct RLC_Config__am *rlcAmCfg)
6981 {
6982    if(rlcAmCfg)
6983    {
6984       /* UL AM */
6985       if(rlcAmCfg->dl_AM_RLC.sn_FieldLength)
6986       {
6987          amCfgToSet->ulAmCfg.snLenUl = *(rlcAmCfg->dl_AM_RLC.sn_FieldLength);
6988          /*TODO: Check the timer value when sent by real CU */
6989          amCfgToSet->ulAmCfg.reAssemTmr = rlcAmCfg->dl_AM_RLC.t_Reassembly;
6990          amCfgToSet->ulAmCfg.statProhTmr = rlcAmCfg->dl_AM_RLC.t_StatusProhibit;
6991       }
6992
6993       /* DL AM */
6994       if(rlcAmCfg->ul_AM_RLC.sn_FieldLength)
6995       {
6996          amCfgToSet->dlAmCfg.snLenDl = *(rlcAmCfg->ul_AM_RLC.sn_FieldLength);
6997          amCfgToSet->dlAmCfg.pollRetxTmr = rlcAmCfg->ul_AM_RLC.t_PollRetransmit;
6998          amCfgToSet->dlAmCfg.pollPdu   = rlcAmCfg->ul_AM_RLC.pollPDU;
6999          amCfgToSet->dlAmCfg.pollByte  = rlcAmCfg->ul_AM_RLC.pollByte;
7000          amCfgToSet->dlAmCfg.maxRetxTh = rlcAmCfg->ul_AM_RLC.maxRetxThreshold;
7001       }
7002    }
7003 }
7004
7005 /*******************************************************************
7006  *
7007  * @brief Function to build Um Bi Info
7008  *
7009  * @details
7010  *
7011  *    Function : extractRlcUmBiCfg
7012  *
7013  *    Functionality: Function to build Um Bi Info
7014  *
7015  * @params[in] UmBiDirBearerCfg *
7016  *             void *
7017  *
7018  * @return ROK/RFAILED
7019  *
7020  * ****************************************************************/
7021
7022 void extractRlcUmBiCfg(UmBiDirBearerCfg *umBiCfgToSet, struct RLC_Config__um_Bi_Directional *rlcBiCfg)
7023 {
7024    if(rlcBiCfg)
7025    {
7026       /* UL UM BI DIR Cfg */
7027       if(rlcBiCfg->dl_UM_RLC.sn_FieldLength)
7028       {
7029          umBiCfgToSet->ulUmCfg.snLenUlUm  = *(rlcBiCfg->dl_UM_RLC.sn_FieldLength);
7030          umBiCfgToSet->ulUmCfg.reAssemTmr = rlcBiCfg->dl_UM_RLC.t_Reassembly;
7031       }
7032
7033       /* DL UM BI DIR Cfg */
7034       if(rlcBiCfg->ul_UM_RLC.sn_FieldLength)
7035          umBiCfgToSet->dlUmCfg.snLenDlUm  = *(rlcBiCfg->ul_UM_RLC.sn_FieldLength);
7036    }
7037 }
7038
7039 /*******************************************************************
7040  *
7041  * @brief Function to build Um Ul Info
7042  *
7043  * @details
7044  *
7045  *    Function : extractRlcUmUlCfg
7046  *
7047  *    Functionality: Function to build Um Ul Info
7048  *
7049  * @params[in] UmUniDirUlBearerCfg *
7050  *             void *
7051  *
7052  * @return ROK/RFAILED
7053  *
7054  * ****************************************************************/
7055
7056 void extractRlcUmUlCfg(UmUniDirUlBearerCfg *umUlCfgToSet, struct RLC_Config__um_Uni_Directional_DL *umUlCfg)
7057 {
7058    if(umUlCfg)
7059    {
7060       if(umUlCfg->dl_UM_RLC.sn_FieldLength)
7061       {
7062          umUlCfgToSet->ulUmCfg.snLenUlUm  = *(umUlCfg->dl_UM_RLC.sn_FieldLength);
7063          umUlCfgToSet->ulUmCfg.reAssemTmr = umUlCfg->dl_UM_RLC.t_Reassembly;
7064       }
7065    }
7066 }
7067
7068 /*******************************************************************
7069  *
7070  * @brief Function to build Um Uni Dl Info
7071  *
7072  * @details
7073  *
7074  *    Function : extractRlcUmDlCfg
7075  *
7076  *    Functionality: Function to build Um Uni Dl Info
7077  *
7078  * @params[in] UmUniDirDlBearerCfg *
7079  *             void *
7080  *
7081  * @return ROK/RFAILED
7082  *
7083  * ****************************************************************/
7084 void extractRlcUmDlCfg(UmUniDirDlBearerCfg *umDlCfgToSet, struct RLC_Config__um_Uni_Directional_UL *umDlCfg)
7085 {
7086    if(umDlCfg)
7087    {
7088       if(umDlCfg->ul_UM_RLC.sn_FieldLength)
7089          umDlCfgToSet->dlUmCfg.snLenDlUm  = *(umDlCfg->ul_UM_RLC.sn_FieldLength);
7090    }
7091 }
7092
7093 /*******************************************************************
7094  *
7095  * @brief Function to extractRlcModeCfg
7096  *
7097  * @details
7098  *
7099  *    Function : extractRlcModeCfg
7100  *
7101  *    Functionality: Function to extractRlcModeCfg
7102  *
7103  * @params[in] RLC_Config_t *
7104  *             RlcBearerCfg *
7105  *             void  *
7106  * @return ROK/RFAILED
7107  *
7108  * ****************************************************************/
7109 void extractRlcModeCfg(uint8_t rlcMode, RlcBearerCfg *rlcDbCfg, RLC_Config_t *lcCfg)
7110 {
7111    if(lcCfg)
7112    {
7113       switch(rlcMode)
7114       {
7115          case RLC_AM :
7116             {
7117                if(lcCfg->choice.am)
7118                {
7119                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.amCfg, sizeof(AmBearerCfg));
7120                   if(rlcDbCfg->u.amCfg)
7121                      extractRlcAmCfg(rlcDbCfg->u.amCfg, lcCfg->choice.am);
7122                }
7123                break;
7124             }
7125          case RLC_UM_BI_DIRECTIONAL :
7126             {
7127                if(lcCfg->choice.um_Bi_Directional)
7128                {
7129                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
7130                   if(rlcDbCfg->u.umBiDirCfg)
7131                      extractRlcUmBiCfg(rlcDbCfg->u.umBiDirCfg, lcCfg->choice.um_Bi_Directional);
7132                }
7133                break;
7134             }
7135          case RLC_UM_UNI_DIRECTIONAL_UL :
7136             {
7137                if(lcCfg->choice.um_Uni_Directional_DL)
7138                {
7139                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
7140                   if(rlcDbCfg->u.umUniDirUlCfg)
7141                      extractRlcUmUlCfg(rlcDbCfg->u.umUniDirUlCfg, lcCfg->choice.um_Uni_Directional_DL);
7142                }
7143                break;
7144             }
7145          case RLC_UM_UNI_DIRECTIONAL_DL :
7146             {
7147                if(lcCfg->choice.um_Uni_Directional_UL)
7148                {
7149                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
7150                   if(rlcDbCfg->u.umUniDirDlCfg)
7151                      extractRlcUmDlCfg(rlcDbCfg->u.umUniDirDlCfg, lcCfg->choice.um_Uni_Directional_UL);
7152                }
7153                break;
7154             }
7155          default:
7156             DU_LOG("\nERROR  -->  DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
7157             break;
7158       }
7159    }
7160 }
7161
7162 /*******************************************************************
7163  *
7164  * @brief Function to extract extractUlLcCfg
7165  *
7166  * @details
7167  *
7168  *    Function : extractUlLcCfg
7169  *
7170  *    Functionality: Function to extract extractUlLcCfg
7171  *
7172  * @params[in] UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg
7173  * @return void
7174  *
7175  * ****************************************************************/
7176
7177 void extractUlLcCfg(UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg)
7178 {
7179    if(ulLcCfg)
7180    {
7181       if(ulLcCfg->ul_SpecificParameters)
7182       {
7183          f1UlLcCfg->priority = \
7184             ulLcCfg->ul_SpecificParameters->priority;
7185       if(ulLcCfg->ul_SpecificParameters->logicalChannelGroup)
7186       {
7187          f1UlLcCfg->lcGroup = \
7188            *(ulLcCfg->ul_SpecificParameters->logicalChannelGroup);
7189       }
7190       if(ulLcCfg->ul_SpecificParameters->schedulingRequestID)
7191       {
7192          f1UlLcCfg->schReqId = \
7193            *(ulLcCfg->ul_SpecificParameters->schedulingRequestID);
7194       }
7195       f1UlLcCfg->pbr = \
7196          ulLcCfg->ul_SpecificParameters->prioritisedBitRate;
7197       f1UlLcCfg->bsd = \
7198          ulLcCfg->ul_SpecificParameters->bucketSizeDuration;
7199       }
7200    }
7201 }
7202
7203 /*******************************************************************
7204  *
7205  * @brief Function to procRlcLcCfg
7206  *
7207  * @details
7208  *
7209  *    Function : procRlcLcCfg
7210  *
7211  *    Functionality: Function to procRlcLcCfg
7212  *
7213  * @params[in] rbId, lcId, rbType, rlcMod
7214  *             RLC_Config_t *, RlcBearerCfg * ,
7215  * @return void
7216  *
7217  * ****************************************************************/
7218
7219 void procRlcLcCfg(uint8_t rbId, uint8_t lcId, uint8_t rbType, uint8_t rlcMode,\
7220    uint8_t configType, RLC_Config_t *f1RlcCfg, RlcBearerCfg *lcCfg)
7221 {
7222
7223    lcCfg->rbId   = rbId;
7224    lcCfg->configType = configType;
7225
7226    if(rbType == RB_TYPE_SRB)
7227    {
7228       lcCfg->rbType = RB_TYPE_SRB;
7229       lcCfg->lcId   = rbId;
7230       lcCfg->lcType = LCH_DCCH;
7231       lcCfg->rlcMode = RLC_AM;
7232    }
7233    else if(rbType == RB_TYPE_DRB)
7234    {
7235       lcCfg->rbType = RB_TYPE_DRB;
7236       lcCfg->lcId   = lcId;
7237       lcCfg->lcType = LCH_DTCH;
7238       lcCfg->rlcMode = rlcMode;
7239    }
7240    if(f1RlcCfg) /* rlc mode config recived */
7241    {
7242       extractRlcModeCfg(lcCfg->rlcMode, lcCfg, f1RlcCfg);
7243    }
7244 }
7245
7246
7247
7248 /*******************************************************************
7249  *
7250  * @brief Fills DrbQos Info received by CU
7251  *
7252  * @details
7253  *
7254  *    Function : extractQosInfo
7255  *
7256  *    Functionality: Fills DrbQos Info received  by CU
7257  *
7258  * @params[in] DrbQosInfo *qosToAdd,
7259  *             QoSFlowLevelQoSParameters_t *qosFlowCfg
7260  * @return void
7261  *
7262  * ****************************************************************/
7263
7264 void extractQosInfo(DrbQosInfo *qosToAdd, QoSFlowLevelQoSParameters_t *qosFlowCfg)
7265 {
7266    qosToAdd->fiveQiType = qosFlowCfg->qoS_Characteristics.present;
7267    qosToAdd->u.nonDyn5Qi.fiveQi     =\
7268          qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
7269    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow)
7270    {
7271       qosToAdd->u.nonDyn5Qi.avgWindow = \
7272         *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
7273    }
7274    qosToAdd->u.nonDyn5Qi.maxDataBurstVol = \
7275       *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
7276    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel)
7277    {
7278       qosToAdd->u.nonDyn5Qi.priorLevel = \
7279          *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel);
7280    }
7281    qosToAdd->ngRanRetPri.priorityLevel = \
7282       qosFlowCfg->nGRANallocationRetentionPriority.priorityLevel;
7283    qosToAdd->ngRanRetPri.preEmptionCap = \
7284       qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionCapability;
7285    qosToAdd->ngRanRetPri.preEmptionVul = \
7286       qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionVulnerability;
7287    if(qosFlowCfg->gBR_QoS_Flow_Information)
7288    {
7289       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateDl, \
7290          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.buf, \
7291          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.size);
7292       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateUl, \
7293          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.buf, \
7294          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.size);
7295       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateDl,\
7296          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.buf, \
7297          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.size);
7298       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateUl,\
7299          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.buf, \
7300          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.size);
7301    }
7302    qosToAdd->pduSessionId = 0;
7303    qosToAdd->ulPduSessAggMaxBitRate = 0;
7304 }
7305
7306 /*******************************************************************
7307  *
7308  * @brief Function to extract GTP Tunnel Info from CU
7309  *
7310  * @details
7311  *
7312  *    Function : extractUpTnlInfo
7313  *
7314  *    Functionality: Function to extract GTP Tunnel Info from CU
7315  *
7316  * @params[in] F1AP message
7317  * @return ROK/RFAILED
7318  *
7319  * ****************************************************************/
7320
7321 uint8_t extractUpTnlInfo(uint8_t drbId, uint8_t configType,\
7322    ULUPTNLInformation_ToBeSetup_List_t *tnlInfo, UpTnlCfg *upTnlInfo)
7323 {
7324    uint8_t tnlIdx;
7325    uint32_t ipv4_du = 0;
7326    GTPTunnel_t *gtpTunnel = NULLP;
7327
7328    upTnlInfo->drbId = drbId;
7329    upTnlInfo->configType = configType;
7330 #ifdef O1_ENABLE
7331    cmInetAddr((S8*)g_cfg.DU_IPV4_Addr, &ipv4_du);
7332 #else
7333    cmInetAddr((char *)DU_IP_V4_ADDR, &ipv4_du);
7334 #endif
7335
7336    for(tnlIdx=0; tnlIdx < tnlInfo->list.count; tnlIdx++)
7337    {
7338       if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
7339       {
7340          if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel)
7341          {
7342             gtpTunnel = tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel;
7343             DU_ALLOC(upTnlInfo->tnlCfg1, sizeof(GtpTnlCfg));
7344             if(upTnlInfo->tnlCfg1 == NULLP)
7345             {
7346                DU_LOG("\nERROR  -->  F1AP : extractUpTnlInfo: Failed to allocate mmeory for tunnel cfg 1");
7347                return RFAILED;
7348             }
7349             bitStringToInt(&gtpTunnel->transportLayerAddress, &upTnlInfo->tnlCfg1->ulTnlAddress);
7350             upTnlInfo->tnlCfg1->dlTnlAddress = ipv4_du;
7351             if(gtpTunnel->gTP_TEID.size > 0)
7352             {
7353                teIdStringToInt(gtpTunnel->gTP_TEID.buf, &upTnlInfo->tnlCfg1->teId);
7354             }
7355          }
7356          break;
7357       }
7358    }
7359    return ROK;
7360 }
7361 /*******************************************************************
7362 *
7363 * @brief Function to extract Drb Qos Cfg Info from CU
7364 *
7365 * @details
7366 *
7367 *    Function : extractDrbQosCfg
7368 *
7369 *    Functionality: Function to extract Drb Qos Cfg Info from CU
7370 *
7371 * @params[in] DRB_Information_t *drbInfo, LcCfg *macLcToAdd
7372 * @return ROK/RFAILED
7373 *
7374 * ****************************************************************/
7375
7376 uint8_t extractDrbQosCfg(DRB_Information_t *drbInfo, LcCfg *macLcToAdd )
7377 {
7378    if(!macLcToAdd->drbQos)
7379    {
7380       DU_ALLOC_SHRABL_BUF(macLcToAdd->drbQos, sizeof(DrbQosInfo));
7381       if(macLcToAdd->drbQos == NULLP)
7382       {
7383          DU_LOG("\nERROR  -->  DUAPP:Memory failed at allocating DrbQos at extractDrbCfg()");
7384          return RFAILED;
7385       }
7386
7387    }
7388    if(drbInfo->dRB_QoS.qoS_Characteristics.present == QoS_Characteristics_PR_non_Dynamic_5QI)
7389    {
7390       extractQosInfo(macLcToAdd->drbQos, &drbInfo->dRB_QoS);
7391       macLcToAdd->dlLcCfg.lcp = macLcToAdd->drbQos->ngRanRetPri.priorityLevel;
7392    }
7393    if(!macLcToAdd->snssai)
7394    {
7395       DU_ALLOC_SHRABL_BUF(macLcToAdd->snssai, sizeof(Snssai));
7396       if(macLcToAdd->snssai == NULLP)
7397       {
7398          DU_LOG("\nERROR  -->  DUAPP : Memory failed at allocating SNSSAI at extractDrbCfg()");
7399          return RFAILED;
7400       }
7401    }
7402    memcpy(&macLcToAdd->snssai->sst, drbInfo->sNSSAI.sST.buf, \
7403          drbInfo->sNSSAI.sST.size);
7404    if(drbInfo->sNSSAI.sD)
7405    {
7406       memcpy(macLcToAdd->snssai->sd, drbInfo->sNSSAI.sD->buf, \
7407             drbInfo->sNSSAI.sD->size);
7408    }
7409    return ROK;
7410 }
7411 /*******************************************************************
7412  *
7413  * @brief Function to extract DRB info received from CU
7414  *
7415  * @details
7416  *
7417  *    Function : extractDrbCfg
7418  *
7419  *    Functionality: Function to extract DRB info received from CU
7420  *
7421  * @params[in] F1AP message
7422  * @return void
7423  *
7424  * ****************************************************************/
7425 uint8_t extractDrbCfg(DRBs_ToBeSetup_Item_t *drbItem,DRBs_ToBeSetupMod_Item_t *drbSetupModItem,\
7426 LcCfg *macLcToAdd, UpTnlCfg *upTnlInfo)
7427 {
7428    DRB_Information_t *drbInfo = NULLP;
7429
7430    if(drbItem != NULLP)
7431    {
7432       if(extractUpTnlInfo(drbItem->dRBID, CONFIG_ADD, &drbItem->uLUPTNLInformation_ToBeSetup_List, upTnlInfo) != ROK)
7433       {
7434          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7435          return RFAILED;
7436       }
7437       if(drbItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7438       {
7439          if(drbItem->qoSInformation.choice.choice_extension->value.present == QoSInformation_ExtIEs__value_PR_DRB_Information)
7440          {
7441             drbInfo = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7442             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7443             {
7444                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7445                return RFAILED;
7446             }
7447          }
7448       }
7449    }
7450    else if(drbSetupModItem != NULLP)
7451    {
7452       if(extractUpTnlInfo(drbSetupModItem->dRBID, CONFIG_ADD, &drbSetupModItem->uLUPTNLInformation_ToBeSetup_List,\
7453       upTnlInfo) != ROK)
7454       {
7455          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7456          return RFAILED;
7457       }
7458       if(drbSetupModItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7459       {
7460          if(drbSetupModItem->qoSInformation.choice.choice_extension->value.present ==\
7461          QoSInformation_ExtIEs__value_PR_DRB_Information)
7462          {
7463             drbInfo = &drbSetupModItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7464             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7465             {
7466                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7467                return RFAILED;
7468             }
7469
7470          }
7471       }
7472    }
7473
7474    return ROK;
7475 }
7476
7477 /*******************************************************************
7478  *
7479  * @brief Function to extract RB info received from CU
7480  *
7481  * @details
7482  *
7483  *    Function : extractMacRbCfg
7484  *
7485  *    Functionality: Function to extract RB info received from CU
7486  *
7487  * @params[in] F1AP message
7488  * @return ROK/RFAILED
7489  *
7490  * ****************************************************************/
7491
7492 uint8_t extractMacRbCfg(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbCfg,\
7493 DRBs_ToBeSetupMod_Item_t *drbSetupModCfg,  LogicalChannelConfig_t *ulLcCfg, LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7494 {
7495    if(drbCfg != NULLP)
7496    {
7497       if(extractDrbCfg(drbCfg, NULL, lcCfg, upTnlInfo) != ROK)
7498       {
7499          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7500          return RFAILED;
7501       }
7502    }
7503    else if(drbSetupModCfg != NULLP)
7504    {
7505       if(extractDrbCfg(NULL, drbSetupModCfg, lcCfg, upTnlInfo) != ROK)
7506       {
7507          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7508          return RFAILED;
7509       }
7510    }
7511    else
7512    {
7513       lcCfg->drbQos = NULLP;
7514       lcCfg->snssai = NULLP;
7515       if(lcCfg->lcId == SRB2_LCID)
7516          lcCfg->dlLcCfg.lcp = LC_PRIORITY_3;
7517       else
7518          lcCfg->dlLcCfg.lcp = LC_PRIORITY_1;
7519    }
7520    if(ulLcCfg)
7521    {
7522       lcCfg->ulLcCfgPres = true;
7523       extractUlLcCfg(&lcCfg->ulLcCfg, ulLcCfg);
7524    }
7525    else
7526       lcCfg->ulLcCfgPres = false;
7527    return ROK;
7528 }
7529
7530 /*******************************************************************
7531  *
7532  * @brief Function processing LC config info received from CU
7533  *
7534  * @details
7535  *
7536  *    Function : procMacLcCfg
7537  *
7538  *    Functionality: Function processing LC config info received from CU
7539  *
7540  * @params[in] F1AP message
7541  * @return ROK/RFAILED
7542  *
7543  * ****************************************************************/
7544
7545 uint8_t procMacLcCfg(uint8_t lcId, uint8_t rbType, uint8_t configType,\
7546 DRBs_ToBeSetup_Item_t *drbItem, DRBs_ToBeSetupMod_Item_t *drbSetupModItem, LogicalChannelConfig_t *ulLcCfg,\
7547 LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7548 {
7549    uint8_t ret = ROK;
7550
7551    lcCfg->lcId = lcId;
7552    lcCfg->configType = configType;
7553    if(rbType == RB_TYPE_SRB)
7554    {
7555       ret = extractMacRbCfg(lcId, NULL,NULL, ulLcCfg, lcCfg, NULL);
7556    }
7557    else if(rbType == RB_TYPE_DRB)
7558    {
7559       if(drbItem != NULL)
7560         ret = extractMacRbCfg(lcId, drbItem, NULL, ulLcCfg, lcCfg, upTnlInfo);
7561       else if(drbSetupModItem != NULL)
7562         ret = extractMacRbCfg(lcId, NULL, drbSetupModItem, ulLcCfg, lcCfg, upTnlInfo);
7563    }
7564    return ret;
7565 }
7566
7567 /*******************************************************************
7568  *
7569  * @brief Function to extract Rlc cfg To Add/Mod in CellGrp Info
7570  *
7571  * @details
7572  *
7573  *    Function : extractRlcCfgToAddMod
7574  *
7575  *    Functionality: Function to extract Rlc cfg To Add/Mod in CellGrp Info
7576  *
7577  * @params[in] CellGroupConfigRrc__rlc_BearerTo pointer
7578  *             DuUeCfg Pointer
7579  * @return ROK/RFAILED
7580  *
7581  * ****************************************************************/
7582
7583 uint8_t extractRlcCfgToAddMod(struct CellGroupConfigRrc__rlc_BearerToAddModList *lcCfg, DuUeCfg *ueCfgDb)
7584 {
7585   uint8_t idx, rbId, lcId, rlcMode, rbType;
7586   RLC_Config_t *f1RlcCfg = NULLP;
7587   LogicalChannelConfig_t *macUlLcCfg = NULLP;
7588
7589   for(idx = 0; idx < lcCfg->list.count; idx++)
7590   {
7591      lcId = lcCfg->list.array[idx]->logicalChannelIdentity;
7592      if(lcCfg->list.array[idx]->servedRadioBearer)
7593      {
7594         /* RadioBearer for SRB/DRB */
7595         if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7596         RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
7597         {
7598            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.srb_Identity;
7599            rbType = RB_TYPE_SRB;
7600         }
7601         else if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7602         RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
7603         {
7604            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.drb_Identity;
7605            rbType = RB_TYPE_DRB;
7606         }
7607         else
7608         {
7609            DU_LOG("\nERROR  -->  No components present in Bearer config to ADD/MOD");
7610            return RFAILED;
7611         }
7612         /* MAC UL LC Config */
7613         if(lcCfg->list.array[idx]->mac_LogicalChannelConfig)
7614         {
7615            macUlLcCfg = lcCfg->list.array[idx]->mac_LogicalChannelConfig;
7616         }
7617      }
7618      else
7619      {
7620         DU_LOG("\nERROR  -->  DUAPP: Received RadioBearer config is NULL");
7621         return RFAILED;
7622      }
7623      /* RLC Mode Config */
7624      if(lcCfg->list.array[idx]->rlc_Config)
7625      {
7626         rlcMode  = lcCfg->list.array[idx]->rlc_Config->present;
7627         f1RlcCfg = lcCfg->list.array[idx]->rlc_Config;
7628      }
7629
7630      /* Filling RLC/MAC Config*/
7631      memset(&ueCfgDb->macLcCfg[idx], 0, sizeof(LcCfg));
7632      memset(&ueCfgDb->rlcLcCfg[idx], 0, sizeof(RlcBearerCfg));
7633      procRlcLcCfg(rbId, lcId, rbType, rlcMode, CONFIG_UNKNOWN, f1RlcCfg, &(ueCfgDb->rlcLcCfg[idx]));
7634      if(procMacLcCfg(lcId, rbType, CONFIG_UNKNOWN, NULL, NULL, macUlLcCfg, &ueCfgDb->macLcCfg[idx], NULL) != ROK)
7635      {
7636         DU_LOG("\nERROR  -->  DU APP : Failed while filling MAC LC config at extractRlcCfgToAddMod()");
7637         return RFAILED;
7638      }
7639      (ueCfgDb->numRlcLcs)++;
7640      (ueCfgDb->numMacLcs)++;
7641   }
7642   //TODO: To send the failure cause in UeContextSetupRsp
7643   return ROK;
7644 }
7645
7646 /*******************************************************************
7647  *
7648  * @brief DeAlloc pdsch serv cell config info
7649  *
7650  * @details
7651  *
7652  *    Function : freeMacPdschServCellInfo
7653  *
7654  *    Functionality: DeAlloc pdsch serv cell config info
7655  *
7656  * @params[in] PdschServCellCfg pointer
7657  * @return void
7658  *
7659  * ****************************************************************/
7660
7661 void freeMacPdschServCellInfo(PdschServCellCfg *pdsch)
7662 {
7663    if(pdsch->xOverhead)
7664    {
7665       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->xOverhead, sizeof(PdschXOverhead));
7666    }
7667    if(pdsch->codeBlkGrpFlushInd)
7668    {
7669       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->codeBlkGrpFlushInd, sizeof(bool));
7670    }
7671    if(pdsch->maxCodeBlkGrpPerTb)
7672    {
7673       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
7674    }
7675    if(pdsch->maxMimoLayers)
7676    {
7677       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxMimoLayers, sizeof(uint8_t));
7678    }
7679 }
7680
7681 /*******************************************************************
7682  *
7683  * @brief Free Serving cell Info
7684  *
7685  * @details
7686  *
7687  *    Function : freeMacServingCellInfo
7688  *
7689  *    Functionality: Free Serving cell Info
7690  *
7691  * @params[in] ServCellCfgInfo *srvCellCfg
7692  * @return void
7693  *
7694  * ****************************************************************/
7695 void freeMacServingCellInfo(ServCellCfgInfo *srvCellCfg)
7696 {
7697    freeMacPdschServCellInfo(&srvCellCfg->pdschServCellCfg);
7698    if(srvCellCfg->bwpInactivityTmr)
7699    {
7700       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
7701    }
7702 }
7703
7704 /*******************************************************************
7705  *
7706  * @brief Free cell Grp Cfg Info
7707  *
7708  * @details
7709  *
7710  *    Function : freeUeReCfgCellGrpInfo
7711  *
7712  *    Functionality: Free cell Grp Cfg Info
7713  *
7714  * @params[in] MacUeCfg*  duUeCfg
7715  * @return void
7716  *
7717  * ****************************************************************/
7718
7719 void freeUeReCfgCellGrpInfo(MacUeCfg *macUeCfg)
7720 {
7721    freeMacServingCellInfo(&macUeCfg->spCellCfg.servCellCfg);
7722 }
7723
7724 /*******************************************************************
7725  *
7726  * @brief Fills Reconfig SchReqReConfig
7727  *
7728  * @details
7729  *
7730  *    Function : extractSchReqReConfig
7731  *
7732  *    Functionality: Fills Reconfig SchReqReConfig
7733  *
7734  * @params[in] SchedulingRequestConfig_t *cuSchedReq
7735  *             SchedReqCfg*  macSchedReq
7736  * @return void
7737  *
7738  * ****************************************************************/
7739 void extractSchReqReConfig(SchedulingRequestConfig_t *cuSchedReq, SchedReqCfg *macSchedReq)
7740 {
7741    uint8_t schReqIdx = 0;
7742    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqListToAdd = NULLP;
7743    struct SchedulingRequestConfig__schedulingRequestToReleaseList *schReqListToRel = NULLP;
7744
7745    if(cuSchedReq->schedulingRequestToAddModList)
7746    {
7747       schReqListToAdd = cuSchedReq->schedulingRequestToAddModList;
7748       if(schReqListToAdd->list.count)
7749       {
7750          macSchedReq->addModListCount = schReqListToAdd->list.count;
7751          for(schReqIdx = 0; schReqIdx < schReqListToAdd->list.count; schReqIdx++)
7752          {
7753             macSchedReq->addModList[schReqIdx].schedReqId = \
7754                schReqListToAdd->list.array[schReqIdx]->schedulingRequestId;
7755             macSchedReq->addModList[schReqIdx].srProhibitTmr = \
7756                *(schReqListToAdd->list.array[schReqIdx]->sr_ProhibitTimer);
7757             macSchedReq->addModList[schReqIdx].srTransMax    =\
7758                schReqListToAdd->list.array[schReqIdx]->sr_TransMax;
7759          }
7760       }
7761    }
7762    /* Scheduling Req To release */
7763    if(cuSchedReq->schedulingRequestToReleaseList)
7764    {
7765       schReqListToRel = cuSchedReq->schedulingRequestToReleaseList;
7766       if(schReqListToRel->list.count)
7767       {
7768          macSchedReq->relListCount = schReqListToRel->list.count;
7769          for(schReqIdx = 0; schReqIdx < schReqListToRel->list.count; schReqIdx++)
7770          {
7771             macSchedReq->relList[schReqIdx] = \
7772                *schReqListToRel->list.array[schReqIdx];
7773          }
7774       }
7775    }
7776 }
7777
7778 /*******************************************************************
7779  *
7780  * @brief Fills TagReconfig
7781  *
7782  * @details
7783  *
7784  *    Function : extractTagReconfig
7785  *
7786  *    Functionality: Fills extractTagReconfig
7787  *
7788  * @params[in] TAG_Config_t *cuTagCfg
7789  *             TagCfg *macTagCfg
7790  * @return void
7791  *
7792  * ****************************************************************/
7793
7794 void extractTagReconfig(TAG_Config_t *cuTagCfg, TagCfg *macTagCfg)
7795 {
7796   uint8_t tagIdx = 0;
7797   struct TAG_Config__tag_ToAddModList  *tagListToAddMod = NULLP;
7798   struct TAG_Config__tag_ToReleaseList *tagListToRel = NULLP;
7799
7800   /* Tag config to AddMod */
7801   if(cuTagCfg->tag_ToAddModList)
7802   {
7803      tagListToAddMod = cuTagCfg->tag_ToAddModList;
7804      if(tagListToAddMod->list.count)
7805      {
7806         macTagCfg->addModListCount = tagListToAddMod->list.count;
7807         for(tagIdx = 0; tagIdx < tagListToAddMod->list.count; tagIdx++)
7808         {
7809            macTagCfg->addModList[tagIdx].tagId =\
7810               tagListToAddMod->list.array[tagIdx]->tag_Id;
7811            macTagCfg->addModList[tagIdx].timeAlignTimer = \
7812
7813               tagListToAddMod->list.array[tagIdx]->timeAlignmentTimer;
7814         }
7815      }
7816   }
7817   /* Tag config to release */
7818   if(cuTagCfg->tag_ToReleaseList)
7819   {
7820      tagListToRel = cuTagCfg->tag_ToReleaseList;
7821      if(tagListToRel->list.count)
7822      {
7823         macTagCfg->relListCount = tagListToRel->list.count;
7824         for(tagIdx = 0; tagIdx < tagListToRel->list.count; tagIdx++)
7825         {
7826            macTagCfg->relList[tagIdx] = *tagListToRel->list.array[tagIdx];
7827         }
7828      }
7829   }
7830 }
7831
7832 /*******************************************************************
7833  *
7834  * @brief Fills PdcchCfg received by CU
7835  *
7836  * @details
7837  *
7838  *    Function : extractPdcchCfg
7839  *
7840  *    Functionality: Fills PdcchCfg received  by CU
7841  *
7842  * @params[in] PDCCH_Config_t *cuPdcchCfg,
7843  *             PdcchConfig *duPdcchCfg
7844  * @return void
7845  *
7846  * ****************************************************************/
7847
7848 void extractPdcchCfg(PDCCH_Config_t *cuPdcchCfg, PdcchConfig *macPdcchCfg)
7849 {
7850    uint8_t cRsetIdx = 0;
7851    uint8_t srchSpcIdx = 0;
7852
7853    struct PDCCH_Config__controlResourceSetToAddModList *cRsetToAddModList = NULLP;
7854    struct PDCCH_Config__controlResourceSetToReleaseList *cRsetToRelList = NULLP;
7855    struct PDCCH_Config__searchSpacesToAddModList *srchSpcToAddModList = NULLP;
7856    struct PDCCH_Config__searchSpacesToReleaseList *srchSpcToRelList = NULLP;
7857
7858
7859    /* Control Resource Set To Add/Mod List */
7860    if(cuPdcchCfg->controlResourceSetToAddModList)
7861    {
7862       cRsetToAddModList = cuPdcchCfg->controlResourceSetToAddModList;
7863       if(cRsetToAddModList->list.count)
7864       {
7865          macPdcchCfg->numCRsetToAddMod = cRsetToAddModList->list.count;
7866          for(cRsetIdx = 0; cRsetIdx < cRsetToAddModList->list.count; cRsetIdx++)
7867          {
7868             macPdcchCfg->cRSetToAddModList[cRsetIdx].cRSetId = \
7869               cRsetToAddModList->list.array[cRsetIdx]->controlResourceSetId;
7870             bitStringToInt(&cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources,\
7871                macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc);
7872             macPdcchCfg->cRSetToAddModList[cRsetIdx].duration = \
7873               cRsetToAddModList->list.array[cRsetIdx]->duration;
7874
7875             macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType = \
7876               cRsetToAddModList->list.array[cRsetIdx]->cce_REG_MappingType.present;
7877             if(macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType == CCE_REG_MAPPINGTYPE_PR_INTERLEAVED)
7878             {
7879                //TODO: handle the case for Interleaved
7880             }
7881             macPdcchCfg->cRSetToAddModList[cRsetIdx].precoderGranularity = \
7882               cRsetToAddModList->list.array[cRsetIdx]->precoderGranularity;
7883             if(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID)
7884             {
7885                macPdcchCfg->cRSetToAddModList[cRsetIdx].dmrsScramblingId= \
7886                   *(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID);
7887             }
7888          }
7889       }
7890
7891    }
7892    /* Control Resource Set To Release List */
7893    if(cuPdcchCfg->controlResourceSetToReleaseList)
7894    {
7895       cRsetToRelList = cuPdcchCfg->controlResourceSetToReleaseList;
7896       if(cRsetToRelList->list.count)
7897       {
7898          macPdcchCfg->numCRsetToRel = cRsetToRelList->list.count;
7899          for(cRsetIdx = 0; cRsetIdx < cRsetToRelList->list.count; cRsetIdx++)
7900          {
7901             macPdcchCfg->cRSetToRelList[cRsetIdx] = *(cRsetToRelList->list.array[cRsetIdx]);
7902          }
7903       }
7904    }
7905
7906    /* Search space To Add/Mod List */
7907    if(cuPdcchCfg->searchSpacesToAddModList)
7908    {
7909       srchSpcToAddModList = cuPdcchCfg->searchSpacesToAddModList;
7910       if(srchSpcToAddModList->list.count)
7911       {
7912          macPdcchCfg->numSearchSpcToAddMod = srchSpcToAddModList->list.count;
7913          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToAddModList->list.count; srchSpcIdx++)
7914          {
7915             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceId =\
7916                srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceId;
7917             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].cRSetId =\
7918                *(srchSpcToAddModList->list.array[srchSpcIdx]->controlResourceSetId);
7919             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset)
7920             {
7921                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset =\
7922                   srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset->present;
7923             }
7924             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot)
7925             {
7926                bitStringToInt(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot,\
7927                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSymbolsWithinSlot);
7928             }
7929             if(srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates)
7930             {
7931               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel1 = \
7932                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel1;
7933               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel2 = \
7934                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel2;
7935               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel4 = \
7936                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel4;
7937
7938               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel8 = \
7939                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel8;
7940
7941               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel16 = \
7942                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel16;
7943             }
7944             if(srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType)
7945             {
7946                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType =\
7947                   srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->present;
7948                if(macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType == SEARCHSPACETYPE_PR_UE_SPECIFIC)
7949                {
7950                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].ueSpecificDciFormat =\
7951                      srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->choice.ue_Specific->dci_Formats;
7952                }
7953
7954             }
7955          }
7956       }
7957    }
7958    /* Search space To Rel List */
7959    if(cuPdcchCfg->searchSpacesToReleaseList)
7960    {
7961       srchSpcToRelList = cuPdcchCfg->searchSpacesToReleaseList;
7962       if(srchSpcToRelList->list.count)
7963       {
7964          macPdcchCfg->numSearchSpcToRel = srchSpcToRelList->list.count;
7965          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToRelList->list.count; srchSpcIdx++)
7966          {
7967             macPdcchCfg->searchSpcToRelList[srchSpcIdx] =\
7968                *(srchSpcToRelList->list.array[srchSpcIdx]);
7969          }
7970       }
7971    }
7972 }
7973
7974 /*******************************************************************
7975  *
7976  * @brief Fills PdschCfg received by CU
7977  *
7978  * @details
7979  *
7980  *    Function : extractPdschCfg
7981  *
7982  *    Functionality: Fills PdschCfg received  by CU
7983  *
7984  * @params[in] PDSCH_Config_t *cuPdschCfg,
7985  *             PdschConfig *macPdschCfg
7986  * @return void
7987  *
7988  * ****************************************************************/
7989
7990 void extractPdschCfg(PDSCH_Config_t *cuPdschCfg, PdschConfig *macPdschCfg)
7991 {
7992    uint8_t timeDomIdx;
7993    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAlloc = NULLP;
7994
7995    if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
7996    {
7997       if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->present == \
7998          PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup)
7999       {
8000          if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup)
8001          {
8002             macPdschCfg->dmrsDlCfgForPdschMapTypeA.addPos = \
8003                *(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_AdditionalPosition);
8004          }
8005       }
8006    }
8007    macPdschCfg->resourceAllocType = cuPdschCfg->resourceAllocation;
8008    if(cuPdschCfg->pdsch_TimeDomainAllocationList)
8009    {
8010       timeDomAlloc = cuPdschCfg->pdsch_TimeDomainAllocationList;
8011       if(timeDomAlloc->present ==\
8012          PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup)
8013       {
8014          if(timeDomAlloc->choice.setup)
8015          {
8016             macPdschCfg->numTimeDomRsrcAlloc  = timeDomAlloc->choice.setup->list.count;
8017             for(timeDomIdx = 0; timeDomIdx < timeDomAlloc->choice.setup->list.count; timeDomIdx++)
8018             {
8019                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
8020                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
8021                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
8022                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8023             }
8024          }
8025       }
8026    }
8027    macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
8028    if(cuPdschCfg->maxNrofCodeWordsScheduledByDCI)
8029       macPdschCfg->numCodeWordsSchByDci = *(cuPdschCfg->maxNrofCodeWordsScheduledByDCI);
8030    if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_staticBundling)
8031    {
8032       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
8033       if(cuPdschCfg->prb_BundlingType.choice.staticBundling)
8034       {
8035          if(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize)
8036          {
8037             macPdschCfg->bundlingInfo.StaticBundling.size = \
8038                *(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize);
8039          }
8040       }
8041    }
8042    else if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_dynamicBundling)
8043    {
8044       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
8045    }
8046
8047 }
8048
8049 /*******************************************************************
8050  *
8051  * @brief Fills PdschServingCellCfg received by CU
8052  *
8053  * @details
8054  *
8055  *    Function : extractPdschServingCellCfg
8056  *
8057  *    Functionality: Fills PdschCfg received  by CU
8058  *
8059  * @params[in] PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg,
8060  *             PdschServCellCfg *macUePdschSrvCellCfg
8061  * @return ROK/RFAILED
8062  *
8063  * ****************************************************************/
8064
8065 uint8_t extractPdschServingCellCfg(PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg, PdschServCellCfg *macUePdschSrvCellCfg)
8066 {
8067    if(cuPdschSrvCellCfg->codeBlockGroupTransmission)
8068    {
8069       if(cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup)
8070       {
8071          if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
8072          {
8073             *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
8074                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
8075          }
8076          else
8077          {
8078             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
8079             if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
8080             {
8081                *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
8082                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
8083             }
8084             else
8085             {
8086                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
8087                return RFAILED;
8088             }
8089          }
8090          if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
8091          {
8092             *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
8093                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
8094          }
8095          else
8096          {
8097             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->codeBlkGrpFlushInd , sizeof(bool));
8098             if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
8099             {
8100                *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
8101                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
8102             }
8103             else
8104             {
8105                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
8106                return RFAILED;
8107             }
8108          }
8109       }
8110    }
8111    if(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH)
8112    {
8113       macUePdschSrvCellCfg->numHarqProcForPdsch = *(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH);
8114    }
8115    if(cuPdschSrvCellCfg->ext1)
8116    {
8117       if(cuPdschSrvCellCfg->ext1->maxMIMO_Layers)
8118       {
8119         if(macUePdschSrvCellCfg->maxMimoLayers)
8120         {
8121            *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
8122         }
8123         else
8124         {
8125            DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxMimoLayers, sizeof(uint8_t));
8126            if(macUePdschSrvCellCfg->maxMimoLayers)
8127            {
8128               *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
8129            }
8130            else
8131            {
8132               DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
8133               return RFAILED;
8134            }
8135         }
8136       }
8137    }
8138    if(cuPdschSrvCellCfg->xOverhead)
8139    {
8140       if(macUePdschSrvCellCfg->xOverhead)
8141       {
8142          *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
8143       }
8144       else
8145       {
8146          DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->xOverhead, sizeof(PdschXOverhead));
8147          if(macUePdschSrvCellCfg->xOverhead)
8148          {
8149             *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
8150          }
8151          else
8152          {
8153             DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
8154             return RFAILED;
8155          }
8156       }
8157    }
8158    return ROK;
8159 }
8160
8161 /*******************************************************************
8162  *
8163  * @brief Fills PuschCfg received by CU
8164  *
8165  * @details
8166  *
8167  *    Function : extractPuschCfg
8168  *
8169  *    Functionality: Fills PuschCfg received  by CU
8170  *
8171  * @params[in] BWP_UplinkDedicated__pusch_Config *cuPuschCfg,
8172  *             PuschCfg *macPuschCfg
8173  * @return void
8174  *
8175  * ****************************************************************/
8176
8177 void extractPuschCfg(struct BWP_UplinkDedicated__pusch_Config *cuPuschCfg, PuschCfg *macPuschCfg)
8178 {
8179    uint8_t timeDomIdx = 0;
8180    DMRS_UplinkConfig_t *dmrsUlCfg = NULLP;
8181    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList = NULLP;
8182
8183    if(cuPuschCfg->present == BWP_UplinkDedicated__pusch_Config_PR_setup)
8184    {
8185       if(cuPuschCfg->choice.setup)
8186       {
8187          if(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH)
8188          {
8189              macPuschCfg->dataScramblingId = \
8190                 *(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH);
8191          }
8192          if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA)
8193          {
8194             if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->present == PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup)
8195             {
8196                if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup)
8197                {
8198                   dmrsUlCfg = (cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup);
8199                   if(dmrsUlCfg->dmrs_AdditionalPosition)
8200                   {
8201                      macPuschCfg->dmrsUlCfgForPuschMapTypeA.addPos =\
8202                         *(dmrsUlCfg->dmrs_AdditionalPosition);
8203                   }
8204                   if(dmrsUlCfg->transformPrecodingDisabled)
8205                   {
8206                      if(dmrsUlCfg->transformPrecodingDisabled->scramblingID0)
8207                      {
8208                         macPuschCfg->dmrsUlCfgForPuschMapTypeA.transPrecodDisabled.scramblingId0 = \
8209                            *(dmrsUlCfg->transformPrecodingDisabled->scramblingID0);
8210                      }
8211                   }
8212                }
8213             }
8214          }
8215          /*Res Alloc Type for UL */
8216          if(cuPuschCfg->choice.setup->resourceAllocation)
8217          {
8218             macPuschCfg->resourceAllocType = \
8219                cuPuschCfg->choice.setup->resourceAllocation;
8220          }
8221          if(cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList)
8222          {
8223             timeDomAllocList = cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList;
8224             if(timeDomAllocList->present == PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup)
8225             {
8226                if(timeDomAllocList->choice.setup)
8227                {
8228                   macPuschCfg->numTimeDomRsrcAlloc = timeDomAllocList->choice.setup->list.count;
8229                   for(timeDomIdx = 0; timeDomIdx <timeDomAllocList->choice.setup->list.count; timeDomIdx++)
8230                   {
8231                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].k2 = \
8232                         *(timeDomAllocList->choice.setup->list.array[timeDomIdx]->k2);
8233                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].mappingType = \
8234                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->mappingType;
8235                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbolAndLength = \
8236                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8237                   }
8238                }
8239             }
8240          }
8241          if(cuPuschCfg->choice.setup->transformPrecoder)
8242             macPuschCfg->transformPrecoder = *(cuPuschCfg->choice.setup->transformPrecoder);
8243       }
8244    }
8245 }
8246
8247 /*******************************************************************
8248  *
8249  * @brief Function to fill pucch Power Control
8250  *
8251  * @details
8252  *
8253  *    Function : extractPucchPowerControl
8254  *
8255  *    Functionality: Function to fill pucch Power Control
8256  *
8257  * @params[in] PucchPowerControl *pwrCtrl,
8258  *             struct PUCCH_PowerControl *cuPwrCtrlCfg
8259  * @return void
8260  *
8261  * ****************************************************************/
8262
8263 void extractPucchPowerControl(PucchPowerControl *pwrCtrl, struct PUCCH_PowerControl *cuPwrCtrlCfg)
8264 {
8265    uint8_t arrIdx;
8266
8267    if(cuPwrCtrlCfg->deltaF_PUCCH_f0)
8268       pwrCtrl->deltaF_Format0 = *cuPwrCtrlCfg->deltaF_PUCCH_f0;
8269    if(cuPwrCtrlCfg->deltaF_PUCCH_f1)
8270       pwrCtrl->deltaF_Format1 = *cuPwrCtrlCfg->deltaF_PUCCH_f1;
8271    if(cuPwrCtrlCfg->deltaF_PUCCH_f2)
8272       pwrCtrl->deltaF_Format2 = *cuPwrCtrlCfg->deltaF_PUCCH_f2;
8273    if(cuPwrCtrlCfg->deltaF_PUCCH_f3)
8274       pwrCtrl->deltaF_Format3 = *cuPwrCtrlCfg->deltaF_PUCCH_f3;
8275    if(cuPwrCtrlCfg->deltaF_PUCCH_f4)
8276       pwrCtrl->deltaF_Format4 = *cuPwrCtrlCfg->deltaF_PUCCH_f4;
8277    if(cuPwrCtrlCfg->p0_Set)
8278    {
8279       pwrCtrl->p0SetCount = cuPwrCtrlCfg->p0_Set->list.count;
8280       for(arrIdx=0; arrIdx < pwrCtrl->p0SetCount; arrIdx++)
8281       {
8282          pwrCtrl->p0Set[arrIdx].p0PucchId =\
8283             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Id;
8284          pwrCtrl->p0Set[arrIdx].p0PucchVal =\
8285             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Value;
8286       }
8287    }
8288    if(cuPwrCtrlCfg->pathlossReferenceRSs)
8289    {
8290       pwrCtrl->pathLossRefRSListCount = cuPwrCtrlCfg->pathlossReferenceRSs->list.count;
8291       for(arrIdx = 0; arrIdx < pwrCtrl->pathLossRefRSListCount; arrIdx++)
8292       {
8293          pwrCtrl->pathLossRefRSList[arrIdx].pathLossRefRSId =\
8294             cuPwrCtrlCfg->pathlossReferenceRSs->list.array[arrIdx]->pucch_PathlossReferenceRS_Id;
8295       }
8296    }
8297 }
8298
8299  /*******************************************************************
8300  *
8301  * @brief Function to extractResrcSetToAddModList sent by CU
8302  *
8303  * @details
8304  *
8305  *    Function : extractResrcSetToAddModList
8306  *
8307  *    Functionality: Fucntion to extractResrcSetToAddModList
8308  *
8309  * @params[in] PucchResrcSetCfg pointer,
8310  *             struct PUCCH_Config__resourceSetToAddModList pointer
8311  * @return void
8312  *
8313  * ****************************************************************/
8314
8315 void extractResrcSetToAddModList(PucchResrcSetCfg *macRsrcSetList, struct PUCCH_Config__resourceSetToAddModList *cuRsrcSetList)
8316 {
8317    uint8_t arrIdx, rsrcListIdx;
8318
8319    macRsrcSetList->resrcSetToAddModListCount = cuRsrcSetList->list.count;
8320    for(arrIdx = 0; arrIdx < macRsrcSetList->resrcSetToAddModListCount; arrIdx++)
8321    {
8322       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcSetId     =\
8323          cuRsrcSetList->list.array[arrIdx]->pucch_ResourceSetId;
8324       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount =\
8325          cuRsrcSetList->list.array[arrIdx]->resourceList.list.count;
8326       for(rsrcListIdx = 0; rsrcListIdx < macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount; rsrcListIdx++)
8327       {
8328          macRsrcSetList->resrcSetToAddModList[arrIdx].resrcList[rsrcListIdx] =\
8329             *cuRsrcSetList->list.array[arrIdx]->resourceList.list.array[rsrcListIdx];
8330       }
8331       macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize =\
8332          *cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1;
8333    }
8334 }/* End of extractResrcSetToAddModList */
8335
8336 /*******************************************************************
8337  *
8338  * @brief Fills extractResrcToAddModList sent by CU
8339  *
8340  * @details
8341  *
8342  *    Function : extractResrcToAddModList
8343  *
8344  *    Functionality: Fills extractResrcToAddModList
8345  *
8346  * @params[in] PucchResrcCfg pointer,
8347  *             struct PUCCH_Config__resourceToAddModList pointer
8348  * @return ROk/RFAILED
8349  *
8350  * ****************************************************************/
8351
8352 uint8_t extractResrcToAddModList(PucchResrcCfg *macResrcList, struct PUCCH_Config__resourceToAddModList *cuResrcList)
8353 {
8354    uint8_t arrIdx;
8355
8356    macResrcList->resrcToAddModListCount = cuResrcList->list.count;
8357    for(arrIdx = 0; arrIdx < macResrcList->resrcToAddModListCount; arrIdx++)
8358    {
8359       macResrcList->resrcToAddModList[arrIdx].resrcId      =\
8360         cuResrcList->list.array[arrIdx]->pucch_ResourceId;
8361       macResrcList->resrcToAddModList[arrIdx].startPrb     =\
8362         cuResrcList->list.array[arrIdx]->startingPRB;
8363       if(cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping)
8364       {
8365          macResrcList->resrcToAddModList[arrIdx].intraFreqHop =\
8366            *cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping;
8367       }
8368       if(cuResrcList->list.array[arrIdx]->secondHopPRB)
8369       {
8370          macResrcList->resrcToAddModList[arrIdx].secondPrbHop =\
8371            *cuResrcList->list.array[arrIdx]->secondHopPRB;
8372       }
8373       /* PUCCH RSRC FORMAT */
8374       if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format0)
8375       {
8376          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_0;
8377          if(cuResrcList->list.array[arrIdx]->format.choice.format0)
8378          {
8379             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0, sizeof(PucchFormat0));
8380             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0 == NULLP)
8381             {
8382                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
8383                return RFAILED;
8384             }
8385             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->initialCyclicShift =\
8386                cuResrcList->list.array[arrIdx]->format.choice.format0->initialCyclicShift;
8387             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->numSymbols =\
8388                cuResrcList->list.array[arrIdx]->format.choice.format0->nrofSymbols;
8389             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->startSymbolIdx =\
8390                cuResrcList->list.array[arrIdx]->format.choice.format0->startingSymbolIndex;
8391          }
8392       }
8393       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format1)
8394       {
8395          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_1;
8396          if(cuResrcList->list.array[arrIdx]->format.choice.format1)
8397          {
8398             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1, sizeof(PucchFormat1));
8399             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1 == NULLP)
8400             {
8401                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
8402                return RFAILED;
8403             }
8404             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->initialCyclicShift =\
8405                 cuResrcList->list.array[arrIdx]->format.choice.format1->initialCyclicShift;
8406             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->numSymbols =\
8407                 cuResrcList->list.array[arrIdx]->format.choice.format1->nrofSymbols;
8408             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->startSymbolIdx =\
8409                 cuResrcList->list.array[arrIdx]->format.choice.format1->startingSymbolIndex;
8410             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->timeDomOCC =\
8411                 cuResrcList->list.array[arrIdx]->format.choice.format1->timeDomainOCC;
8412          }
8413       }
8414       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format2)
8415       {
8416          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_2;
8417          if(cuResrcList->list.array[arrIdx]->format.choice.format2)
8418          {
8419             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
8420             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2 == NULLP)
8421             {
8422                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
8423                return RFAILED;
8424             }
8425             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numPrbs =\
8426                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofPRBs;
8427             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numSymbols =\
8428                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofSymbols;
8429             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->startSymbolIdx =\
8430                 cuResrcList->list.array[arrIdx]->format.choice.format2->startingSymbolIndex;
8431          }
8432       }
8433       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format3)
8434       {
8435          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_3;
8436          if(cuResrcList->list.array[arrIdx]->format.choice.format3)
8437          {
8438             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
8439             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3 == NULLP)
8440             {
8441                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
8442                return RFAILED;
8443             }
8444             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numPrbs =\
8445                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofPRBs;
8446             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numSymbols =\
8447                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofSymbols;
8448             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->startSymbolIdx =\
8449                 cuResrcList->list.array[arrIdx]->format.choice.format3->startingSymbolIndex;
8450          }
8451       }
8452       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format4)
8453       {
8454          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_4;
8455          if(cuResrcList->list.array[arrIdx]->format.choice.format4)
8456          {
8457             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4, sizeof(PucchFormat4));
8458             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4 == NULLP)
8459             {
8460                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
8461                return RFAILED;
8462             }
8463             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->numSymbols =\
8464                 cuResrcList->list.array[arrIdx]->format.choice.format4->nrofSymbols;
8465             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occLen =\
8466                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Length;
8467             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occIdx =\
8468                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Index;
8469             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->startSymbolIdx =\
8470                 cuResrcList->list.array[arrIdx]->format.choice.format4->startingSymbolIndex;
8471          }
8472       }
8473    }
8474    return ROK;
8475
8476 }/* End of extractResrcToAddModList */
8477
8478 /*******************************************************************
8479  *
8480  * @brief Fills fillPucchSchedReqPeriodAndOffset sent by CU
8481  *
8482  * @details
8483  *
8484  *    Function : fillPucchSchedReqPeriodAndOffset
8485  *
8486  *    Functionality: To fillPucchSchedReqPeriodAndOffset
8487  *
8488  * @params[in] macPeriodicty,
8489  *     SchedulingRequestResourceConfig__periodicityAndOffset pointer
8490  * @return void
8491  *
8492  * ****************************************************************/
8493
8494 void fillPucchSchedReqPeriodAndOffset(uint8_t macPeriodicty, uint16_t  macOffset,\
8495    struct SchedulingRequestResourceConfig__periodicityAndOffset *cuPeriodicty)
8496 {
8497    macPeriodicty = cuPeriodicty->present;
8498    switch(macPeriodicty)
8499    {
8500       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
8501          {
8502             macOffset     = cuPeriodicty->choice.sym2;
8503             break;
8504          }
8505       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
8506          {
8507             macOffset     = cuPeriodicty->choice.sym6or7;
8508             break;
8509          }
8510       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
8511          {
8512             macOffset     = cuPeriodicty->choice.sl1;
8513             break;
8514          }
8515       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
8516          {
8517             macOffset = cuPeriodicty->choice.sl2;
8518             break;
8519          }
8520       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
8521          {
8522             macOffset = cuPeriodicty->choice.sl4;
8523             break;
8524          }
8525       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
8526          {
8527             macOffset = cuPeriodicty->choice.sl5;
8528             break;
8529          }
8530       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
8531          {
8532             macOffset = cuPeriodicty->choice.sl8;
8533             break;
8534          }
8535       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
8536          {
8537             macOffset = cuPeriodicty->choice.sl10;
8538             break;
8539          }
8540       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
8541          {
8542             macOffset = cuPeriodicty->choice.sl16;
8543             break;
8544          }
8545       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
8546          {
8547             macOffset = cuPeriodicty->choice.sl20;
8548             break;
8549          }
8550       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
8551          {
8552             macOffset = cuPeriodicty->choice.sl40;
8553             break;
8554          }
8555       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
8556          {
8557             macOffset = cuPeriodicty->choice.sl80;
8558             break;
8559          }
8560       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
8561          {
8562             macOffset = cuPeriodicty->choice.sl160;
8563             break;
8564          }
8565       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
8566          {
8567             macOffset = cuPeriodicty->choice.sl320;
8568             break;
8569          }
8570       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
8571          {
8572             macOffset = cuPeriodicty->choice.sl640;
8573             break;
8574          }
8575       default :
8576          DU_LOG("\nERROR  -->  F1AP : Invalid periodicity %d", macPeriodicty);
8577    }
8578 }
8579
8580 /*******************************************************************
8581  *
8582  * @brief Function to extractPucchFormatCfg sent by CU
8583  *
8584  * @details
8585  *
8586  *    Function : extractPucchFormatCfg
8587  *
8588  *    Functionality: Function to extractPucchFormatCfg
8589  *
8590  * @params[in] PucchFormatCfg pointer,
8591  *             PUCCH_FormatConfig_t pointer
8592  * @return void
8593  *
8594  * ****************************************************************/
8595
8596 void extractPucchFormatCfg(PucchFormatCfg *macFormatCfg, PUCCH_FormatConfig_t *cuFormatCfg)
8597  {
8598     if(cuFormatCfg->interslotFrequencyHopping)
8599        macFormatCfg->interSlotFreqHop = *cuFormatCfg->interslotFrequencyHopping;
8600     if(cuFormatCfg->additionalDMRS)
8601        macFormatCfg->addDmrs = *cuFormatCfg->additionalDMRS;
8602     if(cuFormatCfg->maxCodeRate)
8603        macFormatCfg->maxCodeRate = *cuFormatCfg->maxCodeRate;
8604     if(cuFormatCfg->nrofSlots)
8605        macFormatCfg->numSlots = *cuFormatCfg->nrofSlots;
8606     if(cuFormatCfg->pi2BPSK)
8607        macFormatCfg->pi2BPSK = *cuFormatCfg->pi2BPSK;
8608     if(cuFormatCfg->simultaneousHARQ_ACK_CSI)
8609        macFormatCfg->harqAckCSI = *cuFormatCfg->simultaneousHARQ_ACK_CSI;
8610  }/* End of extractPucchFormatCfg */
8611
8612 /*******************************************************************
8613  *
8614  * @brief Function to extractSchedReqCfgToAddMod sent by CU
8615  *
8616  * @details
8617  *
8618  *    Function : extractSchedReqCfgToAddMod
8619  *
8620  *    Functionality: Function to extractSchedReqCfgToAddMod
8621  *
8622  * @params[in] PucchSchedReqCfg pointer,
8623  *      PUCCH_Config__schedulingRequestResourceToAddModList pointer
8624  * @return void
8625  *
8626  * ****************************************************************/
8627
8628 void extractSchedReqCfgToAddMod(PucchSchedReqCfg *macSchedReqCfg, struct PUCCH_Config__schedulingRequestResourceToAddModList *cuSchedReqList)
8629 {
8630    uint8_t arrIdx;
8631
8632    macSchedReqCfg->schedAddModListCount = cuSchedReqList->list.count;
8633    for(arrIdx = 0; arrIdx <  macSchedReqCfg->schedAddModListCount; arrIdx++)
8634    {
8635       macSchedReqCfg->schedAddModList[arrIdx].resrcId =\
8636          cuSchedReqList->list.array[arrIdx]->schedulingRequestResourceId;
8637       macSchedReqCfg->schedAddModList[arrIdx].requestId =\
8638          cuSchedReqList->list.array[arrIdx]->schedulingRequestID;
8639       if(cuSchedReqList->list.array[arrIdx]->periodicityAndOffset)
8640       {
8641          fillPucchSchedReqPeriodAndOffset(macSchedReqCfg->schedAddModList[arrIdx].periodicity,\
8642             macSchedReqCfg->schedAddModList[arrIdx].offset, cuSchedReqList->list.array[arrIdx]->periodicityAndOffset);
8643       }
8644       if(cuSchedReqList->list.array[arrIdx]->resource)
8645       {
8646          macSchedReqCfg->schedAddModList[arrIdx].resrc =\
8647             *cuSchedReqList->list.array[arrIdx]->resource;
8648       }
8649    }
8650
8651 }/* End of extractSchedReqCfgToAddMod */
8652
8653  /*******************************************************************
8654  *
8655  * @brief Fills PucchCfg received by CU
8656  *
8657  * @details
8658  *
8659  *    Function : extractPucchCfg
8660  *
8661  *    Functionality: Fills PucchCfg received  by CU
8662  *
8663  * @params[in] BWP_UplinkDedicated__pucch_Config *cuPucchCfg,
8664  *             PucchCfg *macPucchCfg
8665  * @return ROK/RFAILED
8666  *
8667  * ****************************************************************/
8668
8669 uint8_t extractPucchCfg(struct BWP_UplinkDedicated__pucch_Config *cuPucchCfg, PucchCfg *macPucchCfg)
8670 {
8671    uint8_t arrIdx;
8672
8673    if(cuPucchCfg->present == BWP_UplinkDedicated__pucch_Config_PR_setup)
8674    {
8675       if(cuPucchCfg->choice.setup)
8676       {
8677          /* Resource Set Cfg */
8678          if(cuPucchCfg->choice.setup->resourceSetToAddModList)
8679          {
8680             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrcSet, sizeof(PucchResrcSetCfg));
8681             if(macPucchCfg->resrcSet == NULLP)
8682             {
8683                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
8684                return RFAILED;
8685             }
8686             memset(macPucchCfg->resrcSet, 0, sizeof(PucchResrcSetCfg));
8687             extractResrcSetToAddModList(macPucchCfg->resrcSet, cuPucchCfg->choice.setup->resourceSetToAddModList);
8688          }
8689
8690          /* Resource Cfg */
8691          if(cuPucchCfg->choice.setup->resourceToAddModList)
8692          {
8693             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrc, sizeof(PucchResrcCfg));
8694             if(macPucchCfg->resrc == NULLP)
8695             {
8696                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
8697                return RFAILED;
8698             }
8699             memset(macPucchCfg->resrc, 0, sizeof(PucchResrcCfg));
8700             extractResrcToAddModList(macPucchCfg->resrc, cuPucchCfg->choice.setup->resourceToAddModList);
8701          }
8702
8703          /* Format 1 Cfg */
8704          if(cuPucchCfg->choice.setup->format1)
8705          {
8706             DU_ALLOC_SHRABL_BUF(macPucchCfg->format1, sizeof(PucchFormatCfg));
8707             if(macPucchCfg->format1 == NULLP)
8708             {
8709                DU_LOG("\nERROR --> F1AP : Failed to extract format 1 Cfg in  extractPucchCfg()");
8710                return RFAILED;
8711             }
8712             memset(macPucchCfg->format1, 0, sizeof(PucchFormatCfg));
8713             extractPucchFormatCfg(macPucchCfg->format1,\
8714                cuPucchCfg->choice.setup->format1->choice.setup);
8715          }
8716
8717          /* Format 2 Cfg */
8718          if(cuPucchCfg->choice.setup->format2)
8719          {
8720             DU_ALLOC_SHRABL_BUF(macPucchCfg->format2, sizeof(PucchFormatCfg));
8721             if(macPucchCfg->format2 == NULLP)
8722             {
8723                DU_LOG("\nERROR --> F1AP : Failed to extract format 2 Cfg in  extractPucchCfg()");
8724                return RFAILED;
8725             }
8726             memset(macPucchCfg->format2, 0, sizeof(PucchFormatCfg));
8727             extractPucchFormatCfg(macPucchCfg->format2,\
8728                cuPucchCfg->choice.setup->format2->choice.setup);
8729          }
8730
8731          /* Format 3 Cfg */
8732          if(cuPucchCfg->choice.setup->format3)
8733          {
8734             DU_ALLOC_SHRABL_BUF(macPucchCfg->format3, sizeof(PucchFormatCfg));
8735             if(macPucchCfg->format3 == NULLP)
8736             {
8737                DU_LOG("\nERROR --> F1AP : Failed to extract format 3 Cfg in  extractPucchCfg()");
8738                return RFAILED;
8739             }
8740             memset(macPucchCfg->format3, 0, sizeof(PucchFormatCfg));
8741             extractPucchFormatCfg(macPucchCfg->format3,\
8742                cuPucchCfg->choice.setup->format3->choice.setup);
8743          }
8744
8745          /* Format 4 Cfg */
8746          if(cuPucchCfg->choice.setup->format4)
8747          {
8748             DU_ALLOC_SHRABL_BUF(macPucchCfg->format4, sizeof(PucchFormatCfg));
8749             if(macPucchCfg->format4 == NULLP)
8750             {
8751                DU_LOG("\nERROR --> F1AP : Failed to extract format 4 Cfg in  extractPucchCfg()");
8752                return RFAILED;
8753             }
8754             memset(macPucchCfg->format4, 0, sizeof(PucchFormatCfg));
8755             extractPucchFormatCfg(macPucchCfg->format4,\
8756                cuPucchCfg->choice.setup->format4->choice.setup);
8757          }
8758
8759          /* Sched Req List */
8760          if(cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList)
8761          {
8762             DU_ALLOC_SHRABL_BUF(macPucchCfg->schedReq, sizeof(PucchSchedReqCfg));
8763             if(macPucchCfg->schedReq == NULLP)
8764             {
8765                DU_LOG("\nERROR --> F1AP : Failed to extract schedReqCfg in  extractPucchCfg()");
8766                return RFAILED;
8767             }
8768             memset(macPucchCfg->schedReq, 0, sizeof(PucchSchedReqCfg));
8769             extractSchedReqCfgToAddMod(macPucchCfg->schedReq,\
8770             cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList);
8771          }
8772
8773          /*TODO: Add support for  Spatial Info */
8774
8775          /* MultiCsiCfg */
8776          if(cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList)
8777          {
8778             DU_ALLOC_SHRABL_BUF(macPucchCfg->multiCsiCfg, sizeof(PucchMultiCsiCfg));
8779             if(macPucchCfg->multiCsiCfg == NULLP)
8780             {
8781                DU_LOG("\nERROR --> F1AP : Failed to extract multiCsiCfg in  extractPucchCfg()");
8782                return RFAILED;
8783             }
8784             memset(macPucchCfg->multiCsiCfg, 0, sizeof(PucchMultiCsiCfg));
8785             macPucchCfg->multiCsiCfg->multiCsiResrcListCount = cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.count;
8786             for(arrIdx =0; arrIdx < macPucchCfg->multiCsiCfg->multiCsiResrcListCount; arrIdx++)
8787             {
8788                macPucchCfg->multiCsiCfg->multiCsiResrcList[arrIdx] =\
8789                  *cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.array[arrIdx];
8790             }
8791          }
8792
8793          /* Dl_DataToUL_ACK */
8794          if(cuPucchCfg->choice.setup->dl_DataToUL_ACK)
8795          {
8796             DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
8797             if(macPucchCfg->dlDataToUlAck == NULLP)
8798             {
8799                DU_LOG("\nERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
8800                return RFAILED;
8801             }
8802             memset(macPucchCfg->dlDataToUlAck, 0, sizeof(PucchDlDataToUlAck));
8803             macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount = cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.count;
8804             for(arrIdx = 0; arrIdx < macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount; arrIdx++)
8805             {
8806                macPucchCfg->dlDataToUlAck->dlDataToUlAckList[arrIdx] =\
8807                   *cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.array[arrIdx];
8808             }
8809          }
8810
8811          /* Power Control */
8812          if(cuPucchCfg->choice.setup->pucch_PowerControl)
8813          {
8814             DU_ALLOC_SHRABL_BUF(macPucchCfg->powerControl, sizeof(PucchPowerControl));
8815             if(macPucchCfg->powerControl == NULLP)
8816             {
8817                DU_LOG("\nERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
8818                return RFAILED;
8819             }
8820             extractPucchPowerControl(macPucchCfg->powerControl,\
8821                cuPucchCfg->choice.setup->pucch_PowerControl);
8822          }
8823       }
8824    }
8825    return ROK;
8826 }
8827
8828 /*******************************************************************
8829  *
8830  * @brief Fills ServingCellReconfig received by CU
8831  *
8832  * @details
8833  *
8834  *    Function : extractSpCellDedicatedCfg
8835  *
8836  *    Functionality: Fills ServingCellReconfig received  by CU
8837  *
8838  * @params[in] ServingCellConfig_t *cuSrvCellCfg
8839  *             ServCellCfgInfo *macSrvCellCfg
8840  * @return ROK/RFAILD
8841  *
8842  * ****************************************************************/
8843 uint8_t extractSpCellDedicatedCfg(ServingCellConfig_t *cuSrvCellCfg, ServCellCfgInfo *macSrvCellCfg)
8844 {
8845    uint8_t ret = ROK;
8846    BWP_DownlinkDedicated_t *dlBwp = NULLP;
8847    BWP_UplinkDedicated_t   *ulBwp = NULLP;
8848
8849    if(cuSrvCellCfg->initialDownlinkBWP)
8850    {
8851       dlBwp = ((BWP_DownlinkDedicated_t *)(cuSrvCellCfg->initialDownlinkBWP));
8852       if(dlBwp->pdcch_Config)
8853       {
8854          if(dlBwp->pdcch_Config->choice.setup)
8855          {
8856             macSrvCellCfg->initDlBwp.pdcchPresent = true;
8857             extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
8858          }
8859       }
8860       if(dlBwp->pdsch_Config)
8861       {
8862          if(dlBwp->pdsch_Config->choice.setup)
8863          {
8864             macSrvCellCfg->initDlBwp.pdschPresent = true;
8865             extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg);
8866          }
8867       }
8868    }
8869    if(cuSrvCellCfg->firstActiveDownlinkBWP_Id)
8870       macSrvCellCfg->firstActvDlBwpId = *(cuSrvCellCfg->firstActiveDownlinkBWP_Id);
8871    if(cuSrvCellCfg->defaultDownlinkBWP_Id)
8872       macSrvCellCfg->defaultDlBwpId = *(cuSrvCellCfg->defaultDownlinkBWP_Id);
8873    if(cuSrvCellCfg->bwp_InactivityTimer)
8874    {
8875       if(macSrvCellCfg->bwpInactivityTmr)
8876       {
8877          memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
8878       }
8879       else
8880       {
8881          macSrvCellCfg->bwpInactivityTmr = NULLP;
8882          DU_ALLOC_SHRABL_BUF(macSrvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
8883          if(macSrvCellCfg->bwpInactivityTmr)
8884          {
8885             memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
8886          }
8887          else
8888          {
8889             DU_LOG("\nERROR  --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
8890             return RFAILED;
8891          }
8892       }
8893    }
8894    if(cuSrvCellCfg->pdsch_ServingCellConfig)
8895    {
8896       if(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup)
8897       {
8898          ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
8899          if(ret == RFAILED)
8900          {
8901             DU_LOG("\nERROR --> F1AP : Failed at extractPdschServingCellCfg()");
8902             return RFAILED;
8903          }
8904       }
8905    }
8906    if(cuSrvCellCfg->uplinkConfig)
8907    {
8908      if(cuSrvCellCfg->uplinkConfig->initialUplinkBWP)
8909      {
8910         ulBwp = ((BWP_UplinkDedicated_t *)(cuSrvCellCfg->uplinkConfig->initialUplinkBWP));
8911         if(ulBwp->pusch_Config)
8912         {
8913            macSrvCellCfg->initUlBwp.puschPresent = true;
8914            extractPuschCfg(ulBwp->pusch_Config, &macSrvCellCfg->initUlBwp.puschCfg);
8915         }
8916         if(ulBwp->pucch_Config)
8917         {
8918            macSrvCellCfg->initUlBwp.pucchPresent = true;
8919            memset(&macSrvCellCfg->initUlBwp.pucchCfg, 0, sizeof(PucchCfg));
8920            extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg);
8921         }
8922      }
8923      if(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id)
8924         macSrvCellCfg->firstActvUlBwpId = *(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id);
8925    }
8926    return ret;
8927 }
8928 /*******************************************************************
8929  *
8930  * @brief Fills Reconfig Cell group Info received by CU
8931  *
8932  * @details
8933  *
8934  *    Function : extractUeReCfgCellInfo
8935  *
8936  *    Functionality: Fills Reconfig Cell group Info received by CU
8937  *
8938  * @params[in] CellGroupConfigRrc_t *macCellGrpCfg
8939  *             MacUeCfg*  macUeCfg
8940  * @return ROK/RFAILED
8941  *
8942  * ****************************************************************/
8943 uint8_t extractUeReCfgCellInfo(CellGroupConfigRrc_t *cellGrp, MacUeCfg *macUeCfg)
8944 {
8945    uint8_t ret = ROK;
8946    MAC_CellGroupConfig_t     *macCellGroup = NULLP;
8947    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
8948    SpCellConfig_t            *spcellCfg = NULLP;
8949    ServingCellConfig_t       *servCellCfg = NULLP;
8950
8951    if(cellGrp)
8952    {
8953       /* Fill MacCell Group Reconfig  */
8954       if(cellGrp->mac_CellGroupConfig)
8955       {
8956          macUeCfg->macCellGrpCfgPres = true;
8957          macCellGroup = ((MAC_CellGroupConfig_t *)(cellGrp->mac_CellGroupConfig));
8958          if(macCellGroup->schedulingRequestConfig)
8959          {
8960             extractSchReqReConfig(macCellGroup->schedulingRequestConfig, &macUeCfg->macCellGrpCfg.schReqCfg);
8961          }
8962          if(macCellGroup->tag_Config)
8963          {
8964             extractTagReconfig(macCellGroup->tag_Config, &macUeCfg->macCellGrpCfg.tagCfg);
8965          }
8966          if(macCellGroup->bsr_Config)
8967          {
8968             macUeCfg->macCellGrpCfg.bsrTmrCfg.periodicTimer = macCellGroup->bsr_Config->periodicBSR_Timer;
8969             macUeCfg->macCellGrpCfg.bsrTmrCfg.retxTimer     = macCellGroup->bsr_Config->retxBSR_Timer;
8970             if(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer)
8971             {
8972                macUeCfg->macCellGrpCfg.bsrTmrCfg.srDelayTimer  =\
8973                *(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer);
8974             }
8975          }
8976          if(macCellGroup->phr_Config)
8977          {
8978             if(macCellGroup->phr_Config->present == MAC_CellGroupConfig__phr_Config_PR_setup)
8979             {
8980                macUeCfg->macCellGrpCfg.phrCfgSetupPres = true;
8981                if(macCellGroup->phr_Config->choice.setup)
8982                {
8983                   macUeCfg->macCellGrpCfg.phrCfg.periodicTimer     = \
8984                   macCellGroup->phr_Config->choice.setup->phr_PeriodicTimer;
8985                   macUeCfg->macCellGrpCfg.phrCfg.prohibitTimer     = \
8986                   macCellGroup->phr_Config->choice.setup->phr_ProhibitTimer;
8987                   macUeCfg->macCellGrpCfg.phrCfg.txPowerFactor     = \
8988                   macCellGroup->phr_Config->choice.setup->phr_Tx_PowerFactorChange;
8989                   macUeCfg->macCellGrpCfg.phrCfg.multiplePHR       = \
8990                   macCellGroup->phr_Config->choice.setup->multiplePHR;
8991                   macUeCfg->macCellGrpCfg.phrCfg.dummy             = \
8992                   macCellGroup->phr_Config->choice.setup->dummy;
8993                   macUeCfg->macCellGrpCfg.phrCfg.phrType2OtherCell = \
8994                   macCellGroup->phr_Config->choice.setup->phr_Type2OtherCell;
8995                   macUeCfg->macCellGrpCfg.phrCfg.phrOtherCG        = \
8996                   macCellGroup->phr_Config->choice.setup->phr_ModeOtherCG;
8997                }
8998             }
8999          }
9000       }
9001       /* Fill Physical Cell Group Reconfig */
9002       if(cellGrp->physicalCellGroupConfig)
9003       {
9004          macUeCfg->phyCellGrpCfgPres = true;
9005          phyCellGrpCfg = ((PhysicalCellGroupConfig_t *)(cellGrp->physicalCellGroupConfig));
9006          if(phyCellGrpCfg->p_NR_FR1)
9007          {
9008             if(*(phyCellGrpCfg->p_NR_FR1) != macUeCfg->phyCellGrpCfg.pNrFr1)
9009                macUeCfg->phyCellGrpCfg.pNrFr1 = *(phyCellGrpCfg->p_NR_FR1);
9010          }
9011          macUeCfg->phyCellGrpCfg.pdschHarqAckCodebook = phyCellGrpCfg->pdsch_HARQ_ACK_Codebook;
9012       }
9013       /* Fill SpCell Reconfig */
9014       if(cellGrp->spCellConfig)
9015       {
9016          macUeCfg->spCellCfgPres = true;
9017          spcellCfg = ((SpCellConfig_t *)(cellGrp->spCellConfig));
9018          if(spcellCfg->servCellIndex)
9019          {
9020             macUeCfg->spCellCfg.servCellIdx = *(spcellCfg->servCellIndex);
9021          }
9022          /* Fill Serving cell Reconfig info */
9023          if(cellGrp->spCellConfig->spCellConfigDedicated)
9024          {
9025             servCellCfg = ((ServingCellConfig_t *)(cellGrp->spCellConfig->spCellConfigDedicated));
9026             ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg);
9027             if(ret == RFAILED)
9028             {
9029                DU_LOG("\nERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
9030             }
9031          }
9032       }
9033    }
9034    return ret;
9035 }
9036 /*******************************************************************
9037 *
9038 * @brief free the memory allocated by decoder
9039 *
9040 * @details
9041 *
9042 *    Function : freeAperDecodeNrcgi
9043 *
9044 *    Functionality: Free Nrcgi values
9045 *
9046 * @params[in] NRCGI_t *nrcgi
9047 * @return void
9048 *
9049 * ****************************************************************/
9050
9051
9052 void freeAperDecodeNrcgi(NRCGI_t *nrcgi)
9053 {
9054     if(nrcgi->pLMN_Identity.buf != NULLP)
9055     {
9056        free(nrcgi->pLMN_Identity.buf);
9057     }
9058     if(nrcgi->nRCellIdentity.buf != NULLP)
9059     {
9060        free(nrcgi->nRCellIdentity.buf);
9061     }
9062 }
9063 /*******************************************************************
9064 *
9065 * @brief free the memory allocated by decoder
9066 *
9067 * @details
9068 *
9069 *    Function : freeAperDecodeCuToDuInfo
9070 *
9071 *    Functionality:  Free Cu To Du Information
9072 *
9073 * @params[in] CUtoDURRCInformation_t *rrcMsg
9074 * @return void
9075 *
9076 * ****************************************************************/
9077
9078
9079 void freeAperDecodeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
9080 {
9081    uint8_t ieIdx =0;
9082    uint8_t arrIdx =0;
9083
9084    if(rrcMsg->uE_CapabilityRAT_ContainerList)
9085    {
9086       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
9087          free(rrcMsg->uE_CapabilityRAT_ContainerList->buf);
9088       free(rrcMsg->uE_CapabilityRAT_ContainerList);
9089    }
9090
9091    if(rrcMsg->iE_Extensions)
9092    {
9093       if(rrcMsg->iE_Extensions->list.array)
9094       {
9095          for(ieIdx= 0; ieIdx < rrcMsg->iE_Extensions->list.count; ieIdx++)
9096          {
9097             if(rrcMsg->iE_Extensions->list.array[ieIdx])
9098             {
9099                switch(rrcMsg->iE_Extensions->list.array[ieIdx]->id)
9100                {
9101                   case ProtocolIE_ID_id_CellGroupConfig:
9102                      if(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
9103                      {
9104                         free(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf);
9105                      }
9106                      break;
9107                   default:
9108                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
9109                            rrcMsg->iE_Extensions->list.array[ieIdx]->id);
9110                      break;
9111                }
9112             }
9113          }
9114          for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
9115          {
9116             free(rrcMsg->iE_Extensions->list.array[arrIdx]);
9117          }
9118          free(rrcMsg->iE_Extensions->list.array);
9119
9120       }
9121
9122       free(rrcMsg->iE_Extensions);
9123    }
9124 }
9125 /*******************************************************************
9126 *
9127 * @brief free the memory allocated by decoder
9128 *
9129 * @details
9130 *
9131 *    Function : freeAperDecodeSplCellList
9132 *
9133 *    Functionality: Free Spl Cell List
9134                     where memory allocated by aper_decoder
9135 *
9136 * @params[in]  SCell_ToBeSetup_List_t *spCellLst
9137 * @return void
9138 *
9139 * ****************************************************************/
9140
9141
9142 void freeAperDecodeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
9143 {
9144     uint8_t  cellIdx =0;
9145
9146     if(spCellLst->list.array != NULLP)
9147     {
9148        for(cellIdx=0; cellIdx<spCellLst->list.count; cellIdx++)
9149        {
9150           if(cellIdx==0&&spCellLst->list.array[cellIdx]!=NULLP)
9151           {
9152              freeAperDecodeNrcgi(&spCellLst->list.array[cellIdx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
9153           }
9154           if(spCellLst->list.array[cellIdx]!=NULLP)
9155           {
9156              free(spCellLst->list.array[cellIdx]);
9157           }
9158        }
9159        free(spCellLst->list.array);
9160     }
9161 }
9162 /*******************************************************************
9163 *
9164 * @brief free the memory allocated by decoder
9165 *
9166 * @details
9167 *
9168 *    Function : freeAperDecodeSRBSetup
9169 *
9170 *    Functionality: added free part for the memory allocated by aper_decoder
9171 *
9172 * @params[in] SRBs_ToBeSetup_List_t *srbSet
9173 * @return void
9174 *
9175 ****************************************************************/
9176
9177
9178 void freeAperDecodeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
9179 {
9180     uint8_t srbIdx =0;
9181     if(srbSet->list.array != NULLP)
9182     {
9183        for(srbIdx=0; srbIdx<srbSet->list.count; srbIdx++)
9184        {
9185           if(srbSet->list.array[srbIdx]!=NULLP)
9186           {
9187              free(srbSet->list.array[srbIdx]);
9188           }
9189        }
9190        free(srbSet->list.array);
9191     }
9192 }
9193
9194 /*******************************************************************
9195 *
9196 * @brief free the memory allocated by decoder
9197 *
9198 * @details
9199 *
9200 *    Function : freeAperDecodeULTnlInfo
9201 *
9202 *    Functionality: added free part for the memory allocated by aper_decoder
9203 *
9204 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
9205 * @return void
9206 *
9207 * ****************************************************************/
9208
9209
9210 void freeAperDecodeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
9211 {
9212    uint8_t ulIdx=0;
9213    if(ulInfo->list.array != NULLP)
9214    {
9215       for(ulIdx=0; ulIdx<ulInfo->list.count; ulIdx++)
9216       {
9217          if(ulIdx==0&&ulInfo->list.array[ulIdx]!=NULLP)
9218          {
9219             if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
9220             {
9221                if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9222                      transportLayerAddress.buf != NULLP)
9223                {
9224                   if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
9225                         !=NULLP)
9226                   {
9227                      free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf);
9228                   }
9229                   free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9230                         transportLayerAddress.buf);
9231                }
9232                free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel);
9233             }
9234          }
9235          if(ulInfo->list.array[ulIdx]!=NULLP)
9236          {
9237             free(ulInfo->list.array[ulIdx]);
9238          }
9239       }
9240       free(ulInfo->list.array);
9241    }
9242 }
9243 /*******************************************************************
9244 *
9245 * @brief free the memory allocated by decoder
9246 *
9247 * @details
9248 *
9249 *    Function : freeAperDecodeDRBSetup
9250 *
9251 *    Functionality: free DRBSetup which is allocated by decoder
9252 *
9253 * @params[in]  DRBs_ToBeSetup_List_t *drbSet
9254 * @return void
9255 *
9256 * ****************************************************************/
9257
9258 void freeAperDecodeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
9259 {
9260    DRBs_ToBeSetup_Item_t *drbSetItem = NULLP;
9261    uint8_t  flowIdx =0;
9262    uint8_t  drbIdx =0;
9263
9264    if(drbSet->list.array != NULLP)
9265    {
9266       for(drbIdx=0; drbIdx<drbSet->list.count; drbIdx++)
9267       {
9268          if(drbIdx==0&&drbSet->list.array[drbIdx] != NULLP)
9269          {
9270             drbSetItem =&drbSet->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
9271             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
9272             {
9273                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9274                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
9275                {
9276                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9277                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9278                   {
9279                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9280                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9281                      {
9282
9283                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
9284                         {
9285
9286                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
9287                            {
9288
9289                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->\
9290                                     buf!=NULLP)
9291                               {
9292
9293                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
9294                                        flows_Mapped_To_DRB_List.list.array != NULLP)
9295                                  {
9296
9297                                     for(flowIdx=0;flowIdx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9298                                           DRB_Information.flows_Mapped_To_DRB_List.list.count; flowIdx++)
9299                                     {
9300
9301                                        if(flowIdx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9302                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9303                                        {
9304                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9305                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9306                                                 qoSFlowLevelQoSParameters.\
9307                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
9308                                           {
9309                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9310                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9311                                                    qoSFlowLevelQoSParameters.\
9312                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9313                                              {
9314
9315                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9316                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9317                                                       qoSFlowLevelQoSParameters.\
9318                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9319                                                 {
9320
9321
9322                                                    free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9323                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9324                                                          qoSFlowLevelQoSParameters.\
9325                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9326                                                 }
9327
9328                                                 free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9329                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9330                                                       qoSFlowLevelQoSParameters.\
9331                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9332                                              }
9333
9334                                              free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9335
9336                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9337                                                    qoSFlowLevelQoSParameters.\
9338                                                    qoS_Characteristics.choice.non_Dynamic_5QI);
9339                                           }
9340                                        }
9341                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9342                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9343                                        {
9344
9345                                           free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9346                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]);
9347                                        }
9348                                     }
9349
9350                                     free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9351                                           DRB_Information.flows_Mapped_To_DRB_List.list.array);
9352                                  }
9353
9354                                  free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9355                                        DRB_Information.sNSSAI.sD->buf);
9356                               }
9357
9358                               free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD);
9359                            }
9360
9361                            free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf);
9362
9363                         }
9364
9365                         free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9366
9367                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9368                      }
9369
9370                      free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9371                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9372                   }
9373
9374                   free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9375                         qoS_Characteristics.choice.non_Dynamic_5QI);
9376                }
9377                free(drbSetItem->qoSInformation.choice.choice_extension);
9378             }
9379             freeAperDecodeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
9380             if(drbSetItem->uLConfiguration)
9381             {
9382                free(drbSetItem->uLConfiguration);
9383             }
9384          }
9385          if(drbSet->list.array[drbIdx]!=NULLP)
9386          {
9387             free(drbSet->list.array[drbIdx]);
9388          }
9389       }
9390       free(drbSet->list.array);
9391    }
9392 }
9393
9394
9395 /*******************************************************************
9396  *
9397  * @brief builds Mac Cell Cfg
9398  *
9399  * @details
9400  *
9401  *    Function : procUeReCfgCellInfo
9402  *
9403  *    Functionality: builds Mac Cell Cfg
9404  *
9405  * @params[in] MacUeCfg pointer
9406  *             void pointer
9407  *
9408  * @return void
9409  *
9410  * ****************************************************************/
9411 uint8_t procUeReCfgCellInfo(MacUeCfg *macUeCfg, void *cellInfo)
9412 {
9413    uint8_t ret = ROK;
9414    CellGroupConfigRrc_t *cellGrp = NULLP;
9415
9416    if(cellInfo)
9417    {
9418       cellGrp = (CellGroupConfigRrc_t *)cellInfo;
9419       ret = extractUeReCfgCellInfo(cellGrp, macUeCfg);
9420       if(ret == RFAILED)
9421          DU_LOG("\nERROR  -->  F1AP : Failed at procUeReCfgCellInfo()");
9422    }
9423    if(ret == RFAILED)
9424    {
9425       freeUeReCfgCellGrpInfo(macUeCfg);
9426    }
9427    return ret;
9428 }
9429
9430 /*******************************************************************
9431  *
9432  * @brief Filling modulation info in mac ue cfg
9433  *
9434  * @details
9435  *
9436  *    Function : duFillModulationDetails
9437  *
9438  *    Functionality: Filling modulation info in mac ue cfg
9439  *
9440  * @params[in] MAC UE Config to be updated
9441  *             Current UE configuration
9442  *             UE NR capability from CU
9443  * @return ROK     - success
9444  *         RFAILED - failure
9445  *
9446  * ****************************************************************/
9447 void duFillModulationDetails(MacUeCfg *ueCfg, MacUeCfg *oldUeCfg, void *ueCap)
9448 {
9449    UE_NR_Capability_t *ueNrCap=NULLP;
9450
9451    if(!ueCap)
9452    {
9453       memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9454       memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9455    }
9456    else
9457    {
9458       ueNrCap = (UE_NR_Capability_t *)ueCap;
9459
9460       /* Filling DL modulation info */
9461       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsDownlinkPerCC && \
9462          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0] && \
9463          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL)
9464       {
9465          switch(*(ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL))
9466          {
9467             case ModulationOrder_qpsk:
9468                {
9469                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
9470                   break;
9471                }
9472             case ModulationOrder_qam16:
9473                {
9474                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM16;
9475                   break;
9476                }
9477             case ModulationOrder_qam64:
9478                {
9479                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM64;
9480                   ueCfg->dlModInfo.mcsIndex = PDSCH_MCS_INDEX;
9481                   ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64;
9482                   break;
9483                }
9484             case ModulationOrder_qam256:
9485                {
9486                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM256;
9487                   break;
9488                }
9489             default:
9490                {
9491                   DU_LOG("\nERROR  -->  DU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
9492                   memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9493                   break;
9494                }
9495          }
9496       }
9497       else
9498       {
9499          memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9500       }
9501
9502       /* Filling UL modulation info */
9503       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsUplinkPerCC && \
9504          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0] && \
9505          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL)
9506       {
9507          switch(*(ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL))
9508          {
9509             case ModulationOrder_qpsk:
9510                {
9511                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
9512                   break;
9513                }
9514             case ModulationOrder_qam16:
9515                {
9516                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM16;
9517                   ueCfg->ulModInfo.mcsIndex = PUSCH_MCS_INDEX;
9518                   ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64;
9519                   break;
9520                }
9521             case ModulationOrder_qam64:
9522                {
9523                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM64;
9524                   break;
9525                }
9526             case ModulationOrder_qam256:
9527                {
9528                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM256;
9529                   break;
9530                }
9531             default:
9532                {
9533                   DU_LOG("\nERROR  -->  DU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
9534                   memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9535                   break;
9536                }
9537          }
9538       }
9539       else
9540       {
9541          memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9542       }
9543    }
9544 }
9545
9546 /*******************************************************************
9547  *
9548  * @brief Function to extract cellGrp Info present in cutoDu cont
9549  *
9550  * @details
9551  *
9552  *    Function : extractCellGrpInfo
9553  *
9554  *    Functionality: Function to extract cellGrp Info present
9555  *                   in cutoDu cont
9556  *
9557  * @params[in] ProtocolExtensionContainer_4624P16_t pointer
9558  *
9559  * @return CellGroupConfigRrc_t *
9560  *
9561  * ****************************************************************/
9562
9563 CellGroupConfigRrc_t *extractCellGrpInfo(ProtocolExtensionContainer_4624P16_t *protocolIeExtn,\
9564       DuUeCfg *ueCfgDb)
9565 {
9566    uint8_t idx2 =0;
9567    uint16_t id =0;
9568    uint16_t recvBufLen =0;
9569    CellGroupConfigRrc_t *cellGrpCfg = NULLP;
9570    CUtoDURRCInformation_ExtIEs_t *extIeInfo = NULLP;
9571    asn_dec_rval_t rval; /* Decoder return value */
9572    memset(&rval, 0, sizeof(asn_dec_rval_t));
9573
9574    if(protocolIeExtn)
9575    {
9576       for(idx2 = 0; idx2 < protocolIeExtn->list.count; idx2++)
9577       {
9578          extIeInfo = ((CUtoDURRCInformation_ExtIEs_t *)(protocolIeExtn->list.array[idx2]));
9579          id = extIeInfo->id;
9580          switch(id)
9581          {
9582             case ProtocolIE_ID_id_CellGroupConfig:
9583             {
9584                recvBufLen = extIeInfo->extensionValue.choice.CellGroupConfig.size;
9585                /* decoding the CellGroup Buf received */
9586                DU_ALLOC(cellGrpCfg, sizeof(CellGroupConfigRrc_t));
9587                if(cellGrpCfg)
9588                {
9589                   memset(cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
9590                   rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfg,
9591                      extIeInfo->extensionValue.choice.CellGroupConfig.buf, recvBufLen, 0, 0);
9592                   if(rval.code == RC_FAIL || rval.code == RC_WMORE)
9593                   {
9594                      DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
9595                      return NULLP;
9596                   }
9597                   xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfg);
9598                   if(extractRlcCfgToAddMod(cellGrpCfg->rlc_BearerToAddModList, ueCfgDb))
9599                      return NULLP;
9600                }
9601                break;
9602             }
9603             default:
9604                DU_LOG("\nERROR  -->  F1AP : Invalid IE received CUtoDURRCInformation:%d at decodeCellGrpCfg()", id);
9605                break;
9606          }
9607       }
9608    }
9609    return cellGrpCfg;
9610 }
9611
9612 /*******************************************************************
9613  *
9614  * @brief Fills Srb List received by CU
9615  *
9616  * @details
9617  *
9618  *    Function : procSrbListToSetup
9619  *
9620  *    Functionality: Fills Srb List received  by CU
9621  *
9622  * @params[in] SRBs_ToBeSetup_Item_t *cuSrbItem
9623  *             LcCfg pointer
9624  *             RlcBearerCfg pointer
9625  * @return void
9626  *
9627  * ****************************************************************/
9628 uint8_t procSrbListToSetup(SRBs_ToBeSetup_Item_t * srbItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd)
9629 {
9630    uint8_t ret = ROK;
9631
9632    /* Filling RLC INFO */
9633    procRlcLcCfg(srbItem->sRBID, srbItem->sRBID, RB_TYPE_SRB, RLC_AM, CONFIG_ADD, NULL, rlcLcToAdd);
9634
9635    /* Filling MAC INFO */
9636    ret = procMacLcCfg(srbItem->sRBID, RB_TYPE_SRB, CONFIG_ADD, NULL,NULL, NULL, macLcToAdd, NULL);
9637    if(ret == RFAILED)
9638    {
9639       DU_LOG("\nERROR  -->  F1AP : Failed at MAC LC Cfg in procSrbListToSetup()");
9640       return ret;
9641    }
9642    return ret;
9643 }
9644
9645
9646
9647 /*******************************************************************
9648  *
9649  * @brief extract Srb List received by CU
9650  *
9651  * @details
9652  *
9653  *    Function : extractSrbListToSetup
9654  *
9655  *    Functionality: extract Srb List received by CU
9656  *                   for both MAC and RLC
9657  *
9658  * @params[in] SRBs_ToBeSetup_Item_t pointer
9659  *             DuUeCfg pointer
9660  * @return ROK/RFAIED
9661  *
9662  * ****************************************************************/
9663
9664 uint8_t extractSrbListToSetup(SRBs_ToBeSetup_List_t *srbCfg, DuUeCfg *ueCfgDb)
9665 {
9666    uint8_t ret, srbIdx;
9667    SRBs_ToBeSetup_Item_t *srbItem = NULLP;
9668
9669    if(srbCfg)
9670    {
9671       for(srbIdx = 0; srbIdx < srbCfg->list.count; srbIdx++)
9672       {
9673          srbItem = &srbCfg->list.array[srbIdx]->value.choice.SRBs_ToBeSetup_Item;
9674          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
9675          {
9676             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in MAC");
9677             ret = RFAILED;
9678             break;
9679          }
9680          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
9681          {
9682             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in RLC");
9683             ret = RFAILED;
9684             break;
9685          }
9686          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
9687          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
9688          ret = procSrbListToSetup(srbItem, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
9689             &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs]);
9690          ueCfgDb->numRlcLcs++;
9691          ueCfgDb->numMacLcs++;
9692          if(ret == RFAILED)
9693          {
9694             DU_LOG("\nERROR  -->  F1AP:  Failed at extractSrbListToSetup()");
9695             break;
9696          }
9697       }
9698    }
9699    else
9700       ret = RFAILED;
9701
9702    return ret;
9703 }
9704
9705 /*******************************************************************
9706  *
9707  * @brief Fills Drb List received by CU
9708  *
9709  * @details
9710  *
9711  *    Function : procDrbListToSetup
9712  *
9713  *    Functionality: Fills Drb List received by CU
9714  *                   for both MAC and RLC
9715  *
9716  * @params[in] SRBs_ToBeSetup_Item_t pointer
9717  *             LcCfg pointer,
9718  *             RlcBearerCfg pointer
9719  * @return void
9720  *
9721  * ****************************************************************/
9722
9723 uint8_t procDrbListToSetup(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbItem,\
9724 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd, UpTnlCfg *upTnlInfo)
9725 {
9726
9727    if(drbItem != NULLP)
9728    {
9729       /* Filling RLC INFO */
9730       procRlcLcCfg(drbItem->dRBID, lcId, RB_TYPE_DRB, drbItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd);
9731
9732       /* Filling MAC INFO */
9733       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, drbItem, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
9734       {
9735          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetup()");
9736          return RFAILED;
9737       }
9738    }
9739    else if(drbSetupModItem != NULLP)
9740    {
9741       procRlcLcCfg(drbSetupModItem->dRBID, lcId, RB_TYPE_DRB, drbSetupModItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd);
9742
9743       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, NULL, drbSetupModItem, NULL, macLcToAdd, upTnlInfo) != ROK)
9744       {
9745          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetup()");
9746          return RFAILED;
9747       }
9748    }
9749    return ROK;
9750 }
9751
9752 /*******************************************************************
9753  *
9754  * @brief extract Drb List received by CU
9755  *
9756  * @details
9757  *
9758  *    Function : extractDrbListToSetup
9759  *
9760  *    Functionality: extract Drb List received by CU
9761  *                   for both MAC and RLC
9762  *
9763  * @params[in] DRBs_ToBeSetup_Item_t pointer
9764  *             DuUeCfg pointer
9765  * @return ROK/RFAIED
9766  *
9767  * ****************************************************************/
9768
9769 uint8_t extractDrbListToSetup(uint8_t lcId, DRBs_ToBeSetup_List_t *drbCfg,DRBs_ToBeSetupMod_List_t *drbSetupModCfg,\
9770 uint8_t drbCount, DuUeCfg *ueCfgDb)
9771 {
9772    uint8_t ret, drbIdx;
9773    DRBs_ToBeSetup_Item_t *drbItem = NULLP;
9774    DRBs_ToBeSetupMod_ItemIEs_t *drbSetupModItem = NULLP;
9775
9776    ret = ROK;
9777    if(drbCount > 0)
9778    {
9779       for(drbIdx = 0; drbIdx < drbCount; drbIdx++)
9780       {
9781          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
9782          {
9783             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in MAC at extractDrbListToSetup()");
9784             ret = RFAILED;
9785             break;
9786          }
9787          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
9788          {
9789             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in RLC at extractDrbListToSetup()");
9790             ret = RFAILED;
9791             break;
9792          }
9793          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
9794          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
9795
9796          if(drbCfg != NULL)
9797          {
9798             drbItem = &drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
9799             ret = procDrbListToSetup(lcId, drbItem, NULL, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
9800                &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], &ueCfgDb->upTnlInfo[ueCfgDb->numDrb]);
9801             if(ret == RFAILED)
9802             {
9803                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetup()");
9804                break;
9805             }
9806          }
9807          else if(drbSetupModCfg != NULL)
9808          {
9809             drbSetupModItem = (DRBs_ToBeSetupMod_ItemIEs_t *) drbSetupModCfg->list.array[drbIdx];
9810             ret = procDrbListToSetup(lcId, NULL, &(drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item) ,\
9811             &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs],\
9812             &ueCfgDb->upTnlInfo[ueCfgDb->numDrb]);
9813             if(ret == RFAILED)
9814             {
9815                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetup()");
9816                break;
9817             }
9818          }
9819          ueCfgDb->numRlcLcs++;
9820          ueCfgDb->numMacLcs++;
9821          ueCfgDb->numDrb++;
9822          if(ret == RFAILED)
9823          {
9824             DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetup()");
9825             break;
9826          }
9827       }
9828    }
9829    else
9830       ret = RFAILED;
9831
9832    return ret;
9833 }
9834
9835 /*******************************************************************
9836  *
9837  * @brief Function to extract Dl RRC Msg received from CU
9838  *
9839  * @details
9840  *
9841  *    Function : extractDlRrcMsg
9842  *
9843  *    Functionality: Function to extract Dl RRC Msg received from CU
9844  *
9845  * @params[in] F1AP message
9846  * @return ROK     - success
9847  *         RFAILED - failure
9848  *
9849  * ****************************************************************/
9850
9851 uint8_t extractDlRrcMsg(uint32_t gnbDuUeF1apId, uint32_t gnbCuUeF1apId, \
9852    F1DlRrcMsg *dlRrcMsg, RRCContainer_t *rrcContainer)
9853 {
9854    uint8_t ret = ROK;
9855    dlRrcMsg->rrcMsgSize = rrcContainer->size;
9856    if(dlRrcMsg->rrcMsgSize > 0)
9857    {
9858       DU_ALLOC_SHRABL_BUF(dlRrcMsg->rrcMsgPdu, dlRrcMsg->rrcMsgSize);
9859       if(!dlRrcMsg->rrcMsgPdu)
9860       {
9861          DU_LOG("\nERROR  --> DU APP : Memory allocation failed for RRC Msg in extractDlRrcMsg()");
9862          ret = RFAILED;
9863       }
9864       else
9865       {
9866          dlRrcMsg->gnbDuUeF1apId = gnbDuUeF1apId;
9867          dlRrcMsg->gnbCuUeF1apId = gnbCuUeF1apId;
9868          dlRrcMsg->srbId = SRB1_LCID;
9869          memcpy(dlRrcMsg->rrcMsgPdu, rrcContainer->buf, dlRrcMsg->rrcMsgSize);
9870       }
9871    }
9872    return ret;
9873 }
9874
9875 /*******************************************************************
9876  *
9877  * @brief Extract UE capability info
9878  *
9879  * @details
9880  *
9881  *    Function : extractUeCapability
9882  *
9883  *    Functionality: Extract UE capability info and stores in ue Cb
9884  *
9885  * @params[in] Octet string of UE capability RAT container list
9886  * @return ROK     - success
9887  *         RFAILED - failure
9888  *
9889  * ****************************************************************/
9890 UE_NR_Capability_t *extractUeCapability(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf, DuUeCb *ueCb)
9891 {
9892    uint8_t  idx;
9893    uint16_t recvBufLen;
9894    asn_dec_rval_t rval;
9895    UE_NR_Capability_t  *ueNrCap = NULLP;
9896    UE_CapabilityRAT_ContainerListRRC_t  *ueCapRatContList = NULLP;
9897
9898    /* Decoding UE Capability RAT Container List */
9899    recvBufLen = ueCapablityListBuf->size;
9900    DU_ALLOC(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
9901    if(!ueCapRatContList)
9902    {
9903       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
9904       return NULLP;
9905    }
9906    memset(ueCapRatContList, 0, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
9907    memset(&rval, 0, sizeof(asn_dec_rval_t));
9908    rval = aper_decode(0, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, (void **)&ueCapRatContList,
9909           ueCapablityListBuf->buf, recvBufLen, 0, 0);
9910    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
9911    {
9912       DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
9913       return NULLP;
9914    }
9915    xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, ueCapRatContList);
9916
9917    /* Free encoded buffer after decoding */
9918
9919    for(idx = 0; idx < ueCapRatContList->list.count; idx++)
9920    {
9921       if(ueCapRatContList->list.array[idx]->rat_Type == RAT_Type_nr)
9922       {
9923          /* Decoding UE NR Capability */
9924           recvBufLen = ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.size;
9925           DU_ALLOC(ueNrCap, sizeof(UE_NR_Capability_t));
9926           if(!ueNrCap)
9927           {
9928              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
9929              DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
9930              return NULLP;
9931           }
9932           memset(ueNrCap, 0, sizeof(UE_NR_Capability_t));
9933           memset(&rval, 0, sizeof(asn_dec_rval_t));
9934           rval = aper_decode(0, &asn_DEF_UE_NR_Capability, (void **)&ueNrCap,
9935                  ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf, recvBufLen, 0, 0);
9936           if(rval.code == RC_FAIL || rval.code == RC_WMORE)
9937           {
9938              DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
9939              return NULLP;
9940           }
9941           xer_fprint(stdout, &asn_DEF_UE_NR_Capability, ueNrCap);
9942
9943           /* Free encoded buffer after decoding */
9944           free(ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf);
9945       }
9946       free(ueCapRatContList->list.array[idx]);
9947    }
9948
9949    /* Free Memory*/
9950    free(ueCapRatContList->list.array);
9951    DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
9952    return ueNrCap;
9953 }
9954
9955 /*******************************************************************
9956 *
9957 * @brief free UE context setup request from CU
9958 *
9959 * @details
9960 *
9961 *    Function : freeAperDecodeF1UeContextSetupReq
9962 *
9963 *    Functionality: freeing part for the memory allocated by aper_decoder
9964 *
9965 * @params[in] F1AP message
9966 * @return ROK     - success
9967 *         RFAILED - failure
9968 *
9969 * ****************************************************************/
9970 void freeAperDecodeF1UeContextSetupReq(UEContextSetupRequest_t   *ueSetReq)
9971 {
9972    uint8_t ieIdx = 0;
9973
9974    if(ueSetReq->protocolIEs.list.array != NULLP)
9975    {
9976       for(ieIdx = 0; ieIdx < ueSetReq->protocolIEs.list.count; ieIdx++)
9977       {
9978          if(ueSetReq->protocolIEs.list.array[ieIdx])
9979          {
9980             switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
9981             {
9982                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
9983                   break;
9984                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
9985                   break;
9986                case ProtocolIE_ID_id_SpCell_ID:
9987                   freeAperDecodeNrcgi(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
9988                   break;
9989                case ProtocolIE_ID_id_ServCellIndex:
9990                   break;
9991                case ProtocolIE_ID_id_SpCellULConfigured:
9992                   break;
9993                case ProtocolIE_ID_id_CUtoDURRCInformation:
9994
9995                   freeAperDecodeCuToDuInfo(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation);
9996                   break;
9997                case ProtocolIE_ID_id_SCell_ToBeSetup_List:
9998
9999                   freeAperDecodeSplCellList(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SCell_ToBeSetup_List);
10000                   break;
10001                case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
10002
10003                   freeAperDecodeSRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List);
10004                   break;
10005                case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
10006
10007                   freeAperDecodeDRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List);
10008                   break;
10009                case ProtocolIE_ID_id_RRCContainer:
10010                   {
10011
10012                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf != NULLP)
10013                      {
10014
10015                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
10016                      }
10017                      break;
10018                   }
10019                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10020                   break;
10021                case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
10022                   {
10023                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf)
10024                      {
10025                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf);
10026                      }
10027                      break;
10028                   }
10029                default:
10030                   DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld " ,ueSetReq->protocolIEs.list.array[ieIdx]->id);
10031             }
10032             free(ueSetReq->protocolIEs.list.array[ieIdx]);
10033          }
10034       }
10035       free(ueSetReq->protocolIEs.list.array);
10036    }
10037 }
10038 /*******************************************************************
10039  *
10040  * @brief Process UE context setup request from CU
10041  *
10042  * @details
10043  *
10044  *    Function : procF1UeContextSetupReq
10045  *
10046  *    Functionality: Process UE context setup request from CU
10047  *
10048  * @params[in] F1AP message
10049  * @return ROK     - success
10050  *         RFAILED - failure
10051  *
10052  * ****************************************************************/
10053 uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
10054 {
10055    uint8_t  ret=0, ieIdx=0, ueIdx=0, lcId=0, cellIdx=0;
10056    bool ueCbFound = false;
10057    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0, bitRateSize=0;
10058    DuUeCb   *duUeCb = NULL;
10059    UEContextSetupRequest_t   *ueSetReq = NULL;
10060    DRBs_ToBeSetup_List_t *drbCfg = NULL;
10061
10062    ret = ROK;
10063
10064    ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
10065    for(ieIdx=0; (ieIdx < ueSetReq->protocolIEs.list.count && ret == ROK); ieIdx++)
10066    {
10067       switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
10068       {
10069          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10070             {
10071                gnbCuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
10072                break;
10073             }
10074          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10075             {
10076                gnbDuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
10077                break;
10078             }
10079          case ProtocolIE_ID_id_ServCellIndex:
10080             {
10081                cellIdx = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.ServCellIndex;
10082                for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
10083                {
10084                   if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
10085                         (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
10086                   {
10087                      ueCbFound = true;
10088                      duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
10089                      DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
10090                      if(duUeCb->f1UeDb)
10091                      {
10092                         memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
10093                         duUeCb->f1UeDb->actionType = UE_CTXT_SETUP;
10094                         duUeCb->f1UeDb->cellIdx = cellIdx;
10095                      }
10096                      else
10097                      {
10098                         DU_LOG("\nERROR  -->  F1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
10099                         ret = RFAILED;
10100                      }
10101                   }
10102                   else
10103                      ueCbFound = false;
10104
10105                }
10106                if(!ueCbFound)
10107                {
10108                   DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
10109                   ret = RFAILED;
10110                }
10111                break;
10112             }
10113          case ProtocolIE_ID_id_SpCellULConfigured:
10114             /* Indicates whether the gNB-CU requests the gNB-DU to configure the uplink as no UL,
10115                UL, SUL or UL+SUL for the indicated cell for the UE */
10116             break;
10117          case ProtocolIE_ID_id_CUtoDURRCInformation:
10118             {
10119                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.uE_CapabilityRAT_ContainerList)
10120                {
10121                   duUeCb->f1UeDb->duUeCfg.ueNrCapability = \
10122                   extractUeCapability(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.\
10123                   uE_CapabilityRAT_ContainerList, duUeCb);
10124                }
10125                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.iE_Extensions)
10126                {
10127                   duUeCb->f1UeDb->duUeCfg.cellGrpCfg = extractCellGrpInfo(ueSetReq->protocolIEs.list.array[ieIdx]->\
10128                         value.choice.CUtoDURRCInformation.iE_Extensions, &duUeCb->f1UeDb->duUeCfg);
10129                   if(!duUeCb->f1UeDb->duUeCfg.cellGrpCfg)
10130                   {
10131                      DU_LOG("\nERROR  -->  F1AP: Failed to extract cell Grp Info");
10132                      //TODO: Update the failure cause in ue context Setup Response
10133                      ret = RFAILED;
10134                   }
10135                }
10136                break;
10137             }
10138          case ProtocolIE_ID_id_SCell_ToBeSetup_List:
10139             {
10140                DU_LOG("\nINFO   -->  DU_APP: Received SCell_ToBeSetup_List but  Not processing the list");
10141                break;
10142             }
10143          case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
10144             {
10145                if(extractSrbListToSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List,\
10146                &duUeCb->f1UeDb->duUeCfg))
10147                {
10148                   DU_LOG("\nERROR  -->  DU APP : Failed at extractSrbListToSetup()");
10149                   //TODO: Update the failure cause in ue context Setup Response
10150                   ret = RFAILED;
10151                }
10152                break;
10153             }
10154          case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
10155             {
10156                lcId = getDrbLcId(&duUeCb->drbBitMap);
10157                if(lcId != RFAILED)
10158                {
10159                   drbCfg = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List;
10160                   if(extractDrbListToSetup(lcId, drbCfg, NULL, drbCfg->list.count, &duUeCb->f1UeDb->duUeCfg))
10161                   {
10162                      DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetup()");
10163                      //TODO: Update the failure cause in ue context Setup Response
10164                      ret = RFAILED;
10165                   }
10166                }
10167                else
10168                   ret = RFAILED;
10169                break;
10170             }
10171          case ProtocolIE_ID_id_RRCContainer:
10172             {
10173                /* Filling Dl RRC Msg Info */
10174                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
10175                if(!duUeCb->f1UeDb->dlRrcMsg)
10176                {
10177                   DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
10178                   ret = RFAILED;
10179                }
10180                else
10181                {
10182                   duUeCb->f1UeDb->dlRrcMsgPres = true;
10183                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
10184                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
10185                         &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer);
10186                }
10187                break;
10188             }
10189          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10190             {
10191                if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
10192                {
10193                   duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
10194                }
10195                else
10196                {
10197                   DU_LOG("\nERROR  -->  Ignoring delivery report, since rrcContainer is not present");
10198                }
10199                break;
10200             }
10201          case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
10202             {
10203                /* MaximumBitRate Uplink */
10204                bitRateSize = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.size;
10205                if(bitRateSize > 0)
10206                {
10207                   DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.ambrCfg, bitRateSize);
10208                   if(!duUeCb->f1UeDb->duUeCfg.ambrCfg)
10209                   {
10210                      DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
10211                      ret = RFAILED;
10212                   }
10213                   else
10214                   {
10215                      memset(duUeCb->f1UeDb->duUeCfg.ambrCfg, 0, sizeof(AmbrCfg));
10216                      memcpy(&duUeCb->f1UeDb->duUeCfg.ambrCfg->ulBr,
10217                            ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf, bitRateSize);
10218                   }
10219                }
10220                else
10221                   ret = RFAILED;
10222                break;
10223             }
10224          default:
10225             {
10226                break;
10227             }
10228       }
10229    }
10230    if(ret == RFAILED)
10231    {
10232       /*TODO : Negative case*/
10233       // BuildAndSendUeContextSetupRsp(cellId,ueIdx);
10234       DU_LOG("\nERROR  -->  F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
10235    }
10236    else
10237       ret = duProcUeContextSetupRequest(duUeCb);
10238
10239    freeAperDecodeF1UeContextSetupReq(ueSetReq);
10240    return ret;
10241
10242 }
10243 /*******************************************************************
10244  * @brief Free the memory allocated for Dl Tunnel Info
10245  *
10246  * @details
10247  *
10248  *    Function : freeDlTnlInfo
10249  *
10250  *    Functionality:
10251  *       Free the memory allocated for Dl Tunnel Info
10252  *
10253  * @params[in] DLUPTNLInformation_ToBeSetup_List_t *
10254  * @return void
10255  *
10256  * ****************************************************************/
10257
10258 void freeDlTnlInfo(DLUPTNLInformation_ToBeSetup_List_t *tnlInfo)
10259 {
10260    uint8_t arrIdx = 0;
10261
10262    if(tnlInfo)
10263    {
10264       for(arrIdx=0; arrIdx < tnlInfo->list.count; arrIdx++)
10265       {
10266          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf,\
10267                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
10268          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf,\
10269                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
10270          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
10271          DU_FREE(tnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
10272       }
10273       DU_FREE(tnlInfo->list.array, tnlInfo->list.size);
10274    }
10275 }
10276
10277 /*******************************************************************
10278  * @brief Free the memory allocated for DRB setup List
10279  *
10280  * @details
10281  *
10282  *    Function : freeDrbSetupList
10283  *
10284  *    Functionality:
10285  *       Free the memory allocated for DRB setup list
10286  *
10287  * @params[in] DRBs_Setup_List_t *
10288  * @return void
10289  *
10290  * ****************************************************************/
10291 void freeDrbSetupList(DRBs_Setup_List_t *drbSetupList)
10292 {
10293    uint8_t arrIdx = 0;
10294    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
10295
10296    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
10297    {
10298       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
10299       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
10300       DU_FREE(drbSetupList->list.array[arrIdx],  sizeof(DRBs_Setup_Item_t));
10301    }
10302    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
10303 }
10304
10305 /*******************************************************************
10306  * @brief Free the memory allocated for UE Setup response
10307  *
10308  * @details
10309  *
10310  *    Function : FreeUeContextSetupRsp
10311  *
10312  *    Functionality:
10313  *       Free the memory allocated for UE Setup response
10314  *
10315  * @params[in] F1AP PDU for UE setup response
10316  * @return ROK     - success
10317  *         RFAILED - failure
10318  *
10319  * ****************************************************************/
10320 void FreeUeContextSetupRsp(F1AP_PDU_t *f1apMsg)
10321 {
10322    uint8_t idx;
10323    UEContextSetupResponse_t *ueSetRsp = NULLP;
10324
10325    if(f1apMsg)
10326    {
10327       if(f1apMsg->choice.successfulOutcome)
10328       {
10329          ueSetRsp = &f1apMsg->choice.successfulOutcome->value.choice.\
10330                     UEContextSetupResponse;
10331          if(ueSetRsp->protocolIEs.list.array)
10332          {
10333             for(idx = 0; idx < ueSetRsp->protocolIEs.list.count; idx++)
10334             {
10335                if(ueSetRsp->protocolIEs.list.array[idx])
10336                {
10337                   switch(ueSetRsp->protocolIEs.list.array[idx]->id)
10338                   {
10339                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10340                         break;
10341                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10342                         break;
10343                      case ProtocolIE_ID_id_DUtoCURRCInformation:
10344                         {
10345                            CellGroupConfig_t *cellGrpCfg = NULLP;
10346                            cellGrpCfg  = &ueSetRsp->protocolIEs.list.array[idx]->value.choice.\
10347                                          DUtoCURRCInformation.cellGroupConfig;
10348                            if(cellGrpCfg->buf != NULLP)
10349                            {
10350                               DU_FREE(cellGrpCfg->buf, cellGrpCfg->size);
10351                               cellGrpCfg = NULLP;
10352                            }
10353                            break;
10354                         }
10355                     case ProtocolIE_ID_id_DRBs_Setup_List:
10356                         {
10357                            freeDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
10358                            break;
10359                         }
10360                      default:
10361                         DU_LOG("\nERROR  -->  DUAPP: Invalid Id %ld at FreeUeContextSetupRsp()",\
10362                         ueSetRsp->protocolIEs.list.array[idx]->id);
10363                         break;
10364                   }
10365                   DU_FREE(ueSetRsp->protocolIEs.list.array[idx],\
10366                         sizeof(UEContextSetupResponseIEs_t));
10367                }
10368             }
10369             DU_FREE(ueSetRsp->protocolIEs.list.array, \
10370                   ueSetRsp->protocolIEs.list.size);
10371          }
10372          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
10373       }
10374       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10375    }
10376 }
10377
10378 /*******************************************************************
10379  *
10380  * @brief Builds Ue context Setup Rsp DU To CU Info
10381  *
10382  * @details
10383  *
10384  *    Function : EncodeUeCntxtDuToCuInfo
10385  *
10386  *    Functionality: Builds Ue context Setup Rsp DU To CU Info
10387  *
10388  * @params[in] CellGroupConfig_t *, CellGroupConfigRrc_t *
10389  *
10390  * @return ROK     - success
10391  *         RFAILED - failure
10392  *
10393  ******************************************************************/
10394
10395 uint8_t EncodeUeCntxtDuToCuInfo(CellGroupConfig_t *duToCuCellGrp, CellGroupConfigRrc_t *duCellGrpCfg)
10396 {
10397    asn_enc_rval_t        encRetVal;
10398
10399    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, duCellGrpCfg);
10400    memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
10401    encBufSize = 0;
10402    encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, duCellGrpCfg, PrepFinalEncBuf, encBuf);
10403    /* Encode results */
10404    if(encRetVal.encoded == ENCODE_FAIL)
10405    {
10406       DU_LOG( "\nERROR  -->  F1AP : Could not encode UeCntxtDuToCuInfo (at %s)\n",\
10407             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10408       return RFAILED;
10409    }
10410    else
10411    {
10412       DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
10413       for(int i=0; i< encBufSize; i++)
10414       {
10415          printf("%x",encBuf[i]);
10416       }
10417    }
10418    duToCuCellGrp->size = encBufSize;
10419    DU_ALLOC(duToCuCellGrp->buf, duToCuCellGrp->size);
10420    if(!duToCuCellGrp->buf)
10421    {
10422       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in UeCntxtDuToCuInfo");
10423    }
10424    memcpy(duToCuCellGrp->buf, encBuf, duToCuCellGrp->size);
10425    return ROK;
10426 }
10427
10428 /*******************************************************************
10429  *
10430  * @brief Fills Dl Gtp tunnel Info
10431  *
10432  * @details
10433  *
10434  *    Function : fillGtpTunnelforDl
10435  *
10436  *    Functionality: Fills Dl Gtp tunnel Info
10437  *
10438  * @params[in]
10439  *
10440  * @return ROK     - success
10441  *         RFAILED - failure
10442  *
10443  * ****************************************************************/
10444
10445 uint8_t fillGtpTunnelforDl(GTPTunnel_t *gtpDl, GtpTnlCfg *gtpUeCfg)
10446 {
10447    uint8_t bufSize = 0;
10448
10449    gtpDl->transportLayerAddress.size    = 4*sizeof(uint8_t);
10450    DU_ALLOC(gtpDl->transportLayerAddress.buf, gtpDl->transportLayerAddress.size);
10451    if(gtpDl->transportLayerAddress.buf == NULLP)
10452    {
10453       return RFAILED;
10454    }
10455    memcpy(gtpDl->transportLayerAddress.buf, &gtpUeCfg->dlTnlAddress, gtpDl->transportLayerAddress.size);
10456
10457    /*GTP TEID*/
10458    gtpDl->gTP_TEID.size = 4 * sizeof(uint8_t);
10459    DU_ALLOC(gtpDl->gTP_TEID.buf, gtpDl->gTP_TEID.size);
10460    if(gtpDl->gTP_TEID.buf == NULLP)
10461    {
10462       return RFAILED;
10463    }
10464    bufSize = 3; /*forming an Octect String*/
10465    fillTeIdString(bufSize, gtpUeCfg->teId, gtpDl->gTP_TEID.buf);
10466
10467    return ROK;
10468 }
10469
10470 /*******************************************************************
10471  *
10472  * @brief Fills DL Tunnel Setup List
10473  *
10474  * @details
10475  *
10476  *    Function : fillDlTnlSetupList
10477  *
10478  *    Functionality: Fills the DL Tunnel Setup List
10479  *
10480  * @params[in]
10481  *
10482  * @return ROK     - success
10483  *         RFAILED - failure
10484  *
10485  * ****************************************************************/
10486
10487 uint8_t fillDlTnlSetupList(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo, UpTnlCfg *tnlCfg)
10488 {
10489    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
10490
10491    eleCount = 1;
10492    dlTnlInfo->list.count = eleCount;
10493    dlTnlInfo->list.size = (eleCount * sizeof(DLUPTNLInformation_ToBeSetup_Item_t *));
10494
10495    /* Initialize the DL Tnl Setup List Members */
10496    DU_ALLOC(dlTnlInfo->list.array, dlTnlInfo->list.size);
10497    if(dlTnlInfo->list.array == NULLP)
10498    {
10499       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL Tnl Setup List in fillDlTnlSetupList()");
10500       ret = RFAILED;
10501    }
10502    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
10503    {
10504       DU_ALLOC(dlTnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
10505       if(dlTnlInfo->list.array[arrIdx] == NULLP)
10506       {
10507          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDlTnlSetupList()", arrIdx);
10508          return RFAILED;
10509       }
10510       dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
10511       DU_ALLOC(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
10512       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel == NULLP)
10513       {
10514          DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL tunnel info in fillDlTnlSetupList()");
10515          return RFAILED;
10516       }
10517       ret = fillGtpTunnelforDl(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel,\
10518                tnlCfg->tnlCfg1);
10519       if(ret != ROK)
10520          break;
10521    }
10522    return ret;
10523 }
10524
10525 /*******************************************************************
10526  *
10527  * @brief Fills the Drb Setup List for Ue Context Setup Response
10528  *
10529  * @details
10530  *
10531  *    Function : fillDrbSetupList
10532  *
10533  *    Functionality: Fills the Drb Setup List for Ue Context Setup Response
10534  *
10535  * @params[in]
10536  *
10537  * @return ROK     - success
10538  *         RFAILED - failure
10539  *
10540  * ****************************************************************/
10541 uint8_t fillDrbSetupList(DRBs_Setup_List_t *drbSetupList, DuUeCfg *ueCfg)
10542 {
10543    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
10544    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
10545
10546    eleCount = ueCfg->numDrb;
10547    drbSetupList->list.count = eleCount;
10548    drbSetupList->list.size = \
10549         (eleCount * sizeof(DRBs_Setup_Item_t *));
10550
10551    /* Initialize the Drb Setup List Members */
10552    DU_ALLOC(drbSetupList->list.array, drbSetupList->list.size);
10553    if(drbSetupList->list.array == NULLP)
10554    {
10555       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DRB Setup List in fillDrbSetupList()");
10556       ret = RFAILED;
10557    }
10558
10559    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
10560    {
10561       DU_ALLOC(drbSetupList->list.array[arrIdx], sizeof(DRBs_Setup_Item_t));
10562       if(drbSetupList->list.array[arrIdx] == NULLP)
10563       {
10564          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDrbSetupList()", arrIdx);
10565          return RFAILED;
10566       }
10567       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
10568       drbItemIe->id = ProtocolIE_ID_id_DRBs_Setup_Item;
10569       drbItemIe->criticality = Criticality_reject;
10570       drbItemIe->value.present = DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item;
10571       drbItemIe->value.choice.DRBs_Setup_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
10572       ret = fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List,\
10573           &ueCfg->upTnlInfo[arrIdx]);
10574       if(ret != ROK)
10575          break;
10576    }
10577    return ret;
10578 }
10579
10580 /*******************************************************************
10581  *
10582  * @brief Builds and sends the UE Setup Response
10583  *
10584  * @details
10585  *
10586  *    Function : BuildAndSendUeContextSetupRsp
10587  *
10588  *    Functionality: Constructs the UE Setup Response and sends
10589  *                   it to the DU through SCTP.
10590  *
10591  * @params[in] uint8_t cellId,uint8_t ueIdx
10592  *
10593  * @return ROK     - success
10594  *         RFAILED - failure
10595  *
10596  * ****************************************************************/
10597 uint8_t BuildAndSendUeContextSetupRsp(uint8_t cellId,uint8_t ueIdx)
10598 {
10599    uint8_t   idx, ret, cellIdx, elementCnt;
10600    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
10601    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
10602    asn_enc_rval_t  encRetVal;        /* Encoder return value */
10603    F1AP_PDU_t               *f1apMsg = NULLP;
10604    UEContextSetupResponse_t *ueSetRsp = NULLP;
10605    CellGroupConfigRrc_t     *cellGrpCfg = NULLP;
10606    DuUeCb                   *ueCb = NULLP;
10607
10608    DU_LOG("\n INFO   -->  F1AP : Building UE Context Setup Response for cellId %d, ueIdx %d\n", cellId, ueIdx);
10609
10610    while(true)
10611    {
10612       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10613       if(f1apMsg == NULLP)
10614       {
10615          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
10616          ret = RFAILED;
10617          break;
10618       }
10619
10620       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
10621       DU_ALLOC(f1apMsg->choice.successfulOutcome,
10622             sizeof(SuccessfulOutcome_t));
10623       if(f1apMsg->choice.successfulOutcome == NULLP)
10624       {
10625          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
10626          ret = RFAILED;
10627          break;
10628       }
10629
10630       f1apMsg->choice.successfulOutcome->procedureCode = \
10631                                                          ProcedureCode_id_UEContextSetup;
10632       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
10633       f1apMsg->choice.successfulOutcome->value.present = \
10634                                                          SuccessfulOutcome__value_PR_UEContextSetupResponse;
10635
10636       ueSetRsp =
10637          &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
10638       elementCnt = 4;
10639       ueSetRsp->protocolIEs.list.count = elementCnt;
10640       ueSetRsp->protocolIEs.list.size = \
10641                                         elementCnt * sizeof(UEContextSetupResponse_t *);
10642
10643       /* Initialize the UESetup members */
10644       DU_ALLOC(ueSetRsp->protocolIEs.list.array, \
10645             ueSetRsp->protocolIEs.list.size);
10646       if(ueSetRsp->protocolIEs.list.array == NULLP)
10647       {
10648          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
10649          ret = RFAILED;
10650          break;
10651       }
10652
10653       for(idx=0; idx<elementCnt; idx++)
10654       {
10655          DU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
10656                sizeof(UEContextSetupResponseIEs_t));
10657          if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
10658          {
10659             DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
10660             ret = RFAILED;
10661             break;
10662          }
10663       }
10664       /* Fetching Ue Cb Info*/
10665       GET_CELL_IDX(cellId, cellIdx);
10666       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
10667       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
10668       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
10669
10670       idx = 0;
10671       /*GNB CU UE F1AP ID*/
10672       ueSetRsp->protocolIEs.list.array[idx]->id = \
10673                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
10674       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10675       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
10676                                                              UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
10677       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
10678
10679       /*GNB DU UE F1AP ID*/
10680       idx++;
10681       ueSetRsp->protocolIEs.list.array[idx]->id = \
10682                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
10683       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10684       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
10685                                                              UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
10686       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
10687
10688
10689       /*DUtoCURRC Information */
10690       idx++;
10691       ueSetRsp->protocolIEs.list.array[idx]->id  = \
10692                                                    ProtocolIE_ID_id_DUtoCURRCInformation;
10693       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10694       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
10695                                                             UEContextSetupResponseIEs__value_PR_DUtoCURRCInformation;
10696       if(ueCb->f1UeDb)
10697       {
10698          if(ueCb->f1UeDb->duUeCfg.cellGrpCfg)
10699          {
10700             cellGrpCfg = (CellGroupConfigRrc_t*)ueCb->f1UeDb->duUeCfg.cellGrpCfg;
10701             ret = EncodeUeCntxtDuToCuInfo(&ueSetRsp->protocolIEs.list.array[idx]->value.\
10702                      choice.DUtoCURRCInformation.cellGroupConfig, cellGrpCfg);
10703             if(ret == RFAILED)
10704             {
10705                DU_LOG("\nERROR  -->  F1AP : Failed to EncodeUeCntxtDuToCuInfo in BuildAndSendUeContextSetupRsp()");
10706                freeF1UeDb(ueCb->f1UeDb);
10707                ueCb->f1UeDb = NULLP;
10708                break;
10709             }
10710          }
10711       }
10712       else
10713       {
10714          DU_LOG("\nERROR  -->  F1AP : Failed to form DUtoCU RRCInfo at BuildAndSendUeContextSetupRsp()");
10715          ret = RFAILED;
10716          break;
10717       }
10718
10719       /* Drb Setup List */
10720       idx++;
10721       ueSetRsp->protocolIEs.list.array[idx]->id  = \
10722                                  ProtocolIE_ID_id_DRBs_Setup_List;
10723       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10724       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
10725                                  UEContextSetupResponseIEs__value_PR_DRBs_Setup_List;
10726       ret = fillDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List,\
10727                &ueCb->f1UeDb->duUeCfg);
10728       if(ret == RFAILED)
10729       {
10730          DU_LOG("\nERROR  -->  F1AP : Failed to fillDrbSetupList in BuildAndSendUeContextSetupRsp()");
10731          freeF1UeDb(ueCb->f1UeDb);
10732          ueCb->f1UeDb = NULLP;
10733          break;
10734       }
10735
10736        /* Free UeContext Db created during Ue context Req */
10737        freeF1UeDb(ueCb->f1UeDb);
10738        ueCb->f1UeDb = NULLP;
10739
10740       /* TODO: To send Drb list */
10741       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10742
10743       /* Encode the UE context setup response type as APER */
10744       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
10745       encBufSize = 0;
10746       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
10747             encBuf);
10748       /* Encode results */
10749       if(encRetVal.encoded == ENCODE_FAIL)
10750       {
10751          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Response structure (at %s)\n",\
10752                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10753          ret = RFAILED;
10754          break;
10755       }
10756       else
10757       {
10758          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Setup Response\n");
10759          for(int i=0; i< encBufSize; i++)
10760          {
10761             printf("%x",encBuf[i]);
10762          }
10763       }
10764
10765       /* Sending  msg  */
10766       if(sendF1APMsg()  != ROK)
10767       {
10768          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Response failed");
10769          ret = RFAILED;
10770          break;
10771       }
10772       break;
10773    }
10774    FreeUeContextSetupRsp(f1apMsg);
10775    return ret;
10776 }/* End of BuildAndSendUeContextSetupRsp */
10777 /*******************************************************************
10778 *
10779 * @brief  Build And Send Ue Context Rsp
10780 *
10781 * @details
10782 *
10783 *    Function : BuildAndSendUeCtxtRsp
10784 *
10785 *    Functionality : Build And Send Ue Context Rsp
10786
10787 * @params[in]
10788 * @return sucess = ROK
10789 *         failure = RFAILED
10790 *
10791 * ****************************************************************/
10792 uint8_t BuildAndSendUeCtxtRsp(uint8_t cellId, uint8_t ueIdx)
10793 {
10794    uint8_t cellIdx = 0, actionType = 0;
10795
10796    GET_CELL_IDX(cellId, cellIdx);
10797    actionType = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].f1UeDb->actionType;
10798
10799    switch(actionType)
10800    {
10801       case UE_CTXT_SETUP:
10802          {
10803             BuildAndSendUeContextSetupRsp(cellId,ueIdx);
10804             break;
10805          }
10806       case UE_CTXT_MOD:
10807          {
10808             BuildAndSendUeContextModRsp(cellId, ueIdx);
10809             break;
10810          }
10811       default:
10812          DU_LOG("ERROR  -->  F1AP: Invalid Action Type %d at BuildAndSendUeCtxtRsp()", actionType);
10813          break;
10814
10815    }
10816    return ROK;
10817 }
10818
10819 /*******************************************************************
10820  *
10821  * @brief deallocating the memory of  F1reset msg
10822  *
10823  * @details
10824  *
10825  *    Function : FreeF1ResetReq
10826  *
10827  *    Functionality :
10828  *         - freeing memory of F1reset request msg
10829  *
10830  * @params[in]
10831  * @return void
10832  *
10833  *
10834  * ****************************************************************/
10835 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
10836 {
10837    uint8_t idx =0 ;
10838    Reset_t *f1ResetMsg;
10839
10840    if(f1apMsg)
10841    {
10842       if(f1apMsg->choice.initiatingMessage)
10843       {
10844          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
10845
10846          if(f1ResetMsg->protocolIEs.list.array)
10847          {
10848             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
10849             {
10850                if(f1ResetMsg->protocolIEs.list.array[idx])
10851                {
10852                   DU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
10853                }
10854             }
10855             DU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
10856          }
10857          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10858       }
10859       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10860    }
10861 }
10862 /*******************************************************************
10863  *
10864  * @brief Build and Send F1reset request
10865  *
10866  * @details
10867  *
10868  *    Function : BuildAndSendF1ResetReq
10869  *
10870  *    Functionality:
10871  *         - Build and Send F1reset request msg
10872  *
10873  * @params[in]
10874  * @return ROK     - success
10875  *         RFAILED - failure
10876  *
10877  * ****************************************************************/
10878 uint8_t BuildAndSendF1ResetReq()
10879 {
10880    uint8_t          elementCnt=0;
10881    uint8_t          idx=0;
10882    uint8_t          ret= RFAILED;
10883    Reset_t          *f1ResetMsg = NULLP;
10884    F1AP_PDU_t       *f1apMsg = NULLP;
10885    asn_enc_rval_t   encRetVal;
10886    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset request \n");
10887    do
10888    {
10889       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10890       if(f1apMsg == NULLP)
10891       {
10892          break;
10893       }
10894       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
10895       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
10896       if(f1apMsg->choice.initiatingMessage == NULLP)
10897       {
10898          break;
10899       }
10900       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
10901       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
10902       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
10903
10904       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
10905
10906       elementCnt = 3;
10907       f1ResetMsg->protocolIEs.list.count = elementCnt;
10908       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
10909
10910       /* Initialize the F1Setup members */
10911       DU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
10912       if(f1ResetMsg->protocolIEs.list.array == NULLP)
10913       {
10914          break;
10915       }
10916       for(idx=0; idx<elementCnt; idx++)
10917       {
10918          DU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
10919          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
10920          {
10921             break;
10922          }
10923       }
10924
10925       /*TransactionID*/
10926       idx=0;
10927       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
10928       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10929       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
10930       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
10931
10932       /*Cause*/
10933       idx++;
10934       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
10935       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
10936       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
10937       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
10938       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
10939
10940       /*Reset Type*/
10941       idx++;
10942       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
10943       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10944       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
10945       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
10946       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
10947
10948       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
10949
10950       /* Encode the F1SetupRequest type as APER */
10951       memset(encBuf, 0, ENC_BUF_MAX_LEN);
10952       encBufSize = 0;
10953       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
10954             encBuf);
10955
10956       /* Encode results */
10957       if(encRetVal.encoded == ENCODE_FAIL)
10958       {
10959          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
10960                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10961          break;
10962       }
10963       else
10964       {
10965          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1Reset\n");
10966          for(idx=0; idx< encBufSize; idx++)
10967          {
10968             printf("%x",encBuf[idx]);
10969          }
10970       }
10971
10972       if(sendF1APMsg() != ROK)
10973       {
10974          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
10975          break;
10976       }
10977
10978       ret = ROK;
10979       break;
10980    }while(true);
10981
10982    FreeF1ResetReq(f1apMsg);
10983    return ret;
10984 }
10985 /*******************************************************************
10986  *
10987  * @brief Build And Send F1ResetAck
10988  *
10989  * @details
10990  *
10991  *    Function : BuildAndSendF1ResetAck
10992  *
10993  *    Functionality:
10994  *         - Build And Send  F1ResetRSP
10995  *
10996  * @return ROK     - success
10997  *         RFAILED - failure
10998  *
10999  * ****************************************************************/
11000 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
11001 {
11002    uint8_t idx;
11003    ResetAcknowledge_t *f1ResetAck;
11004
11005    if(f1apMsg)
11006    {
11007       if(f1apMsg->choice.successfulOutcome)
11008       {
11009          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
11010
11011          if(f1ResetAck->protocolIEs.list.array)
11012          {
11013             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
11014             {
11015                if(f1ResetAck->protocolIEs.list.array[idx])
11016                {
11017                   DU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
11018                }
11019             }
11020             DU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
11021          }
11022          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11023       }
11024       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11025    }
11026 }
11027
11028 /*******************************************************************
11029  *
11030  * @brief Build And Send F1ResetAck
11031  *
11032  * @details
11033  *
11034  *    Function : BuildAndSendF1ResetAck
11035  *
11036  *    Functionality:
11037  *         - Build And Send  F1ResetRSP
11038  *
11039  *  @params[in]
11040  * @return ROK     - success
11041  *         RFAILED - failure
11042  *
11043  * ****************************************************************/
11044 uint8_t BuildAndSendF1ResetAck()
11045 {
11046    uint8_t                idx = 0;
11047    uint8_t                elementCnt = 0;
11048    uint8_t                ret = RFAILED;
11049    F1AP_PDU_t             *f1apMsg = NULL;
11050    ResetAcknowledge_t     *f1ResetAck = NULLP;
11051    asn_enc_rval_t         encRetVal;
11052    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset Acknowledgment \n");
11053
11054    do{
11055       /* Allocate the memory for F1ResetRequest_t */
11056       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11057       if(f1apMsg == NULLP)
11058       {
11059          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11060          break;
11061       }
11062
11063       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
11064
11065       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11066       if(f1apMsg->choice.successfulOutcome == NULLP)
11067       {
11068          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11069          break;
11070       }
11071       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
11072       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
11073       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
11074
11075       elementCnt = 1;
11076
11077       f1ResetAck->protocolIEs.list.count = elementCnt;
11078       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
11079
11080       DU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
11081       if(f1ResetAck->protocolIEs.list.array == NULLP)
11082       {
11083          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
11084          break;
11085       }
11086
11087       for(idx=0; idx<elementCnt; idx++)
11088       {
11089          DU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
11090          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
11091          {
11092             break;
11093          }
11094       }
11095       /*TransactionID*/
11096       idx = 0;
11097       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
11098       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11099       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
11100       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
11101
11102       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11103
11104       /* Encode the F1SetupRequest type as UPER */
11105       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11106       encBufSize = 0;
11107       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
11108
11109       /* Check encode results */
11110       if(encRetVal.encoded == ENCODE_FAIL)
11111       {
11112          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
11113                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11114          break;
11115       }
11116       else
11117       {
11118          DU_LOG("\nDUBUG   -->  F1AP : Created APER encoded buffer for F1ResetAck\n");
11119          for(int i=0; i< encBufSize; i++)
11120          {
11121             printf("%x",encBuf[i]);
11122          }
11123       }
11124       /* Sending msg */
11125       if(sendF1APMsg() != ROK)
11126       {
11127          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Acknowledgement failed");
11128          break;
11129       }
11130
11131       ret = ROK;
11132       break;
11133    }while(true);
11134
11135    FreeF1ResetAck(f1apMsg);
11136    return ret;
11137 }
11138 /******************************************************************
11139 *
11140 * @brief free F1 reset msg allocated by aper_decoder
11141 *
11142 * @details
11143 *
11144 *    Function : freeAperDecodeF1ResetMsg
11145 *
11146 *    Functionality: free F1 reset msg allocated by aper_decoder
11147 *
11148 * @params[in] Reset_t *f1ResetMsg
11149 * @return void
11150 *
11151 * ****************************************************************/
11152
11153 void freeAperDecodeF1ResetMsg(Reset_t *f1ResetMsg)
11154 {
11155    uint8_t ieIdx =0;
11156    if(f1ResetMsg->protocolIEs.list.array)
11157    {
11158       for(ieIdx=0 ;ieIdx < f1ResetMsg->protocolIEs.list.count ; ieIdx++)
11159       {
11160          if(f1ResetMsg->protocolIEs.list.array[ieIdx])
11161          {
11162             free(f1ResetMsg->protocolIEs.list.array[ieIdx]);
11163          }
11164       }
11165       free(f1ResetMsg->protocolIEs.list.array);
11166    }
11167 }
11168
11169 /******************************************************************
11170  *
11171  * @brief Processes DL RRC Message Transfer  sent by CU
11172  *
11173  * @details
11174  *
11175  *    Function : procF1ResetReq
11176  *
11177  *    Functionality: Processes DL RRC Message Transfer sent by CU
11178  *
11179  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11180  * @return ROK     - success
11181  *         RFAILED - failure
11182  *
11183  * ****************************************************************/
11184 uint8_t procF1ResetReq(F1AP_PDU_t *f1apMsg)
11185 {
11186    /* we are currently not supporting Ue release. right now we are supporting only init case of fireset */
11187    uint8_t       ieIdx = 0;
11188    uint8_t        ret = ROK;
11189    Reset_t       *f1ResetMsg = NULLP;
11190
11191    DU_LOG("\nINFO   -->  Processing F1 reset request");
11192    f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11193
11194    for(ieIdx=0; ieIdx<f1ResetMsg->protocolIEs.list.count; ieIdx++)
11195    {
11196       switch(f1ResetMsg->protocolIEs.list.array[ieIdx]->id)
11197       {
11198          case ProtocolIE_ID_id_TransactionID:
11199             break;
11200
11201          case ProtocolIE_ID_id_Cause:
11202             break;
11203
11204          case ProtocolIE_ID_id_ResetType:
11205             {
11206                break;
11207             }
11208
11209          default:
11210             break;
11211       }
11212    }
11213    ret = BuildAndSendF1ResetAck();
11214    DU_LOG("\nINFO   -->  UE release is not supported for now");
11215
11216    freeAperDecodeF1ResetMsg(f1ResetMsg);
11217
11218    return ret;
11219 }
11220
11221 /*******************************************************************
11222  *
11223  * @brief free the RRC delivery report
11224  *
11225  * @details
11226  *
11227  *    Function : freeRrcDeliveryReport
11228  *
11229  *    Functionality: free the RRC delivery report
11230  *
11231  * @params[in]
11232  * @return ROK     - success
11233  *         RFAILED - failure
11234  *
11235  * ****************************************************************/
11236 void freeRrcDeliveryReport(F1AP_PDU_t  *f1apMsg )
11237 {
11238    uint8_t idx=0;
11239    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11240
11241    if(f1apMsg)
11242    {
11243       if(f1apMsg->choice.initiatingMessage)
11244       {
11245          rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11246          if(rrcDeliveryReport->protocolIEs.list.array)
11247          {
11248             for(idx =0 ;idx <rrcDeliveryReport->protocolIEs.list.count ;
11249                   idx++)
11250             {
11251                if(rrcDeliveryReport->protocolIEs.list.array[idx])
11252                {
11253                   DU_FREE(rrcDeliveryReport->protocolIEs.list.array[idx],
11254                         sizeof(RRCDeliveryReportIEs_t));
11255                }
11256             }
11257             DU_FREE(rrcDeliveryReport->protocolIEs.list.array,
11258                   rrcDeliveryReport->protocolIEs.list.size);
11259          }
11260          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11261       }
11262       DU_FREE(f1apMsg,
11263             sizeof(F1AP_PDU_t));
11264    }
11265 }
11266
11267 /*******************************************************************
11268 *
11269 * @brief Builds and sends the RRC delivery report
11270 *
11271 * @details
11272 *
11273 *    Function : BuildAndSendRrcDeliveryReport
11274 *
11275 *    Functionality: Builds and sends the RRC delivery report
11276 *
11277 * @params[in]
11278 *
11279 * @return ROK     - success
11280 *         RFAILED - failure
11281 *
11282 * ****************************************************************/
11283 uint8_t BuildAndSendRrcDeliveryReport(uint32_t gnbCuUeF1apId, \
11284    uint32_t gnbDuUeF1apId, RrcDeliveryReport *rrcDelivery)
11285 {
11286    uint8_t             ret = RFAILED;
11287    uint8_t             idx    = 0;
11288    uint8_t             idx1   = 0;
11289    uint8_t             elementCnt = 0;
11290    F1AP_PDU_t          *f1apMsg = NULLP;
11291    asn_enc_rval_t      encRetVal;
11292    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11293
11294    do{
11295
11296       DU_LOG("\nINFO   -->  F1AP : Building RRC delivery Message Transfer Message\n");
11297       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11298       if(f1apMsg == NULLP)
11299       {
11300          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11301          break;
11302       }
11303       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
11304       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11305       if(f1apMsg->choice.initiatingMessage == NULLP)
11306       {
11307          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU  failed");
11308          break;
11309       }
11310       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_RRCDeliveryReport;
11311       f1apMsg->choice.initiatingMessage->criticality   = Criticality_ignore;
11312       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RRCDeliveryReport;
11313
11314       rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11315       elementCnt = 4;
11316       rrcDeliveryReport->protocolIEs.list.count = elementCnt;
11317       rrcDeliveryReport->protocolIEs.list.size = elementCnt * sizeof(RRCDeliveryReportIEs_t *);
11318
11319       /* Initialize the F1Setup members */
11320       DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array, rrcDeliveryReport->protocolIEs.list.size);
11321       if(rrcDeliveryReport->protocolIEs.list.array == NULLP)
11322       {
11323          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRC Delivery  failed");
11324          break;
11325       }
11326       for(idx =0 ;idx <elementCnt; idx++)
11327       {
11328          DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array[idx], sizeof(RRCDeliveryReportIEs_t));
11329          if(rrcDeliveryReport->protocolIEs.list.array[idx] == NULLP)
11330          {
11331             break;
11332          }
11333       }
11334
11335       idx1 = 0;
11336
11337       /*GNB CU UE F1AP ID*/
11338       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11339       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
11340       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_CU_UE_F1AP_ID;
11341       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
11342
11343       /*GNB DU UE F1AP ID*/
11344       idx1++;
11345       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11346       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
11347       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_DU_UE_F1AP_ID;
11348       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
11349
11350       /*RRC delivery status*/
11351       idx1++;
11352       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_RRCDeliveryStatus;
11353       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
11354       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_RRCDeliveryStatus;
11355       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.delivery_status =\
11356       rrcDelivery->rrcDeliveryStatus.deliveryStatus;
11357       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.triggering_message =\
11358       rrcDelivery->rrcDeliveryStatus.triggeringMessage;
11359
11360       /* SRB ID */
11361       idx1++;
11362       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
11363       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
11364       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_SRBID;
11365       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.SRBID =  rrcDelivery->srbId;
11366
11367       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11368
11369       /* Encode the RRC DELIVERY REPORT type as APER */
11370       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11371       encBufSize = 0;
11372       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11373             encBuf);
11374
11375       /* Encode results */
11376       if(encRetVal.encoded == ENCODE_FAIL)
11377       {
11378          DU_LOG("\nERROR  -->  F1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
11379                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11380          break;
11381       }
11382       else
11383       {
11384          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for RRC Delivery Msg \n");
11385          for(idx=0; idx< encBufSize; idx++)
11386          {
11387             printf("%x",encBuf[idx]);
11388          }
11389       }
11390
11391       /* Sending msg */
11392       if(sendF1APMsg() != ROK)
11393       {
11394          DU_LOG("\nERROR  -->  F1AP : Sending RRC delivery  msg request failed");
11395          break;
11396       }
11397       ret = ROK;
11398       break;
11399
11400    }while(true);
11401
11402    freeRrcDeliveryReport(f1apMsg);
11403    return ret;
11404 }
11405
11406 /*******************************************************************
11407  *
11408  * @brief Processes cells to be activated
11409  *
11410  * @details
11411  *
11412  *    Function : extractCellsToBeActivated
11413  *
11414  *    Functionality:
11415  *      - Processes cells to be activated list received in F1SetupRsp
11416  *
11417  * @params[in] void
11418  * @return ROK     - success
11419  *         RFAILED - failure
11420  *
11421  * ****************************************************************/
11422
11423 uint8_t extractCellsToBeActivated(Cells_to_be_Activated_List_t cellsToActivate)
11424 {
11425    uint8_t  ret = ROK;
11426    uint16_t idx, nci, pci = 0;
11427    Cells_to_be_Activated_List_Item_t cell;
11428
11429    for(idx=0; idx<cellsToActivate.list.count; idx++)
11430    {
11431       nci = 0;
11432       cell = cellsToActivate.list.array[idx]->value.choice.Cells_to_be_Activated_List_Item;
11433       bitStringToInt(&cell.nRCGI.nRCellIdentity, &nci);
11434
11435       if(cell.nRPCI)
11436       {
11437          pci = *cell.nRPCI;
11438       }
11439       ret = duProcCellsToBeActivated(cell.nRCGI.pLMN_Identity.buf, nci, pci);
11440    }
11441    return ret;
11442 }
11443 /******************************************************************
11444 *
11445 * @brief Processes F1 Setup Response allocated by aper_decoder
11446 *
11447 * @details
11448 *
11449 *    Function : freeF1SetupRsp
11450 *
11451 *    Functionality: free F1 Setup Response allocated by aper_decoder
11452 *
11453 * @params[in] F1SetupResponse_t *f1SetRspMsg
11454 * @return void
11455 *
11456 * ****************************************************************/
11457
11458 void freeAperDecodeF1SetupRsp(F1SetupResponse_t *f1SetRspMsg)
11459 {
11460    uint8_t ieIdx =0;
11461    uint8_t arrIdx =0;
11462    Cells_to_be_Activated_List_t *cellToActivate =NULLP;
11463    RRC_Version_t      *rrcVer =NULLP;
11464
11465    if(f1SetRspMsg->protocolIEs.list.array)
11466    {
11467       for(ieIdx=0; ieIdx<f1SetRspMsg->protocolIEs.list.count; ieIdx++)
11468       {
11469          if(f1SetRspMsg->protocolIEs.list.array[ieIdx])
11470          {
11471             switch(f1SetRspMsg->protocolIEs.list.array[ieIdx]->id)
11472             {
11473                case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11474                   {
11475                      cellToActivate =
11476                         &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.Cells_to_be_Activated_List;
11477                      if(cellToActivate->list.array)
11478                      {
11479                         for(arrIdx=0; arrIdx<cellToActivate->list.count ; arrIdx++)
11480                         {
11481                            if(cellToActivate->list.array[arrIdx])
11482                            {
11483
11484                               if(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.\
11485                               pLMN_Identity.buf)
11486                               {
11487                                  if(cellToActivate->list.array[0]->value.choice.\
11488                                        Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf)
11489                                  {
11490                                     free(cellToActivate->list.array[0]->value.choice.\
11491                                           Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf);
11492                                  }
11493
11494                                  free(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
11495                                        nRCGI.pLMN_Identity.buf);
11496                               }
11497                               free(cellToActivate->list.array[arrIdx]);
11498                            }
11499                         }
11500                         free(cellToActivate->list.array);
11501                      }
11502                      break;
11503                   }
11504                case ProtocolIE_ID_id_TransactionID:
11505                   {
11506                      break;
11507                   }
11508                case ProtocolIE_ID_id_gNB_CU_Name:
11509                   {
11510                      free(f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_Name.buf);
11511                      break;
11512                   }
11513                case ProtocolIE_ID_id_GNB_CU_RRC_Version:
11514                   {
11515                      rrcVer = &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
11516                      if(rrcVer->latest_RRC_Version.buf)
11517                      {
11518                         if(rrcVer->iE_Extensions)
11519                         {
11520                            if(rrcVer->iE_Extensions->list.array)
11521                            {
11522                               if(rrcVer->iE_Extensions->list.array[0])
11523                               {
11524                                  if(rrcVer->iE_Extensions->list.\
11525                                        array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf)
11526                                  {
11527                                     free(rrcVer->iE_Extensions->list.\
11528                                           array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf);
11529                                  }
11530                                  free(rrcVer->iE_Extensions->list.array[0]);
11531                               }
11532                               free(rrcVer->iE_Extensions->list.array);
11533                            }
11534                            free(rrcVer->iE_Extensions);
11535                         }
11536                         free(rrcVer->latest_RRC_Version.buf);
11537                      }
11538                      break;
11539
11540                   }
11541                default:
11542                   {
11543                      DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
11544                            f1SetRspMsg->protocolIEs.list.array[ieIdx]->id);
11545                   }
11546             }
11547             free(f1SetRspMsg->protocolIEs.list.array[ieIdx]);
11548          }
11549       }
11550       free(f1SetRspMsg->protocolIEs.list.array);
11551    }
11552 }
11553 /******************************************************************
11554  *
11555  * @brief Processes F1 Setup Response sent by CU
11556  *
11557  * @details
11558  *
11559  *    Function : procF1SetupRsp
11560  *
11561  *    Functionality: Processes F1 Setup Response sent by CU
11562  *
11563  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11564  * @return ROK     - success
11565  *         RFAILED - failure
11566  *
11567  * ****************************************************************/
11568 uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg)
11569 {
11570    uint8_t ret = ROK;
11571    uint16_t idx =0;
11572    F1SetupResponse_t *f1SetRspMsg = NULLP;
11573    GNB_CU_Name_t     *cuName = NULLP;
11574    F1SetupRsp  f1SetRspDb;
11575    RRC_Version_t      *rrcVer =NULLP;
11576
11577    memset(&f1SetRspDb, 0, sizeof(F1SetupRsp));
11578
11579    DU_LOG("\nINFO   -->  F1AP : F1 Setup Response received");
11580    f1SetRspMsg = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
11581
11582    for(idx=0; idx<f1SetRspMsg->protocolIEs.list.count; idx++)
11583    {
11584       switch(f1SetRspMsg->protocolIEs.list.array[idx]->id)
11585       {
11586          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11587             {
11588                extractCellsToBeActivated(f1SetRspMsg->protocolIEs.list.array[idx]->\
11589                      value.choice.Cells_to_be_Activated_List);
11590                break;
11591             }
11592          case ProtocolIE_ID_id_TransactionID:
11593             {
11594                f1SetRspDb.transId = f1SetRspMsg->protocolIEs.list.array[idx]->\
11595                                     value.choice.TransactionID;
11596                break;
11597             }
11598          case ProtocolIE_ID_id_gNB_CU_Name:
11599             {
11600                cuName = &f1SetRspMsg->protocolIEs.list.array[idx]->\
11601                         value.choice.GNB_CU_Name;
11602                strcpy(f1SetRspDb.cuName, (const char*)cuName->buf);
11603                break;
11604             }
11605          case ProtocolIE_ID_id_GNB_CU_RRC_Version:
11606             {
11607                rrcVer = &f1SetRspMsg->protocolIEs.list.array[idx]->value.choice.RRC_Version;
11608                strcpy(f1SetRspDb.rrcVersion.rrcVer,
11609                      (const char*)rrcVer->latest_RRC_Version.buf);
11610                break;
11611             }
11612          default:
11613             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
11614                   f1SetRspMsg->protocolIEs.list.array[idx]->id);
11615       }
11616       duProcF1SetupRsp();
11617    }
11618
11619    freeAperDecodeF1SetupRsp(f1SetRspMsg);
11620    return ret;
11621 }
11622 /*******************************************************************
11623 *
11624 * @brief free GNB DU config update ack
11625 *
11626 * @details
11627 *
11628 *    Function : freeAperDecodeGnbDuAck
11629 *
11630 *    Functionality: Processes GNB DU config update ack And
11631 *                     added free part for the memory allocated by aper_decoder
11632 *
11633 * @params[in] F1AP_PDU_t ASN decoded F1AP message
11634 * @return ROK     - success
11635 *         RFAILED - failure
11636 *
11637 * ****************************************************************/
11638
11639 void freeAperDecodeGnbDuAck(GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck)
11640 {
11641    uint8_t ieIdx = 0;
11642
11643    if(gnbDuAck->protocolIEs.list.array)
11644    {
11645       for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
11646       {
11647          if(gnbDuAck->protocolIEs.list.array[ieIdx])
11648          {
11649             free(gnbDuAck->protocolIEs.list.array[ieIdx]);
11650          }
11651       }
11652       free(gnbDuAck->protocolIEs.list.array);
11653    }
11654 }
11655
11656 /*******************************************************************
11657 *
11658 * @brief Building  result of gnb-du config update ack output
11659 *
11660 * @details
11661 *
11662 *    Function : duProcGnbDuCfgUpdAckMsg
11663 *
11664 *    Functionality:
11665 *        Building output of gnb-du config update ack
11666 *
11667 * @params[in] transId
11668 * @return void
11669 *
11670 * ****************************************************************/
11671
11672 uint8_t duProcGnbDuCfgUpdAckMsg(uint8_t transId)
11673 {
11674    uint8_t  ieIdx=0, arrIdx=0,ret=ROK;
11675    uint8_t  ueId =0 , ueIdx =0;
11676    uint16_t cellId =0, cellIdx =0, crnti=0;
11677    CmLList *f1apPduNode = NULLP;
11678    ReservedF1apPduInfo *f1apPduInfo =NULLP;
11679    F1AP_PDU_t *f1apMsgPdu = NULLP;
11680    GNBDUConfigurationUpdate_t *gnbDuConfigUpdate = NULLP;
11681    BIT_STRING_t *cellIdentity=NULLP;
11682    struct Served_Cells_To_Delete_ItemIEs *deleteItemIe=NULLP;
11683    Served_Cells_To_Delete_List_t *cellsToDelete=NULLP;
11684    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
11685
11686    DU_LOG("\nINFO   -->  DU APP: GNB-DU config update Ack received ");
11687    f1apPduNode = searchFromReservedF1apPduList(transId);
11688    f1apPduInfo = (ReservedF1apPduInfo *)f1apPduNode->node;
11689    f1apMsgPdu = (F1AP_PDU_t *)f1apPduInfo->f1apMsg;
11690
11691    if(f1apMsgPdu)
11692    {
11693       if(f1apMsgPdu->choice.initiatingMessage)
11694       {
11695          gnbDuConfigUpdate = &f1apMsgPdu->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
11696          for(ieIdx=0; ieIdx < gnbDuConfigUpdate->protocolIEs.list.count; ieIdx++)
11697          {
11698             switch(gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->id)
11699             {
11700                case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
11701                   {
11702                      cellsToDelete = &gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
11703                                      Served_Cells_To_Delete_List;
11704                      if(cellsToDelete->list.array)
11705                      {
11706                         if(cellsToDelete->list.array[arrIdx])
11707                         {
11708                            deleteItemIe = (Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx];
11709                            deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
11710                            if(deleteItem->oldNRCGI.nRCellIdentity.buf)
11711                            {
11712                               cellIdentity = &deleteItem->oldNRCGI.nRCellIdentity;
11713                               bitStringToInt(cellIdentity, &cellId);
11714                            }
11715                         }
11716                      }
11717
11718                      GET_CELL_IDX(cellId, cellIdx);
11719                      if(duCb.actvCellLst[cellIdx] != NULLP)
11720                      {
11721                         if(duCb.actvCellLst[cellIdx]->numActvUes == 0)
11722                         {
11723                            duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
11724                            ret = duSendCellDeletReq(cellId);
11725                            if(ret == RFAILED)
11726                            {
11727                               DU_LOG("ERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to send cell delete\
11728                               request for cellId[%d]", cellId);
11729                            }
11730                         }
11731                         else
11732                         {
11733                            for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
11734                            {
11735                               crnti = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].crnti;
11736                               GET_UE_IDX(crnti,ueId);
11737                               ret = BuildAndSendUeContextReleaseReq(cellId, ueId);
11738                               if(ret == RFAILED)
11739                               {
11740                                  DU_LOG("ERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to build and send UE delete\
11741                                  request for cellId[%d]", cellId);
11742                               }
11743                            }
11744                         }
11745                      }
11746                      else
11747                      {
11748                         DU_LOG("ERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): CellId [%d] not found", cellId);
11749                         ret = RFAILED;
11750                      }
11751                      break;
11752                   }
11753
11754                default:
11755                   break;
11756             }
11757          }
11758       }
11759    }
11760
11761    FreeDUConfigUpdate(f1apMsgPdu);
11762    deleteFromReservedF1apPduList(f1apPduNode);
11763    return ret;
11764 }
11765
11766 /*******************************************************************
11767 *
11768 * @brief Processes GNB DU config update ack
11769 *
11770 * @details
11771 *
11772 *    Function : procF1GNBDUCfgUpdAck
11773 *
11774 *    Functionality: added free part for the memory allocated by aper_decoder
11775 *
11776 * @params[in] F1AP_PDU_t *f1apMsg
11777 * @return void
11778 *
11779 * ****************************************************************/
11780 uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
11781 {
11782    uint8_t ieIdx=0,transId=0;
11783    GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
11784
11785    DU_LOG("\nINFO   -->  F1AP : GNB-DU config update acknowledgment");
11786    gnbDuAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
11787
11788    for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
11789    {
11790       switch(gnbDuAck->protocolIEs.list.array[ieIdx]->id)
11791       {
11792          case ProtocolIE_ID_id_TransactionID:
11793             {
11794                transId = gnbDuAck->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
11795                break;
11796             }
11797          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11798             {
11799                break;
11800             }
11801          default :
11802             {
11803                DU_LOG("\nERROR  -->  F1AP: procF1GNBDUCfgUpdAck(): Invalid IE Received: %ld", \
11804                      gnbDuAck->protocolIEs.list.array[ieIdx]->id);
11805                break;
11806             }
11807       }
11808    }
11809
11810    duProcGnbDuCfgUpdAckMsg(transId);
11811
11812 #if 0
11813    /* presently we are not supporting F1 Reset from DU to CU , we are only
11814     * supporting F1 Reset from CU to DU */
11815
11816    if(BuildAndSendF1ResetReq() != ROK)
11817    {
11818       return RFAILED;
11819    }
11820 #endif
11821
11822    freeAperDecodeGnbDuAck(gnbDuAck);
11823    return ROK;
11824 }
11825 /******************************************************************
11826 *
11827 * @brief free DL RRC Message Transfer allocated by aper_decoder
11828 *
11829 * @details
11830 *
11831 *    Function : freeAperDecodef1DlRrcMsg
11832 *
11833 *    Functionality: free DL RRC Message Transfer allocated by aper_decoder
11834 *
11835 * @params[in] DLRRCMessageTransfer_t *f1DlRrcMsg
11836 * @return ROK     - success
11837 *         RFAILED - failure
11838 *
11839 * ****************************************************************/
11840
11841 void freeAperDecodef1DlRrcMsg(DLRRCMessageTransfer_t *f1DlRrcMsg)
11842 {
11843    uint8_t ieIdx =0;
11844    RRCContainer_t *rrcContainer = NULLP;
11845
11846    if(f1DlRrcMsg->protocolIEs.list.array)
11847    {
11848       for(ieIdx=0; ieIdx<f1DlRrcMsg->protocolIEs.list.count; ieIdx++)
11849       {
11850          if(f1DlRrcMsg->protocolIEs.list.array[ieIdx])
11851          {
11852             switch(f1DlRrcMsg->protocolIEs.list.array[ieIdx]->id)
11853             {
11854                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11855                   break;
11856                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11857                   break;
11858                case ProtocolIE_ID_id_SRBID:
11859                   break;
11860                case ProtocolIE_ID_id_RRCContainer:
11861                   {
11862                      rrcContainer =&f1DlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
11863                      free(rrcContainer->buf);
11864                   }
11865                case ProtocolIE_ID_id_ExecuteDuplication:
11866                   break;
11867                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
11868                   break;
11869                   break;
11870             }
11871             free(f1DlRrcMsg->protocolIEs.list.array[ieIdx]);
11872          }
11873       }
11874       free(f1DlRrcMsg->protocolIEs.list.array);
11875    }
11876 }
11877 /******************************************************************
11878  *
11879  * @brief Processes DL RRC Message Transfer  sent by CU
11880  *
11881  * @details
11882  *
11883  *    Function : procF1DlRrcMsgTrans
11884  *
11885  *    Functionality: Processes DL RRC Message Transfer sent by CU
11886  *
11887  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11888  * @return ROK     - success
11889  *         RFAILED - failure
11890  *
11891  * ****************************************************************/
11892 uint8_t procF1DlRrcMsgTrans(F1AP_PDU_t *f1apMsg)
11893 {
11894    uint8_t  idx, ret;
11895    DLRRCMessageTransfer_t *f1DlRrcMsg = NULLP;
11896    F1DlRrcMsg dlMsg;
11897    memset(&dlMsg, 0, sizeof(F1DlRrcMsg));
11898
11899    DU_LOG("\nINFO   -->  DU_APP : DL RRC message transfer Recevied");
11900    f1DlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
11901
11902    ret = ROK;
11903
11904    for(idx=0; idx<f1DlRrcMsg->protocolIEs.list.count; idx++)
11905    {
11906       switch(f1DlRrcMsg->protocolIEs.list.array[idx]->id)
11907       {
11908          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
11909             {
11910                dlMsg.gnbCuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
11911                break;
11912             }
11913          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
11914             {
11915                dlMsg.gnbDuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
11916                break;
11917             }
11918          case ProtocolIE_ID_id_SRBID:
11919             {
11920                dlMsg.srbId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
11921                break;
11922             }
11923          case ProtocolIE_ID_id_ExecuteDuplication:
11924             dlMsg.execDup = true;
11925             break;
11926
11927          case ProtocolIE_ID_id_RRCContainer:
11928             {
11929                if(f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0)
11930                {
11931                   dlMsg.rrcMsgSize = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
11932                   DU_ALLOC_SHRABL_BUF(dlMsg.rrcMsgPdu, dlMsg.rrcMsgSize);
11933                   if(dlMsg.rrcMsgPdu)
11934                   {
11935                      memcpy(dlMsg.rrcMsgPdu, f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
11936                         dlMsg.rrcMsgSize);
11937                   }
11938                   else
11939                   {
11940                      DU_LOG("\nERROR  -->  DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
11941                      return RFAILED;
11942                   }
11943                }
11944                else
11945                {
11946                   DU_LOG("\nERROR  -->  DU_APP : RRC Container Size is invalid:%ld",\
11947                   f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
11948                   return RFAILED;
11949                }
11950                break;
11951             }
11952          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
11953             {
11954                dlMsg.deliveryStatRpt = true;
11955                break;
11956             }
11957          default:
11958             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
11959                   f1DlRrcMsg->protocolIEs.list.array[idx]->id);
11960       }
11961    }
11962
11963    ret = duProcDlRrcMsg(&dlMsg);
11964
11965    freeAperDecodef1DlRrcMsg(f1DlRrcMsg);
11966    return ret;
11967 }
11968 /*******************************************************************
11969  *
11970 * @brief Builds the DRB to be Setup Mod list
11971 *
11972 * @details
11973 *
11974 *    Function :
11975 *
11976 *    Functionality: Constructs the DRB to be Setup Mod list
11977 *
11978 * @params[in] DRBs_SetupMod_List_t *drbSet
11979 *
11980 * @return ROK     - success
11981 *         RFAILED - failure
11982 *
11983 * ****************************************************************/
11984
11985 uint8_t BuildDrbSetupModList(DRBs_SetupMod_List_t *drbSet , DuUeCfg *ueCfg)
11986 {
11987    uint8_t arrIdx =0;
11988    uint8_t drbCnt =0;
11989    struct DRBs_SetupMod_ItemIEs *drbItemIe;
11990
11991    drbCnt = 1;
11992    drbSet->list.count = drbCnt;
11993    drbSet->list.size = drbCnt * sizeof(DRBs_SetupMod_ItemIEs_t *);
11994    DU_ALLOC(drbSet->list.array, drbSet->list.size);
11995    if(drbSet->list.array == NULLP)
11996    {
11997       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
11998       return  RFAILED;
11999    }
12000    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
12001    {
12002       DU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
12003       if(drbSet->list.array[arrIdx] == NULLP)
12004       {
12005               DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
12006               return  RFAILED;
12007       }
12008
12009       drbItemIe = (struct DRBs_SetupMod_ItemIEs *)drbSet->list.array[arrIdx];
12010       drbItemIe->id = ProtocolIE_ID_id_DRBs_SetupMod_Item;
12011       drbItemIe->criticality = Criticality_reject;
12012       drbItemIe->value.present = DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item;
12013       drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
12014       if(fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List,\
12015       &ueCfg->upTnlInfo[arrIdx])!= ROK)
12016       {
12017          DU_LOG("\nERROR  -->  F1AP : Failed to fill DlTnl SetupList in BuildDrbToBeSetupModList");
12018          return RFAILED;
12019       }
12020
12021    }
12022
12023    return ROK;
12024 }
12025 /*******************************************************************
12026 * @brief Free the memory allocated for DRB setup List
12027 *
12028 * @details
12029 *
12030 *    Function : FreeDrbSetupModList
12031 *
12032 *    Functionality:
12033 *       Free the memory allocated for DRB setup list
12034 *
12035 * @params[in] DRBs_Setup_List_t *
12036 * @return void
12037 *
12038 * ****************************************************************/
12039 void FreeDrbSetupModList(DRBs_SetupMod_List_t *drbSetupList)
12040 {
12041    uint8_t arrIdx = 0;
12042    DRBs_SetupMod_ItemIEs_t *drbItemIe = NULLP;
12043
12044    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
12045    {
12046       drbItemIe = ((DRBs_SetupMod_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
12047       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
12048       DU_FREE(drbSetupList->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
12049    }
12050    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
12051 }
12052 /*******************************************************************
12053 * @brief Free the memory allocated for UE Context Mod Response
12054 *
12055 * @details
12056 *
12057 *    Function : FreeUeContextModResp
12058 *
12059 *    Functionality:
12060 *       Free the memory allocated for UE Context Mod Response
12061 *
12062 * @params[in] F1AP_PDU_t *f1apMsg
12063 * @return void
12064 *
12065 * ****************************************************************/
12066
12067 void FreeUeContextModResp(F1AP_PDU_t *f1apMsg)
12068 {
12069    uint8_t ieIdx;
12070    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
12071    if(f1apMsg)
12072    {
12073       if(f1apMsg->choice.successfulOutcome)
12074       {
12075          ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
12076          if(ueContextModifyRes->protocolIEs.list.array)
12077          {
12078             for(ieIdx=0 ; ieIdx<ueContextModifyRes->protocolIEs.list.count; ieIdx++)
12079             {
12080                if(ueContextModifyRes->protocolIEs.list.array[ieIdx])
12081                {
12082                   switch(ueContextModifyRes->protocolIEs.list.array[ieIdx]->id)
12083                   {
12084                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12085                         break;
12086                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12087                         break;
12088                      case ProtocolIE_ID_id_DRBs_SetupMod_List:
12089                         {
12090                             FreeDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
12091                             value.choice.DRBs_SetupMod_List));
12092                             break;
12093                         }
12094                   }
12095                   DU_FREE(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
12096                }
12097
12098             }
12099             DU_FREE(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
12100          }
12101          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12102       }
12103       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12104    }
12105 }
12106
12107 /*****************************************************************i
12108 *
12109 * @brief Creating the ue context modifcation response and sending
12110 *
12111 * @details
12112 *
12113 *    Function : BuildAndSendUeContextModRsp
12114 *
12115 *    Functionality:
12116 *         - Creating the ue context modifcation response
12117 *
12118 * @params[in] uint8_t cellId,uint8_t ueIdx
12119 * @return ROK     - success
12120 *         RFAILED - failure
12121 *
12122 * ****************************************************************/
12123 uint8_t BuildAndSendUeContextModRsp(uint8_t cellId,uint8_t ueIdx)
12124 {
12125    uint8_t   ieIdx = 0;
12126    uint8_t   cellIdx =0;
12127    uint8_t   elementCnt = 0;
12128    uint8_t   ret = RFAILED;
12129    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
12130    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
12131    F1AP_PDU_t *f1apMsg = NULLP;
12132    asn_enc_rval_t         encRetVal;
12133    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
12134    DuUeCb                   *ueCb = NULLP;
12135
12136    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification response\n");
12137
12138    while(1)
12139    {
12140       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12141       if(f1apMsg == NULLP)
12142       {
12143          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
12144          break;
12145       }
12146
12147       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
12148
12149       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12150       if(f1apMsg->choice.successfulOutcome == NULLP)
12151       {
12152          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
12153          break;
12154       }
12155       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextModification;
12156       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
12157       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_UEContextModificationResponse;
12158
12159       ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
12160
12161       elementCnt = 3;
12162       ueContextModifyRes->protocolIEs.list.count = elementCnt;
12163       ueContextModifyRes->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationResponse_t*);
12164
12165       /* Initialize the UE context modification members */
12166       DU_ALLOC(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
12167       if(ueContextModifyRes->protocolIEs.list.array == NULLP)
12168       {
12169          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
12170          break;
12171       }
12172
12173       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
12174       {
12175          DU_ALLOC(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
12176          if(ueContextModifyRes->protocolIEs.list.array[ieIdx] == NULLP)
12177          {
12178             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
12179             break;
12180          }
12181       }
12182
12183       /* Fetching Ue Cb Info*/
12184       GET_CELL_IDX(cellId, cellIdx);
12185       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
12186       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
12187       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
12188
12189       ieIdx=0;
12190       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
12191       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12192       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
12193       UEContextModificationResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
12194       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
12195
12196       ieIdx++;
12197       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
12198       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12199       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present=\
12200       UEContextModificationResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
12201       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
12202
12203       ieIdx++;
12204       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_SetupMod_List;
12205       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12206       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
12207       UEContextModificationResponseIEs__value_PR_DRBs_SetupMod_List;
12208       if(ueCb->f1UeDb)
12209       {
12210          ret = BuildDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
12211                   value.choice.DRBs_SetupMod_List) , &ueCb->f1UeDb->duUeCfg);
12212          if(ret != ROK)
12213          {
12214             DU_LOG( "\nERROR  -->  F1AP : Failed to build drb setupmod List ");
12215             break;
12216          }
12217          freeF1UeDb(ueCb->f1UeDb);
12218          ueCb->f1UeDb = NULLP;
12219       }
12220       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12221
12222       /* Encode the F1SetupRequest type as APER */
12223       memset(encBuf, 0, ENC_BUF_MAX_LEN);
12224       encBufSize = 0;
12225       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,encBuf);
12226
12227       /* Encode results */
12228       if(encRetVal.encoded == ENCODE_FAIL)
12229       {
12230          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
12231                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12232          ret = RFAILED;
12233          break;
12234       }
12235       else
12236       {
12237          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Modification Response\n");
12238          for(int i=0; i< encBufSize; i++)
12239          {
12240             printf("%x",encBuf[i]);
12241          }
12242       }
12243
12244       /* Sending  msg  */
12245       if(sendF1APMsg() != ROK)
12246       {
12247          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Res Failed");
12248          ret = RFAILED;
12249          break;
12250       }
12251       break;
12252    }
12253    FreeUeContextModResp(f1apMsg);
12254    return ret;
12255 }
12256 /*******************************************************************
12257  *
12258  * @brief Deallocating the memory allocated by the aper decoder
12259  *          for QOSInfo
12260  *
12261  * @details
12262  *
12263  *    Function : freeAperDecodeQosInfo
12264  *
12265  *    Functionality:  Deallocating the memory allocated for QOSInfo
12266  *
12267  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
12268  *
12269  * @return void
12270  *
12271  * ****************************************************************/
12272
12273 void freeAperDecodeQosInfo(QoSFlowLevelQoSParameters_t *drbQos)
12274 {
12275    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
12276    {
12277       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
12278       {
12279          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
12280          {
12281             free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
12282          }
12283          free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
12284       }
12285       free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI);
12286    }
12287 }
12288 /*******************************************************************
12289  *
12290  * @brief Deallocating the memory allocated by the aper decoder
12291  *          for UlTnlInfoforDrb
12292  *
12293  * @details
12294  *
12295  *    Function : freeAperDecodeUlTnlInfoforDrbSetupMod
12296  *
12297  *    Functionality:  Deallocating memory allocated for UlTnlInfoforDrb
12298  *
12299  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
12300  *
12301  * @return void
12302  *
12303  * ****************************************************************/
12304 void freeAperDecodeUlTnlInfoforDrbSetupMod(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
12305 {
12306    uint8_t arrIdx =0;
12307
12308    if(ulInfo->list.array)
12309    {
12310       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
12311       {
12312          if(ulInfo->list.array[arrIdx])
12313          {
12314             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
12315             {
12316                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
12317                {
12318                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
12319                   {
12320                      free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12321                            gTP_TEID.buf);
12322                   }
12323                   free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12324                         transportLayerAddress.buf);
12325                }
12326                free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel);
12327             }
12328             free(ulInfo->list.array[arrIdx]);
12329          }
12330       }
12331       free(ulInfo->list.array);
12332    }
12333 }
12334 /*******************************************************************
12335  *
12336  * @brief Deallocating the memory allocated by the aper decoder
12337  *          for DrbSetupModItem
12338  *
12339  * @details
12340  *
12341  *    Function : freeAperDecodeDrbSetupModItem
12342  *
12343  *    Functionality:  Deallocating memory allocated for DrbSetupModItem
12344  *
12345  * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
12346  *
12347  * @return void
12348  *
12349  * ****************************************************************/
12350
12351 void freeAperDecodeDrbSetupModItem(DRBs_ToBeSetupMod_Item_t *drbItem)
12352 {
12353    uint8_t arrIdx =0;
12354    SNSSAI_t *snssai =NULLP;
12355    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
12356
12357    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
12358    switch(drbItem->qoSInformation.present)
12359    {
12360       case QoSInformation_PR_NOTHING:
12361          break;
12362       case QoSInformation_PR_eUTRANQoS:
12363          {
12364             if(drbItem->qoSInformation.choice.eUTRANQoS)
12365             {
12366                free(drbItem->qoSInformation.choice.eUTRANQoS);
12367             }
12368             break;
12369          }
12370       case QoSInformation_PR_choice_extension:
12371          {
12372             if(drbItem->qoSInformation.choice.choice_extension)
12373             {
12374                freeAperDecodeQosInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.\
12375                      DRB_Information.dRB_QoS);
12376                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
12377                if(snssai->sST.buf)
12378                {
12379                   free(snssai->sST.buf);
12380                }
12381                if(snssai->sD)
12382                {
12383                   if(snssai->sD->buf)
12384                   {
12385                      free(snssai->sD->buf);
12386                   }
12387                   free(snssai->sD);
12388                }
12389
12390                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.\
12391                          DRB_Information.flows_Mapped_To_DRB_List;
12392                if(flowMap->list.array)
12393                {
12394                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
12395                   {
12396                      if(flowMap->list.array[arrIdx] )
12397                      {
12398                         freeAperDecodeQosInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
12399                         free(flowMap->list.array[arrIdx]);
12400                      }
12401                   }
12402                   free(flowMap->list.array);
12403                }
12404
12405                free(drbItem->qoSInformation.choice.choice_extension);
12406             }
12407             break;
12408          }
12409
12410    }
12411    freeAperDecodeUlTnlInfoforDrbSetupMod(&drbItem->uLUPTNLInformation_ToBeSetup_List);
12412    if(drbItem->uLConfiguration)
12413    {
12414       free(drbItem->uLConfiguration);
12415    }
12416 }
12417
12418 /*******************************************************************
12419  *
12420  * @brief Deallocating the memory allocated by the aper decoder
12421  *          for DrbToBeSetupModList
12422  *
12423  * @details
12424  *
12425  *    Function : freeAperDecodeDrbToBeSetupModList
12426  *
12427  *    Functionality:  Deallocating memory allocated for DrbToBeSetupModList
12428  *
12429  * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
12430  *
12431  * @return void
12432  *
12433  * ****************************************************************/
12434
12435 void freeAperDecodeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
12436 {
12437    uint8_t arrIdx =0;
12438    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
12439
12440    if(drbSet->list.array)
12441    {
12442       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
12443       {
12444          if(drbSet->list.array[arrIdx] != NULLP)
12445          {
12446             if(arrIdx == 0)
12447             {
12448                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
12449                freeAperDecodeDrbSetupModItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
12450             }
12451             free(drbSet->list.array[arrIdx]);
12452          }
12453       }
12454       free(drbSet->list.array);
12455    }
12456
12457 }
12458 /*******************************************************************
12459  *
12460  * @brief Deallocating the memory allocated by the aper decoder
12461  *          for UeContextModificationReqMsg
12462  *
12463  * @details
12464  *
12465  *    Function : freeAperDecodeUeContextModificationReqMsg
12466  *
12467  *    Functionality:  Deallocating memory allocated for
12468  *                  UeContextModificationReqMsg
12469  *
12470  * @params[in] UEContextModificationRequest_t *UeContextModifyReq
12471  *
12472  * @return void
12473  *
12474  * ****************************************************************/
12475 void freeAperDecodeUeContextModificationReqMsg(UEContextModificationRequest_t *UeContextModifyReq )
12476 {
12477    uint8_t arrIdx, ieId;
12478
12479    if(UeContextModifyReq->protocolIEs.list.array)
12480    {
12481       for( arrIdx = 0 ; arrIdx<UeContextModifyReq->protocolIEs.list.count ; arrIdx++)
12482       {
12483          if(UeContextModifyReq->protocolIEs.list.array[arrIdx])
12484          {
12485             ieId = UeContextModifyReq->protocolIEs.list.array[arrIdx]->id;
12486             switch(ieId)
12487             {
12488                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12489                   break;
12490                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12491                   break;
12492                case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
12493                   {
12494                      freeAperDecodeDrbToBeSetupModList(&UeContextModifyReq->protocolIEs.list.array[arrIdx]->\
12495                            value.choice.DRBs_ToBeSetupMod_List);
12496                      break;
12497                   }
12498             }
12499             free(UeContextModifyReq->protocolIEs.list.array[arrIdx]);
12500          }
12501       }
12502       free(UeContextModifyReq->protocolIEs.list.array);
12503    }
12504 }
12505 /*******************************************************************
12506  *
12507  * @brief processing the F1 UeContextModificationReq
12508  *
12509  * @details
12510  *
12511  *    Function : procF1UeContextModificationReq
12512  *
12513  *    Functionality:  processing the F1 UeContextModificationReq
12514  *
12515  * @params[in] F1AP_PDU_t *f1apMsg
12516  *
12517  * @return
12518  * ****************************************************************/
12519 uint8_t procF1UeContextModificationReq(F1AP_PDU_t *f1apMsg)
12520 {
12521    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
12522    uint8_t  ret = ROK, ieIdx = 0, lcId =0,cellIdx=0, ueIdx=0;
12523    DuUeCb   *duUeCb = NULLP;
12524    DRBs_ToBeSetupMod_List_t *drbSetupModCfg;
12525    uint32_t gnbCuUeF1apId, gnbDuUeF1apId;
12526
12527    ueContextModifyReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
12528    for(ieIdx=0; (ieIdx < ueContextModifyReq->protocolIEs.list.count && ret == ROK); ieIdx++)
12529    {
12530       switch(ueContextModifyReq->protocolIEs.list.array[ieIdx]->id)
12531       {
12532          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12533             {
12534                gnbCuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
12535                break;
12536             }
12537          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12538             {
12539                gnbDuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
12540                break;
12541             }
12542          case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
12543             {
12544                for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
12545                {
12546                   for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
12547                   {
12548                      if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
12549                            (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
12550                      {
12551
12552                         duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
12553                         lcId = getDrbLcId(&duUeCb->drbBitMap);
12554                         if(lcId != RFAILED)
12555                         {
12556                            DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
12557                            if(duUeCb->f1UeDb)
12558                            {
12559                               duUeCb->f1UeDb->actionType = UE_CTXT_MOD;
12560                               drbSetupModCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
12561                               choice.DRBs_ToBeSetupMod_List;
12562                               if(extractDrbListToSetup(lcId, NULL, drbSetupModCfg ,drbSetupModCfg->list.count, \
12563                               &duUeCb->f1UeDb->duUeCfg))
12564                               {
12565                                  DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetup()");
12566                                  ret = RFAILED;
12567                               }
12568                            }
12569                         }
12570                      }
12571                      else
12572                      {
12573                         DU_LOG("\nERROR  -->  DU APP : wrong values of gnbCuUeF1apId and gnbDuUeF1apId ");
12574                         ret = RFAILED;
12575                      }
12576                   }
12577                }
12578                break;
12579             }
12580       }
12581    }
12582    if(ret != RFAILED)
12583    {
12584       ret = duProcUeContextModReq(duUeCb);
12585    }
12586    freeAperDecodeUeContextModificationReqMsg(ueContextModifyReq);
12587    return ret;
12588 }
12589 /*****************************************************************i
12590 *
12591 * @brief Free memory allocated for UE Context Release Request
12592 *
12593 * @details
12594 *
12595 *    Function : FreeUeContextReleaseReq
12596 *
12597 *    Functionality:
12598 *         - Free memory allocated for UE Context Release Request
12599 *
12600 * @params[in] F1AP_PDU_t *f1apMsg
12601 * @return void
12602 *
12603 * *************************************************************/
12604 void FreeUeContextReleaseReq(F1AP_PDU_t *f1apMsg)
12605 {
12606    uint8_t ieIdx;
12607    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
12608
12609    if(f1apMsg)
12610    {
12611       if(f1apMsg->choice.initiatingMessage)
12612       {
12613          ueReleaseReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
12614          if(ueReleaseReq->protocolIEs.list.array)
12615          {
12616             for(ieIdx=0 ; ieIdx<ueReleaseReq->protocolIEs.list.count; ieIdx++)
12617             {
12618                DU_FREE(ueReleaseReq->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseRequest_t));
12619             }
12620             DU_FREE(ueReleaseReq->protocolIEs.list.array, ueReleaseReq->protocolIEs.list.size);
12621          }
12622          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
12623       }
12624       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12625    }
12626
12627 }
12628 /*****************************************************************i
12629 *
12630 * @brief Build and Send UE Context Release Request
12631 *
12632 * @details
12633 *
12634 *    Function : BuildAndSendUeContextReleaseReq
12635 *
12636 *    Functionality:
12637 *         - Build and Send UE Context Release Request
12638 *
12639 * @params[in]
12640 * @return ROK     - success
12641 *         RFAILED - failure
12642 *
12643 * *************************************************************/
12644 uint8_t BuildAndSendUeContextReleaseReq(uint16_t cellId, uint8_t ueIdx)
12645 {
12646    bool memAllocFail = false;
12647    uint8_t ieIdx =0;
12648    uint8_t ret = RFAILED;
12649    uint16_t cellIdx =0;
12650    uint16_t crnti = 0;
12651    uint8_t  elementCnt = 0;
12652    uint32_t  gnbCuUeF1apId =0;   /* gNB-CU UE F1AP Id */
12653    uint32_t  gnbDuUeF1apId =0;   /* gNB-DU UE F1AP Id */
12654    asn_enc_rval_t encRetVal;
12655    F1AP_PDU_t *f1apMsg = NULLP;
12656    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
12657
12658    DU_LOG("\nINFO  --> Building the UE Context Release Request");
12659    do
12660    {
12661       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12662       if(f1apMsg == NULLP)
12663       {
12664          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for f1apMsg");
12665          break;
12666       }
12667
12668       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
12669       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
12670       if(f1apMsg->choice.initiatingMessage == NULLP)
12671       {
12672          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for\
12673          initiatingMessage");
12674          break;
12675       }
12676       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextReleaseRequest;
12677       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
12678       f1apMsg->choice.initiatingMessage->value.present = \
12679       InitiatingMessage__value_PR_UEContextReleaseRequest;
12680
12681       ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
12682
12683       elementCnt = 2;
12684
12685       ueReleaseReq->protocolIEs.list.count = elementCnt;
12686       ueReleaseReq->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseRequest_t *);
12687
12688       /* Initialize the F1Setup members */
12689       DU_ALLOC(ueReleaseReq->protocolIEs.list.array,ueReleaseReq->protocolIEs.list.size);
12690       if(ueReleaseReq->protocolIEs.list.array == NULLP)
12691       {
12692          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE array");
12693          break;
12694       }
12695       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
12696       {
12697          DU_ALLOC(ueReleaseReq->protocolIEs.list.array[ieIdx],\
12698                sizeof(UEContextReleaseRequest_t));
12699          if(ueReleaseReq->protocolIEs.list.array[ieIdx] == NULLP)
12700          {
12701             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE elements");
12702             memAllocFail = true;
12703             break;
12704          }
12705       }
12706       if(memAllocFail == true)
12707          break;
12708
12709       /* Fetching Ue Cb Info*/
12710       GET_CELL_IDX(cellId, cellIdx);
12711       if(duCb.actvCellLst[cellIdx] == NULLP)
12712       {
12713          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): CellId[%d] does not exist", cellId);
12714          break;
12715       }
12716       else
12717       {
12718          GET_CRNTI(crnti, ueIdx);
12719          if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].crnti != crnti)
12720          {
12721             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): crnti[%d] does not exist", crnti);
12722             break;
12723          }
12724          gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
12725          gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
12726       }
12727
12728       ieIdx=0;
12729       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
12730       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
12731       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present = \
12732       UEContextReleaseRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
12733       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
12734
12735       ieIdx++;
12736       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
12737       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
12738       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present =\
12739       UEContextReleaseRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
12740       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
12741
12742       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12743
12744       /* Encode the F1SetupRequest type as APER */
12745       memset(encBuf, 0, ENC_BUF_MAX_LEN);
12746       encBufSize = 0;
12747       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
12748       /* Encode results */
12749       if(encRetVal.encoded == ENCODE_FAIL)
12750       {
12751          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseRequest structure (at %s)\n",\
12752                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12753          break;
12754       }
12755       else
12756       {
12757          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseRequest\n");
12758          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
12759          {
12760             printf("%x",encBuf[ieIdx]);
12761          }
12762       }
12763
12764       /* Sending msg */
12765       if(sendF1APMsg() != ROK)
12766       {
12767          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Request failed");
12768          break;
12769       }
12770       ret = ROK;
12771       break;
12772    }while(true);
12773
12774    FreeUeContextReleaseReq(f1apMsg);
12775    return ret;
12776 }
12777 /*****************************************************************i
12778  *
12779  * @brief Free memory allocated for UE Context Release Complete
12780  *
12781  * @details
12782  *
12783  *    Function : FreeUeContextReleaseComplete
12784  *
12785  *    Functionality:
12786  *         - Free memory allocated for UE Context Release Complete
12787  *
12788  * @params[in] F1AP_PDU_t *f1apMsg
12789  * @return void
12790  *
12791  * *************************************************************/
12792 void FreeUeContextReleaseComplete(F1AP_PDU_t *f1apMsg)
12793 {
12794    uint8_t ieIdx;
12795    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
12796
12797    if(f1apMsg)
12798    {
12799       if(f1apMsg->choice.successfulOutcome)
12800       {
12801          ueReleaseComplete =&f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
12802          if(ueReleaseComplete->protocolIEs.list.array)
12803          {
12804             for(ieIdx=0 ; ieIdx<ueReleaseComplete->protocolIEs.list.count; ieIdx++)
12805             {
12806                DU_FREE(ueReleaseComplete->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseComplete_t));
12807             }
12808             DU_FREE(ueReleaseComplete->protocolIEs.list.array, ueReleaseComplete->protocolIEs.list.size);
12809          }
12810          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12811       }
12812       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12813    }
12814
12815 }
12816 /*****************************************************************i
12817  *
12818  * @brief Build and Send UE Context Release Complete
12819  *
12820  * @details
12821  *
12822  *    Function : BuildAndSendUeContextReleaseComplete
12823  *
12824  *    Functionality:
12825  *         - Build and Send UE Context Release Complete
12826  *
12827  * @params[in]  cellId,  gnbCuUeF1apId, gnbDuUeF1apId
12828  * @return ROK     - success
12829  *         RFAILED - failure
12830  *
12831  * *************************************************************/
12832 uint8_t BuildAndSendUeContextReleaseComplete(uint16_t cellId, uint32_t gnbCuUeF1apId, uint32_t gnbDuUeF1apId)
12833 {
12834    bool memAllocFail = false;
12835    uint8_t ieIdx =0, ret = RFAILED, elementCnt = 0;
12836    asn_enc_rval_t encRetVal;
12837    F1AP_PDU_t *f1apMsg = NULLP;
12838    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
12839
12840    DU_LOG("\nINFO  --> Building the UE Context Release Complete");
12841    do
12842    {
12843       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12844       if(f1apMsg == NULLP)
12845       {
12846          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for f1apMsg");
12847          break;
12848       }
12849
12850       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
12851       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12852       if(f1apMsg->choice.successfulOutcome == NULLP)
12853       {
12854          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for\
12855                successfulOutcome");
12856          break;
12857       }
12858       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextRelease;
12859       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
12860       f1apMsg->choice.successfulOutcome->value.present = \
12861       SuccessfulOutcome__value_PR_UEContextReleaseComplete;
12862
12863       ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
12864
12865       elementCnt = 2;
12866       ueReleaseComplete->protocolIEs.list.count = elementCnt;
12867       ueReleaseComplete->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseComplete_t *);
12868
12869       /* Initialize the UE Release Complete members */
12870       DU_ALLOC(ueReleaseComplete->protocolIEs.list.array,ueReleaseComplete->protocolIEs.list.size);
12871       if(ueReleaseComplete->protocolIEs.list.array == NULLP)
12872       {
12873          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE array");
12874          break;
12875       }
12876       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
12877       {
12878          DU_ALLOC(ueReleaseComplete->protocolIEs.list.array[ieIdx],\
12879                sizeof(UEContextReleaseComplete_t));
12880          if(ueReleaseComplete->protocolIEs.list.array[ieIdx] == NULLP)
12881          {
12882             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE\
12883             elements");
12884             memAllocFail = true;
12885             break;
12886          }
12887       }
12888       if(memAllocFail == true)
12889          break;
12890
12891
12892       ieIdx=0;
12893       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
12894       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
12895       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present = \
12896       UEContextReleaseCompleteIEs__value_PR_GNB_CU_UE_F1AP_ID;
12897       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
12898
12899       ieIdx++;
12900       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
12901       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
12902       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present =\
12903       UEContextReleaseCompleteIEs__value_PR_GNB_DU_UE_F1AP_ID;
12904       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
12905
12906       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12907
12908       /* Encode the F1SetupComplete type as APER */
12909       memset(encBuf, 0, ENC_BUF_MAX_LEN);
12910       encBufSize = 0;
12911       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
12912       /* Encode results */
12913       if(encRetVal.encoded == ENCODE_FAIL)
12914       {
12915          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseComplete structure (at %s)\n",\
12916                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12917          break;
12918       }
12919       else
12920       {
12921          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseComplete\n");
12922          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
12923          {
12924             printf("%x",encBuf[ieIdx]);
12925          }
12926       }
12927
12928       /* Sending msg */
12929       if(sendF1APMsg() != ROK)
12930       {
12931          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Complete failed");
12932          break;
12933       }
12934       ret = ROK;
12935       break;
12936    }while(true);
12937
12938    if(ret == ROK)
12939    {
12940       duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
12941       ret = duSendCellDeletReq(cellId);
12942       if(ret != ROK)
12943       {
12944          DU_LOG("\nERROR  -->  F1AP: BuildAndSendUeContextReleaseComplete(): Failed to process cell\
12945                Delete req for CellId");
12946       }
12947    }
12948    FreeUeContextReleaseComplete(f1apMsg);
12949    return ret;
12950
12951 }
12952
12953 /*******************************************************************
12954 *
12955 * @brief added free part for the memory allocated by aper_decoder
12956 *
12957 * @details
12958 *
12959 *    Function : freeAperDecodeUeContextReleaseCommand
12960 *
12961 *    Functionality: added free part for the memory allocated by aper_decoder
12962 *
12963 * @params[in] F1AP_PDU_t *f1apMsg
12964 * @return void
12965 *
12966 * ****************************************************************/
12967 void freeAperDecodeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
12968 {
12969    uint8_t ieIdx=0;
12970    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
12971
12972    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
12973
12974    if(ueContextReleaseCommand->protocolIEs.list.array)
12975    {
12976       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
12977       {
12978          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
12979          {
12980             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
12981             {
12982                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12983                   break;
12984                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12985                   break;
12986                case ProtocolIE_ID_id_Cause:
12987                   break;
12988                case ProtocolIE_ID_id_RRCContainer:
12989                {
12990                   if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
12991                   {
12992                      free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
12993                   }
12994                   break;
12995                }
12996                default :
12997                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
12998                        ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
12999                   break;
13000             }
13001          }
13002          free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]);
13003       }
13004       free(ueContextReleaseCommand->protocolIEs.list.array);
13005    }
13006 }
13007 /*******************************************************************
13008 *
13009 * @brief processing of UE Context Release Command
13010 *
13011 * @details
13012 *
13013 *    Function : procF1UeContextReleaseCommand
13014 *
13015 *    Functionality: processing of UE Context Release Command
13016 *
13017 * @params[in] F1AP_PDU_t *f1apMsg
13018 * @return void
13019 *
13020 * ****************************************************************/
13021 uint8_t procF1UeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
13022 {
13023    uint8_t  ieIdx=0, ret=ROK, ueIdx=0;
13024    uint16_t cellIdx =0;
13025    bool ueIdxFound;
13026    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0;
13027    DuUeCb   *duUeCb = NULLP;
13028    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
13029
13030    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
13031
13032    if(ueContextReleaseCommand->protocolIEs.list.array)
13033    {
13034       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
13035       {
13036          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
13037          {
13038             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
13039             {
13040                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13041                   {
13042                      gnbCuUeF1apId= ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13043                                     value.choice.GNB_CU_UE_F1AP_ID;
13044                      break;
13045                   }
13046
13047                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13048                   {
13049                      gnbDuUeF1apId = ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13050                                      value.choice.GNB_DU_UE_F1AP_ID;
13051                      break;
13052                   }
13053
13054                case ProtocolIE_ID_id_Cause:
13055                   {
13056                      break;
13057                   }
13058
13059                case ProtocolIE_ID_id_RRCContainer:
13060                   {
13061                      for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
13062                      {
13063                         for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
13064                         {
13065                            if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
13066                                  (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
13067                            {
13068                               duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
13069                               DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
13070                               if(duUeCb->f1UeDb)
13071                               {
13072                                  memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
13073                                  duUeCb->f1UeDb->actionType = UE_CTXT_RELEASE;
13074                                  duUeCb->f1UeDb->cellIdx = cellIdx;
13075                                  /* Filling Dl RRC Msg Info */
13076                                  DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
13077                                  if(!duUeCb->f1UeDb->dlRrcMsg)
13078                                  {
13079                                     DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
13080                                     Memory allocation failed ");
13081                                     ret = RFAILED;
13082                                  }
13083                                  else
13084                                  {
13085                                     duUeCb->f1UeDb->dlRrcMsgPres = true;
13086                                     memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
13087                                     ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
13088                                           &ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13089                                           value.choice.RRCContainer);
13090                                  }
13091
13092                               }
13093                               else
13094                               {
13095                                  DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
13096                                  Memory allocation failed ");
13097                                  ret = RFAILED;
13098
13099                               }
13100
13101                               ueIdxFound = true;
13102                               break;
13103                            }
13104                         }
13105                         if(ueIdxFound == true)
13106                         {
13107                            break;
13108                         }
13109                      }
13110                      if(!ueIdxFound)
13111                      {
13112                         DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
13113                         ret = RFAILED;
13114                      }
13115
13116
13117                      break;
13118                   }
13119                default :
13120                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
13121                         ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
13122                   break;
13123             }
13124          }
13125       }
13126    }
13127    if(ret != RFAILED)
13128    {
13129       duProcUeContextReleaseCommand(duUeCb);
13130    }
13131    freeAperDecodeUeContextReleaseCommand(f1apMsg);
13132    return ret;
13133 }
13134 /**************************************************************
13135  *
13136  * @brief Handles received F1AP message and sends back response
13137  *
13138  * @details
13139  *
13140  *    Function : F1APMsgHdlr
13141  *
13142  *    Functionality:
13143  *         - Decodes received F1AP control message
13144  *         - Prepares response message, encodes and sends to SCTP
13145  *
13146  * @params[in]
13147  * @return ROK     - success
13148  *         RFAILED - failure
13149  *
13150  * ****************************************************************/
13151 void F1APMsgHdlr(Buffer *mBuf)
13152 {
13153    int i =0;
13154    char *recvBuf =NULLP;
13155    MsgLen copyCnt =0;
13156    MsgLen recvBufLen =0;
13157    F1AP_PDU_t *f1apMsg =NULLP;
13158    asn_dec_rval_t rval; /* Decoder return value */
13159    F1AP_PDU_t f1apasnmsg ;
13160    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
13161    ODU_PRINT_MSG(mBuf, 0,0);
13162
13163    /* Copy mBuf into char array to decode it */
13164    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
13165    DU_ALLOC(recvBuf, (Size)recvBufLen);
13166
13167    if(recvBuf == NULLP)
13168    {
13169       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
13170       return;
13171    }
13172    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
13173    {
13174       DU_LOG("\nERROR   -->  F1AP : Failed while copying %d", copyCnt);
13175       return;
13176    }
13177
13178    printf("\nDEBUG   -->  F1AP : Received flat buffer to be decoded : ");
13179    for(i=0; i< recvBufLen; i++)
13180    {
13181       printf("%x",recvBuf[i]);
13182    }
13183
13184    /* Decoding flat buffer into F1AP messsage */
13185    f1apMsg = &f1apasnmsg;
13186    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
13187
13188    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
13189    DU_FREE(recvBuf, (Size)recvBufLen);
13190
13191    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
13192    {
13193       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
13194       return;
13195    }
13196    printf("\n");
13197    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13198
13199    switch(f1apMsg->present)
13200    {
13201       case F1AP_PDU_PR_successfulOutcome:
13202          {
13203             switch(f1apMsg->choice.successfulOutcome->value.present)
13204             {
13205                case SuccessfulOutcome__value_PR_ResetAcknowledge:
13206                   {
13207                      DU_LOG("\nINFO   -->  F1AP : F1ResetAcknowledge is received successfully ");
13208                      break;
13209                   }
13210                case SuccessfulOutcome__value_PR_F1SetupResponse:
13211                   {
13212 #ifndef ODU_TEST_STUB
13213                      procF1SetupRsp(f1apMsg);
13214 #endif
13215                      break;
13216                   }
13217
13218                case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
13219                   {
13220                      procF1GNBDUCfgUpdAck(f1apMsg);
13221                      break;
13222                   }
13223
13224                default:
13225                   {
13226                      DU_LOG("\nERROR  -->  F1AP : Invalid type of SuccessfulOutcome__value_PR_ResetAcknowledge [%d]",\
13227                            f1apMsg->choice.successfulOutcome->value.present);
13228                      return;
13229                   }
13230             }/* End of switch(successfulOutcome) */
13231             free(f1apMsg->choice.successfulOutcome);
13232             break;
13233          }
13234       case F1AP_PDU_PR_initiatingMessage:
13235          {
13236             switch(f1apMsg->choice.initiatingMessage->value.present)
13237             {
13238                case InitiatingMessage__value_PR_Reset:
13239                   {
13240                      procF1ResetReq(f1apMsg);
13241                      break;
13242                   }
13243                case InitiatingMessage__value_PR_DLRRCMessageTransfer:
13244                   {
13245                      procF1DlRrcMsgTrans(f1apMsg);
13246                      break;
13247                   }
13248                case InitiatingMessage__value_PR_UEContextSetupRequest:
13249                   {
13250                      procF1UeContextSetupReq(f1apMsg);
13251                      break;
13252                   }
13253                case InitiatingMessage__value_PR_UEContextModificationRequest:
13254                   {
13255                      procF1UeContextModificationReq(f1apMsg);
13256                      break;
13257                   }
13258                case InitiatingMessage__value_PR_UEContextReleaseCommand:
13259                   {
13260                       procF1UeContextReleaseCommand(f1apMsg);
13261                       break;
13262                   }
13263                default:
13264                   {
13265                      DU_LOG("\nERROR  -->  F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
13266                            f1apMsg->choice.initiatingMessage->value.present);
13267                      return;
13268                   }
13269             }/* End of switch(initiatingMessage) */
13270             free(f1apMsg->choice.initiatingMessage);
13271             break;
13272          }
13273
13274       default:
13275          {
13276             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
13277             return;
13278          }
13279          free(f1apMsg);
13280
13281    }/* End of switch(f1apMsg->present) */
13282
13283 } /* End of F1APMsgHdlr */
13284
13285 /**********************************************************************
13286   End of file
13287  **********************************************************************/