src/du_app/du_f1ap_msg_hdl.c

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   4 #                                                                              #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
   6 #   you may not use this file except in compliance with the License.           #
   7 #   You may obtain a copy of the License at                                    #
   8 #                                                                              #
   9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10 #                                                                              #
  11 #   Unless required by applicable law or agreed to in writing, software        #
  12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
  14 #   See the License for the specific language governing permissions and        #
  15 #   limitations under the License.                                             #
  16 ################################################################################
  17 *******************************************************************************/
  18
  19 /* This file contains F1AP message handler functions */
  20 #include "common_def.h"
  21 #include "lrg.h"
  22 #include "legtp.h"
  23 #include "lkw.x"
  24 #include "lrg.x"
  25 #include "F1AP-PDU.h"
  26 #include "du_app_mac_inf.h"
  27 #include "du_cfg.h"
  28 #include "du_app_rlc_inf.h"
  29 #include "du_mgr_main.h"
  30 #include "du_utils.h"
  31 #include "RAT-Type.h"
  32 #include "FeatureSetUplinkPerCC.h"
  33 #include "FeatureSetDownlinkPerCC.h"
  34 #include "FeatureSets.h"
  35 #include "UE-NR-Capability.h"
  36 #include "UE-CapabilityRAT-Container.h"
  37 #include "UE-CapabilityRAT-ContainerListRRC.h"
  38 #include "GNB-DU-System-Information.h"
  39 #include "CellGroupConfigRrc.h"
  40 #include "MAC-CellGroupConfig.h"
  41 #include "SchedulingRequestConfig.h"
  42 #include "SchedulingRequestToAddMod.h"
  43 #include "BSR-Config.h"
  44 #include "TAG-Config.h"
  45 #include "TAG.h"
  46 #include "PHR-Config.h"
  47 #include "RLC-Config.h"
  48 #include "UL-AM-RLC.h"
  49 #include "DL-AM-RLC.h"
  50 #include "LogicalChannelConfig.h"
  51 #include "RLC-BearerConfig.h"
  52 #include "PhysicalCellGroupConfig.h"
  53 #include "SpCellConfig.h"
  54 #include "TDD-UL-DL-ConfigDedicated.h"
  55 #include "ServingCellConfig.h"
  56 #include "ControlResourceSet.h"
  57 #include "SearchSpace.h"
  58 #include "PDCCH-Config.h"
  59 #include "PDSCH-TimeDomainResourceAllocation.h"
  60 #include "PDSCH-TimeDomainResourceAllocationList.h"
  61 #include "PDSCH-CodeBlockGroupTransmission.h"
  62 #include "PDSCH-ServingCellConfig.h"
  63 #include "DMRS-DownlinkConfig.h"
  64 #include "PDSCH-Config.h"
  65 #include "BWP-DownlinkDedicated.h"
  66 #include "PUSCH-TimeDomainResourceAllocation.h"
  67 #include "PUSCH-TimeDomainResourceAllocationList.h"
  68 #include "DMRS-UplinkConfig.h"
  69 #include "PUSCH-Config.h"
  70 #include "SRS-ResourceId.h"
  71 #include "SRS-Resource.h"
  72 #include "SRS-ResourceSet.h"
  73 #include "SRS-Config.h"
  74 #include "BWP-UplinkDedicated.h"
  75 #include "PUSCH-ServingCellConfig.h"
  76 #include "UplinkConfig.h"
  77 #include "DUtoCURRCContainer.h"
  78 #include "GBR-QoSFlowInformation.h"
  79 #include "QoSFlowLevelQoSParameters.h"
  80 #include "PUCCH-Config.h"
  81 #include "PUCCH-ResourceSet.h"
  82 #include "PUCCH-Resource.h"
  83 #include "PUCCH-PowerControl.h"
  84 #include "P0-PUCCH.h"
  85 #include "PUCCH-PathlossReferenceRS.h"
  86 #include "PUCCH-format0.h"
  87 #include "PUCCH-format1.h"
  88 #include "PUCCH-format2.h"
  89 #include "PUCCH-format3.h"
  90 #include "PUCCH-format4.h"
  91 #include "PUCCH-FormatConfig.h"
  92 #include "SchedulingRequestResourceConfig.h"
  93 #include<ProtocolIE-Field.h>
  94 #include "ProtocolExtensionField.h"
  95 #include "odu_common_codec.h"
  96 #include "du_mgr.h"
  97 #include "du_cell_mgr.h"
  98 #include "du_f1ap_msg_hdl.h"
  99 #include "DRBs-Setup-Item.h"
 100 #include "DLUPTNLInformation-ToBeSetup-List.h"
 101 #include "DLUPTNLInformation-ToBeSetup-Item.h"
 102 #include "UPTransportLayerInformation.h"
 103 #include "GTPTunnel.h"
 104
 105 #ifdef O1_ENABLE
 106 #include "ConfigInterface.h"
 107 extern StartupConfig g_cfg;
 108 #endif
 109
 110 DuCfgParams duCfgParam;
 111
 112 /************************************************************************
 113  *
 114  * @brief Converts enum values into actual value of Poll retransmit timer
 115  *
 116  * @details
 117  *
 118  *    Function : getPollPdu
 119  *
 120  *    Functionality: Converts enum values into actual value of poll
 121  *    retransmit timer
 122  *
 123  * @params[in] Enum value of pollPdu
 124  * @return Actual value of pollPdu
 125  *
 126  * **********************************************************************/
 127
 128 uint16_t getPollRetxTmr(uint8_t pollRetxTmrCfg)
 129 {
 130    uint16_t pollRetxTmr;
 131
 132    /* All values of poll retx timer are at interval of 5ms.
 133     * This is valid upto 250ms
 134     * Hence converting the enum value to actual value by multiplying it to 5
 135     */
 136    if(pollRetxTmrCfg <= T_PollRetransmit_ms250)
 137       pollRetxTmr = (pollRetxTmrCfg + 1) * 5;
 138    else
 139    {
 140       switch(pollRetxTmrCfg)
 141       {
 142          case T_PollRetransmit_ms300:
 143             pollRetxTmr = 300;
 144             break;
 145          case T_PollRetransmit_ms350:
 146             pollRetxTmr = 350;
 147             break;
 148          case T_PollRetransmit_ms400:
 149             pollRetxTmr = 400;
 150             break;
 151          case T_PollRetransmit_ms450:
 152             pollRetxTmr = 450;
 153             break;
 154          case T_PollRetransmit_ms500:
 155             pollRetxTmr = 500;
 156             break;
 157          case T_PollRetransmit_ms800:
 158             pollRetxTmr = 800;
 159             break;
 160          default:
 161             DU_LOG("\nERROR  -->  F1AP: Invalid value of Poll Retransmit timer");
 162             pollRetxTmr = 0;
 163       }
 164    }
 165    return pollRetxTmr;
 166 }
 167
 168 /*******************************************************************
 169  *
 170  * @brief Converts enum values into actual value of PollPdu
 171  *
 172  * @details
 173  *
 174  *    Function : getPollPdu
 175  *
 176  *    Functionality: Converts enum values into actual value of PollPdu
 177  *
 178  * @params[in] Enum value of pollPdu
 179  * @return Actual value of pollPdu
 180  *
 181  * ****************************************************************/
 182 int32_t getPollPdu(uint8_t pollPduCfg)
 183 {
 184    int32_t pollPdu;
 185    switch(pollPduCfg)
 186    {
 187       case PollPDU_p4:
 188          pollPdu = 4;
 189          break;
 190       case PollPDU_p8:
 191          pollPdu = 8;
 192          break;
 193       case PollPDU_p16:
 194          pollPdu = 16;
 195          break;
 196       case PollPDU_p32:
 197          pollPdu = 32;
 198          break;
 199       case PollPDU_p64:
 200          pollPdu = 64;
 201          break;
 202       case PollPDU_p128:
 203          pollPdu = 128;
 204          break;
 205       case PollPDU_p256:
 206          pollPdu = 256;
 207          break;
 208       case PollPDU_p512:
 209          pollPdu = 512;
 210          break;
 211       case PollPDU_p1024:
 212          pollPdu = 1024;
 213          break;
 214       case PollPDU_p2048:
 215          pollPdu = 2048;
 216          break;
 217       case PollPDU_p4096:
 218          pollPdu = 4096;
 219          break;
 220       case PollPDU_p6144:
 221          pollPdu = 6144;
 222          break;
 223       case PollPDU_p8192:
 224          pollPdu = 8192;
 225          break;
 226       case PollPDU_p12288:
 227          pollPdu = 12288;
 228          break;
 229       case PollPDU_p16384:
 230          pollPdu = 16384;
 231          break;
 232       case PollPDU_p20480:
 233          pollPdu = 20480;
 234          break;
 235       case PollPDU_p24576:
 236          pollPdu = 24576;
 237          break;
 238       case PollPDU_p28672:
 239          pollPdu = 28672;
 240          break;
 241       case PollPDU_p32768:
 242          pollPdu = 32768;
 243          break;
 244       case PollPDU_p40960:
 245          pollPdu = 40960;
 246          break;
 247       case PollPDU_p49152:
 248          pollPdu = 49152;
 249          break;
 250       case PollPDU_p57344:
 251          pollPdu = 57344;
 252          break;
 253       case PollPDU_p65536:
 254          pollPdu = 65536;
 255          break;
 256       case PollPDU_infinity:
 257          pollPdu = -1;
 258          break;
 259       default:
 260          DU_LOG("\nERROR  -->  F1AP: Invalid value of poll pdu");
 261          pollPdu = 0;
 262          break;
 263    }
 264    return pollPdu;
 265 }
 266
 267 /*******************************************************************
 268  *
 269  * @brief Converts enum values into actual value of poll bytes
 270  *
 271  * @details
 272  *
 273  *    Function : getPollByte
 274  *
 275  *    Functionality: Converts enum values into actual value of pollBytes
 276  *
 277  * @params[in] Enum value
 278  * @return Actual value
 279  *
 280  * ****************************************************************/
 281 int32_t getPollByte(uint16_t pollBytesCfg)
 282 {
 283    int32_t pollBytes;
 284    switch(pollBytesCfg)
 285    {
 286       case PollByte_kB1:
 287          pollBytes = 1000;
 288          break;
 289       case PollByte_kB2:
 290          pollBytes = 2000;
 291          break;
 292       case PollByte_kB5:
 293          pollBytes = 5000;
 294          break;
 295       case PollByte_kB8:
 296          pollBytes = 8000;
 297          break;
 298       case PollByte_kB10:
 299          pollBytes = 10000;
 300          break;
 301       case PollByte_kB15:
 302          pollBytes = 15000;
 303          break;
 304       case PollByte_kB25:
 305          pollBytes = 25000;
 306          break;
 307       case PollByte_kB50:
 308          pollBytes = 50000;
 309          break;
 310       case PollByte_kB75:
 311          pollBytes = 75000;
 312          break;
 313       case PollByte_kB100:
 314          pollBytes = 100000;
 315          break;
 316       case PollByte_kB125:
 317          pollBytes = 125000;
 318          break;
 319       case PollByte_kB250:
 320          pollBytes = 250000;
 321          break;
 322       case PollByte_kB375:
 323          pollBytes = 375000;
 324          break;
 325       case PollByte_kB500:
 326          pollBytes = 500000;
 327          break;
 328       case PollByte_kB750:
 329          pollBytes = 750000;
 330          break;
 331       case PollByte_kB1000:
 332          pollBytes = 1000000;
 333          break;
 334       case PollByte_kB1250:
 335          pollBytes = 1250000;
 336          break;
 337       case PollByte_kB1500:
 338          pollBytes = 1500000;
 339          break;
 340       case PollByte_kB2000:
 341          pollBytes = 2000000;
 342          break;
 343       case PollByte_kB3000:
 344          pollBytes = 3000000;
 345          break;
 346       case PollByte_kB4000:
 347          pollBytes = 4000000;
 348          break;
 349       case PollByte_kB4500:
 350          pollBytes = 4500000;
 351          break;
 352       case PollByte_kB5000:
 353          pollBytes = 5000000;
 354          break;
 355       case PollByte_kB5500:
 356          pollBytes = 5500000;
 357          break;
 358       case PollByte_kB6000:
 359          pollBytes = 6000000;
 360          break;
 361       case PollByte_kB6500:
 362          pollBytes = 6500000;
 363          break;
 364       case PollByte_kB7000:
 365          pollBytes = 7000000;
 366          break;
 367       case PollByte_kB7500:
 368          pollBytes = 7500000;
 369          break;
 370       case PollByte_mB8:
 371          pollBytes = 8000000;
 372          break;
 373       case PollByte_mB9:
 374          pollBytes = 9000000;
 375          break;
 376       case PollByte_mB10:
 377          pollBytes = 10000000;
 378          break;
 379       case PollByte_mB11:
 380          pollBytes = 11000000;
 381          break;
 382       case PollByte_mB12:
 383          pollBytes = 12000000;
 384          break;
 385       case PollByte_mB13:
 386          pollBytes = 13000000;
 387          break;
 388       case PollByte_mB14:
 389          pollBytes = 14000000;
 390          break;
 391       case PollByte_mB15:
 392          pollBytes = 15000000;
 393          break;
 394       case PollByte_mB16:
 395          pollBytes = 16000000;
 396          break;
 397       case PollByte_mB17:
 398          pollBytes = 17000000;
 399          break;
 400       case PollByte_mB18:
 401          pollBytes = 18000000;
 402          break;
 403       case PollByte_mB20:
 404          pollBytes = 20000000;
 405          break;
 406       case PollByte_mB25:
 407          pollBytes = 25000000;
 408          break;
 409       case PollByte_mB30:
 410          pollBytes = 30000000;
 411          break;
 412       case PollByte_mB40:
 413          pollBytes = 40000000;
 414          break;
 415       case PollByte_infinity:
 416          pollBytes = -1;
 417          break;
 418       default:
 419          DU_LOG("\nERROR  -->  F1AP: Invalid value of poll bytes");
 420          pollBytes = 0;
 421    }
 422    return pollBytes;
 423 }
 424
 425 /*******************************************************************
 426  *
 427  * @brief Converts enum values into actual value of maxRetx
 428  *
 429  * @details
 430  *
 431  *    Function : getMaxRetx
 432  *
 433  *    Functionality: Converts enum values into actual value of maxRetx
 434  *
 435  * @params[in] Enum value
 436  * @return Actual value
 437  *
 438  * ****************************************************************/
 439 uint8_t getMaxRetx(uint8_t maxRetxCfg)
 440 {
 441    uint8_t maxRetx;
 442    switch(maxRetxCfg)
 443    {
 444       case UL_AM_RLC__maxRetxThreshold_t1:
 445          maxRetx = 1;
 446          break;
 447       case UL_AM_RLC__maxRetxThreshold_t2:
 448          maxRetx = 2;
 449          break;
 450       case UL_AM_RLC__maxRetxThreshold_t3:
 451          maxRetx = 3;
 452          break;
 453       case UL_AM_RLC__maxRetxThreshold_t4:
 454          maxRetx = 4;
 455          break;
 456       case UL_AM_RLC__maxRetxThreshold_t6:
 457          maxRetx = 6;
 458          break;
 459       case UL_AM_RLC__maxRetxThreshold_t8:
 460          maxRetx = 8;
 461          break;
 462       case UL_AM_RLC__maxRetxThreshold_t16:
 463          maxRetx = 16;
 464          break;
 465       case UL_AM_RLC__maxRetxThreshold_t32:
 466          maxRetx = 32;
 467          break;
 468       default:
 469          DU_LOG("\nERROR  -->  F1AP: Invalid configuration for Max retransmission threshold");
 470          maxRetx = 0;
 471    }
 472    return maxRetx;
 473 }
 474
 475 /*******************************************************************
 476  * @brief Converts enum values into actual value of reassembly timer
 477  *
 478  * @details
 479  *
 480  *    Function : getReAsmblTmr
 481  *
 482  *    Functionality: Converts enum values into actual value of reassembly
 483  *    timer
 484  *
 485  * @params[in] Enum value of reassembly timer
 486  * @return Actual value of reassembly timer
 487  *
 488  * **********************************************************************/
 489
 490 int8_t getReAsmblTmr(uint8_t reAsmblTmrCfg)
 491 {
 492    int8_t reAsmblTmr = 0;
 493
 494    if(reAsmblTmrCfg == T_Reassembly_ms0)
 495    {
 496       reAsmblTmr = 0;
 497    }
 498    else if(reAsmblTmrCfg >= T_Reassembly_ms5 || reAsmblTmrCfg <= T_Reassembly_ms100)
 499    {
 500      /* All values of re assembly timer are at interval of 5ms.
 501       * This is valid upto 100ms
 502       * Hence converting the enum value to actual value by multiplying it to 5
 503       */
 504       reAsmblTmr = reAsmblTmrCfg * 5;
 505    }
 506    else if(reAsmblTmrCfg >= T_Reassembly_ms110 || reAsmblTmrCfg <= T_Reassembly_ms200)
 507    {
 508      /* All values of re assembly timer are at interval of 10ms.
 509       * This is valid upto 200ms
 510       * since enum value starts from 20 for 100ms, subtracting 10 and
 511       * converting the enum value to actual value by multiplying it to 10
 512       */
 513       reAsmblTmr = ((reAsmblTmrCfg-10) * 10);
 514    }
 515    else
 516    {
 517       DU_LOG("\nERROR  -->  F1AP : Invalid value of Re Assembly timer %d", reAsmblTmrCfg);
 518       reAsmblTmr = -1;
 519    }
 520    return reAsmblTmr;
 521 }
 522
 523 /************************************************************************
 524  *
 525  * @brief Converts enum values into actual value of status prohibit timer
 526  *
 527  * @details
 528  *
 529  *    Function : getStatProhTmr
 530  *
 531  *    Functionality: Converts enum values into actual value of status prohibit
 532  *    timer
 533  *
 534  * @params[in] Enum value of status prohibit timer
 535  * @return Actual value of status prohibit timer
 536  *
 537  * **********************************************************************/
 538
 539 int16_t getStatProhTmr(uint8_t statProhTmrCfg)
 540 {
 541    int16_t statProhTmr =0;
 542
 543    if(statProhTmrCfg == T_StatusProhibit_ms0)
 544    {
 545       statProhTmr = 0;
 546    }
 547    else if(statProhTmrCfg >= T_StatusProhibit_ms5 || statProhTmrCfg <= T_StatusProhibit_ms250)
 548    {
 549       /* All values of re assembly timer are at interval of 5ms.
 550        * This is valid upto 250ms
 551        * Hence converting the enum value to actual value by multiplying it to 5
 552        */
 553       statProhTmr = statProhTmrCfg * 5;
 554    }
 555    else
 556    {
 557       switch(statProhTmrCfg)
 558       {
 559          case T_StatusProhibit_ms300:
 560             statProhTmr = 300;
 561             break;
 562          case T_StatusProhibit_ms350:
 563             statProhTmr = 350;
 564             break;
 565          case T_StatusProhibit_ms400:
 566             statProhTmr = 400;
 567             break;
 568          case T_StatusProhibit_ms450:
 569             statProhTmr = 450;
 570             break;
 571          case T_StatusProhibit_ms500:
 572             statProhTmr = 500;
 573             break;
 574          case T_StatusProhibit_ms800:
 575             statProhTmr = 800;
 576             break;
 577          case T_StatusProhibit_ms1000:
 578             statProhTmr = 1000;
 579             break;
 580          case T_StatusProhibit_ms1200:
 581             statProhTmr = 1200;
 582             break;
 583          case T_StatusProhibit_ms1600:
 584             statProhTmr = 1600;
 585             break;
 586          case T_StatusProhibit_ms2000:
 587             statProhTmr = 2000;
 588             break;
 589          case T_StatusProhibit_ms2400:
 590             statProhTmr = 2400;
 591             break;
 592          default:
 593             DU_LOG("\nInvalid value of Status Prohibit timer %d", statProhTmrCfg);
 594             statProhTmr = -1;
 595             break;
 596       }
 597    }
 598    return statProhTmr;
 599 }
 600
 601 /*******************************************************************
 602 *
 603 * @brief Adding F1AP pdu to reserved pdu list
 604 *
 605 * @details
 606 *
 607 *    Function : addToReservedF1apPduList
 608 *
 609 *    Functionality: Adding F1AP pdu to reserved pdu list.
 610 *     These pdu are awaiting aknowledgment from CU
 611 *
 612 * @params[in] uint8_t transId, F1AP_PDU_t *f1apMsg
 613 *
 614 * @return ROK - success
 615 *         RFAILED - failure
 616 *
 617 * ****************************************************************/
 618
 619 void addToReservedF1apPduList(uint8_t transId, F1AP_PDU_t *f1apPdu)
 620 {
 621    CmLList         *node = NULLP;
 622    ReservedF1apPduInfo *pduInfo = NULLP;
 623    DU_ALLOC(pduInfo, sizeof(ReservedF1apPduInfo));
 624    if(pduInfo)
 625    {
 626       DU_ALLOC(node, sizeof(CmLList));
 627       if(node)
 628       {
 629          pduInfo->transId = transId;
 630          pduInfo->f1apMsg = (void*) f1apPdu;
 631
 632          node->node = (PTR)pduInfo;
 633          cmLListAdd2Tail(&duCb.reservedF1apPduList, node);
 634       }
 635    }
 636 }
 637
 638 /*******************************************************************
 639 *
 640 * @brief searching for F1AP pdu from ReservedF1apPduList
 641 *
 642 * @details
 643 *
 644 *    Function : searchFromReservedF1apPduList
 645 *
 646 *    Functionality: searching for F1AP pdu information
 647 *
 648 * @params[in] uint8_t transId
 649 *
 650 * @return pointer to F1AP_PDU_t
 651 *
 652 * ****************************************************************/
 653
 654 CmLList *searchFromReservedF1apPduList(uint8_t transId)
 655 {
 656    CmLList         *node;
 657    ReservedF1apPduInfo *f1apPdu;
 658    if(duCb.reservedF1apPduList.count)
 659    {
 660       CM_LLIST_FIRST_NODE(&duCb.reservedF1apPduList, node);
 661       while(node)
 662       {
 663          f1apPdu = (ReservedF1apPduInfo*)node->node;
 664          if(f1apPdu->transId == transId)
 665          {
 666             return node;
 667          }
 668          node = node->next;
 669       }
 670    }
 671    return NULL;
 672 }
 673
 674 /*******************************************************************
 675 *
 676 * @brief deleting F1AP pdu information from ReservedF1apPduList
 677 *
 678 * @details
 679 *
 680 *    Function : deleteFromReservedF1apPduList
 681 *
 682 *    Functionality: deleting pdu information from ReservedF1apPduList
 683 *
 684 * @params[in] CmLList *node
 685 *
 686 * @return void
 687 *
 688 * ****************************************************************/
 689
 690 void deleteFromReservedF1apPduList(CmLList *node)
 691 {
 692    ReservedF1apPduInfo *f1apPdu;
 693
 694    if(node != NULL)
 695    {
 696       f1apPdu = (ReservedF1apPduInfo *)node->node;
 697       cmLListDelFrm(&duCb.reservedF1apPduList, node);
 698       DU_FREE(f1apPdu, sizeof(ReservedF1apPduInfo));
 699       DU_FREE(node, sizeof(CmLList));
 700       node = NULL;
 701    }
 702 }
 703
 704 /*******************************************************************
 705  *
 706  * @brief Builds Uplink Info for NR
 707  *
 708  * @details
 709  *
 710  *    Function : BuildULNRInfo
 711  *
 712  *    Functionality: Building NR Uplink Info
 713  *
 714  * @params[in] NRFreqInfo_t *ulnrfreq
 715  * @return ROK     - success
 716  *         RFAILED - failure
 717  *
 718  * ****************************************************************/
 719 uint8_t BuildULNRInfo(NRFreqInfo_t *ulnrfreq)
 720 {
 721    uint8_t idx=0;
 722    ulnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 723                        fdd.ulNrFreqInfo.nrArfcn;
 724    ulnrfreq->freqBandListNr.list.count = 1;
 725    ulnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 726    DU_ALLOC(ulnrfreq->freqBandListNr.list.array,ulnrfreq->freqBandListNr.list.size);
 727    if(ulnrfreq->freqBandListNr.list.array == NULLP)
 728    {
 729       return RFAILED;
 730    }
 731    for(idx=0;idx<ulnrfreq->freqBandListNr.list.count;idx++)
 732    {
 733       DU_ALLOC(ulnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 734       if(ulnrfreq->freqBandListNr.list.array[idx] == NULLP)
 735       {
 736          return RFAILED;
 737       }
 738    }
 739    ulnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 740                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
 741                                                                  freqBand[0].nrFreqBand;
 742    ulnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 743    return ROK;
 744 }
 745 /*******************************************************************
 746  *
 747  * @brief Builds Downlink NR Info
 748  *
 749  * @details
 750  *
 751  *    Function : BuildDLNRInfo
 752  *
 753  *    Functionality: Building Downlink NR Info
 754  *
 755  * @params[in] NRFreqInfo_t *dlnrfreq
 756  * @return ROK     - success
 757  *         RFAILED - failure
 758  *
 759  * ****************************************************************/
 760 uint8_t BuildDLNRInfo(NRFreqInfo_t *dlnrfreq)
 761 {
 762    uint8_t idx=0;
 763    dlnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 764                        fdd.dlNrFreqInfo.nrArfcn;
 765    dlnrfreq->freqBandListNr.list.count = 1;
 766    dlnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 767    DU_ALLOC(dlnrfreq->freqBandListNr.list.array,dlnrfreq->freqBandListNr.list.size);
 768    if(dlnrfreq->freqBandListNr.list.array == NULLP)
 769    {
 770       return RFAILED;
 771    }
 772    for(idx=0;idx< dlnrfreq->freqBandListNr.list.count;idx++)
 773    {
 774       DU_ALLOC(dlnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 775       if(dlnrfreq->freqBandListNr.list.array[idx] == NULLP)
 776       {
 777          return RFAILED;
 778       }
 779    }
 780    dlnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 781                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
 782                                                                  freqBand[0].nrFreqBand;
 783    dlnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 784
 785    return ROK;
 786 }
 787
 788 /*******************************************************************
 789  *
 790  * @brief Builds NRCell ID
 791  *
 792  * @details
 793  *
 794  *    Function : BuildNrCellId
 795  *
 796  *    Functionality: Building the NR Cell ID
 797  *
 798  * @params[in] BIT_STRING_t *nrcell
 799  * @return ROK     - success
 800  *         RFAILED - failure
 801  *
 802  * ****************************************************************/
 803
 804 S16 BuildNrCellId(BIT_STRING_t *nrcell)
 805 {
 806    memset(nrcell->buf, 0, nrcell->size);
 807    nrcell->buf[4]   = 16;
 808    nrcell->bits_unused = 4;
 809    return ROK;
 810 }
 811
 812 /*******************************************************************
 813  *
 814  * @brief Builds Nrcgi
 815  *
 816  * @details
 817  *
 818  *    Function : BuildNrcgi
 819  *
 820  *    Functionality: Building the PLMN ID and NR Cell id
 821  *
 822  * @params[in] NRCGI_t *nrcgi
 823  * @return ROK     - success
 824  *         RFAILED - failure
 825  *
 826  * ****************************************************************/
 827 uint8_t BuildNrcgi(NRCGI_t *nrcgi)
 828 {
 829    uint8_t ret;
 830    uint8_t byteSize = 5;
 831    /* Allocate Buffer Memory */
 832    nrcgi->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 833    DU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
 834    if(nrcgi->pLMN_Identity.buf == NULLP)
 835    {
 836       return RFAILED;
 837    }
 838    ret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 839          nrcgi->pLMN_Identity.buf); // Building PLMN function
 840    if(ret != ROK)
 841    {
 842       return RFAILED;
 843    }
 844    /*nrCellIdentity*/
 845    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
 846    DU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
 847    if(nrcgi->nRCellIdentity.buf == NULLP)
 848    {
 849       return RFAILED;
 850    }
 851    BuildNrCellId(&nrcgi->nRCellIdentity);
 852
 853    return ROK;
 854 }
 855 /*******************************************************************
 856  *
 857  * @brief Builds FiveGStac
 858  *
 859  * @details
 860  *
 861  *    Function : BuildFiveGSTac
 862  *
 863  *    Functionality: Building the FiveGSTac
 864  *
 865  * @params[in] OCTET_STRING_t *fivegsTac
 866  * @return ROK     - success
 867  *         RFAILED - failure
 868  *
 869  * ****************************************************************/
 870 uint8_t BuildFiveGSTac(Served_Cell_Information_t *servcell)
 871 {
 872    DU_ALLOC(servcell->fiveGS_TAC,sizeof(FiveGS_TAC_t));
 873    if(servcell->fiveGS_TAC == NULLP)
 874    {
 875       return RFAILED;
 876    }
 877    servcell->fiveGS_TAC->size = 3 * sizeof(uint8_t);
 878    DU_ALLOC(servcell->fiveGS_TAC->buf,\
 879          sizeof(servcell->fiveGS_TAC->size));
 880    if(servcell->fiveGS_TAC->buf == NULLP)
 881    {
 882       return RFAILED;
 883    }
 884    servcell->fiveGS_TAC->buf[0] = 0;
 885    servcell->fiveGS_TAC->buf[1] = 0;
 886    servcell->fiveGS_TAC->buf[2] = duCfgParam.srvdCellLst[0].duCellInfo.tac;
 887    return ROK;
 888 }
 889 /*******************************************************************
 890  *
 891  * @brief Builds NR Mode
 892  *
 893  * @details
 894  *
 895  *    Function : BuildNrMode
 896  *
 897  *    Functionality: Building the NR Mode
 898  *
 899  * @params[in] NR_Mode_Info_t *fdd
 900  * @return ROK     - success
 901  *         RFAILED - failure
 902  *
 903  * ****************************************************************/
 904 uint8_t BuildNrMode(NR_Mode_Info_t *mode)
 905 {
 906    uint8_t BuildDLNRInforet=0;
 907    uint8_t BuildULNRInforet=0;
 908    /* FDD Mode */
 909    mode->present = NR_Mode_Info_PR_fDD;
 910    if(mode->present == NR_Mode_Info_PR_fDD)
 911    {
 912       DU_ALLOC(mode->choice.fDD,sizeof(FDD_Info_t));
 913       if(mode->choice.fDD == NULLP)
 914       {
 915          return RFAILED;
 916       }
 917       BuildULNRInforet = BuildULNRInfo(&mode->choice.fDD->uL_NRFreqInfo);
 918       if(BuildULNRInforet != ROK)
 919       {
 920          return RFAILED;
 921       }
 922       BuildDLNRInforet = BuildDLNRInfo(&mode->choice.fDD->dL_NRFreqInfo);
 923       if(BuildDLNRInforet != ROK)
 924       {
 925          return RFAILED;
 926       }
 927    }
 928    mode->choice.fDD->uL_Transmission_Bandwidth.nRSCS = \
 929                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 930                                                        f1Mode.mode.fdd.ulTxBw.nrScs;
 931    mode->choice.fDD->uL_Transmission_Bandwidth.nRNRB = \
 932                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 933                                                        f1Mode.mode.fdd.ulTxBw.nrb;
 934    mode->choice.fDD->dL_Transmission_Bandwidth.nRSCS = \
 935                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 936                                                        f1Mode.mode.fdd.dlTxBw.nrScs;
 937    mode->choice.fDD->dL_Transmission_Bandwidth.nRNRB = \
 938                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 939                                                        f1Mode.mode.fdd.dlTxBw.nrb;
 940    return ROK;
 941 }
 942 /*******************************************************************
 943  *
 944  * @brief Builds IE Extensions for Served PLMNs
 945  *
 946  * @details
 947  *
 948  *    Function : BuildExtensions
 949  *
 950  *    Functionality: Building the IE Extensions
 951  *
 952  * @params[in] struct ProtocolExtensionContainer_4624P3 *buildextend
 953  * @return ROK     - success
 954  *         RFAILED - failure
 955  *
 956  * ****************************************************************/
 957 uint8_t BuildExtensions(ProtocolExtensionContainer_4624P3_t **ieExtend)
 958 {
 959    uint8_t idx=0, plmnidx=0, sliceLstIdx=0;
 960    uint8_t elementCnt=0, extensionCnt=0;
 961
 962    extensionCnt=IE_EXTENSION_LIST_COUNT;
 963    DU_ALLOC(*ieExtend,sizeof(ProtocolExtensionContainer_4624P3_t));
 964    if((*ieExtend) == NULLP)
 965    {
 966       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 967       return RFAILED;
 968    }
 969    (*ieExtend)->list.count = extensionCnt;
 970    (*ieExtend)->list.size = \
 971                             extensionCnt * sizeof(ServedPLMNs_ItemExtIEs_t *);
 972    DU_ALLOC((*ieExtend)->list.array,(*ieExtend)->list.size);
 973    if((*ieExtend)->list.array == NULLP)
 974    {
 975       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 976       return RFAILED;
 977    }
 978    for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
 979    {
 980       DU_ALLOC((*ieExtend)->list.array[plmnidx],\
 981             sizeof(ServedPLMNs_ItemExtIEs_t));
 982       if((*ieExtend)->list.array[plmnidx] == NULLP)
 983       {
 984          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 985          return RFAILED;
 986       }
 987    }
 988
 989    elementCnt = NUM_OF_SUPPORTED_SLICE;
 990    idx = 0;
 991    (*ieExtend)->list.array[idx]->id = ProtocolIE_ID_id_TAISliceSupportList;
 992    (*ieExtend)->list.array[idx]->criticality = Criticality_ignore;
 993    (*ieExtend)->list.array[idx]->extensionValue.present = \
 994    ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
 995    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 996       list.count = elementCnt;
 997    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 998       list.size = (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 999       list.count * sizeof(SliceSupportItem_t *);
1000
1001    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1002          list.array, elementCnt * sizeof(SliceSupportItem_t *));
1003    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1004          list.array == NULLP)
1005    {
1006       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1007       return RFAILED;
1008    }
1009
1010    for(sliceLstIdx =0; sliceLstIdx<elementCnt; sliceLstIdx++)
1011    {
1012       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1013             list.array[sliceLstIdx],sizeof(SliceSupportItem_t));
1014       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1015             list.array[sliceLstIdx] == NULLP)
1016       {
1017          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1018          return RFAILED;
1019       }
1020       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1021          list.array[sliceLstIdx]->sNSSAI.sST.size = sizeof(uint8_t);
1022       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
1023             .list.array[sliceLstIdx]->sNSSAI.sST.buf,(*ieExtend)->list.array[idx]->\
1024             extensionValue.choice.SliceSupportList.\
1025             list.array[sliceLstIdx]->sNSSAI.sST.size);
1026       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
1027             .list.array[sliceLstIdx]->sNSSAI.sST.buf == NULLP)
1028       {
1029          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1030          return RFAILED;
1031       }
1032       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1033          list.array[sliceLstIdx]->sNSSAI.sST.buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.\
1034          cellInfo.srvdPlmn[0].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
1035
1036       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1037             list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1038       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1039             list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
1040       {
1041          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1042          return RFAILED;
1043       }
1044       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1045          list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
1046       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1047             list.array[sliceLstIdx]->sNSSAI.sD->buf, (*ieExtend)->list.array[idx]->extensionValue.choice.\
1048             SliceSupportList.list.array[sliceLstIdx]->sNSSAI.sD->size);
1049       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1050             list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
1051       {
1052          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1053          return RFAILED;
1054       }
1055       memcpy((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1056       list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[0].duCellInfo.\
1057       cellInfo.srvdPlmn[0].taiSliceSuppLst.snssai[sliceLstIdx]->sd, (*ieExtend)->list.array[idx]->\
1058       extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->sNSSAI.sD->size);
1059    }
1060    return ROK;
1061 }
1062 /*******************************************************************
1063  *
1064  * @brief Builds Served PLMN
1065  *
1066  * @details
1067  *
1068  *    Function : BuildServedPlmn
1069  *
1070  *    Functionality: Building the Served PLMN
1071  *
1072  * @params[in] GNB_DU_Served_Cells_Item_t *srvCellItem
1073  * @return ROK     - success
1074  *         RFAILED - failure
1075  *
1076  * ****************************************************************/
1077 uint8_t  BuildServedPlmn(ServedPLMNs_List_t *srvplmn)
1078 {
1079    uint8_t  plmnidx;
1080    uint8_t  servPlmnCnt=1;
1081    uint8_t buildPlmnIdret=0;
1082    uint8_t BuildExtensionsret=0;
1083    srvplmn->list.count = servPlmnCnt;
1084    srvplmn->list.size = \
1085                         servPlmnCnt*sizeof(ServedPLMNs_Item_t *);
1086    DU_ALLOC(srvplmn->list.array,srvplmn->list.size);
1087    if(srvplmn->list.array == NULLP)
1088    {
1089       return RFAILED;
1090    }
1091    for(plmnidx=0; plmnidx<servPlmnCnt; plmnidx++)
1092    {
1093       DU_ALLOC(srvplmn->list.array[plmnidx],\
1094             sizeof(ServedPLMNs_Item_t));
1095       if(srvplmn->list.array[plmnidx] == NULLP)
1096       {
1097          return RFAILED;
1098       }
1099    }
1100    srvplmn->list.array[0]->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
1101    DU_ALLOC(srvplmn->list.array[0]->pLMN_Identity.buf, srvplmn->list.array[0]->pLMN_Identity.size);
1102    buildPlmnIdret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
1103          srvplmn->list.array[0]->pLMN_Identity.buf);
1104    if(buildPlmnIdret!= ROK)
1105    {
1106       return RFAILED;
1107    }
1108    BuildExtensionsret = BuildExtensions(&srvplmn->list.array[0]->iE_Extensions);
1109    if(BuildExtensionsret!= ROK)
1110    {
1111       return RFAILED;
1112    }
1113    return ROK;
1114 }
1115 /*******************************************************************
1116  *
1117  * @brief Builds Served Cell List
1118  *
1119  * @details
1120  *
1121  *    Function : BuildServedCellList
1122  *
1123  *    Functionality: Building Served Cell List
1124  *
1125  * @params[in] PLMNID plmn
1126  * @return ROK     - success
1127  *         RFAILED - failure
1128  *
1129  * ****************************************************************/
1130
1131 uint8_t BuildServedCellList(GNB_DU_Served_Cells_List_t *duServedCell)
1132 {
1133    uint8_t  BuildNrcgiret=0;
1134    uint8_t  BuildFiveGSTacret=0;
1135    uint8_t  BuildServedPlmnret=0;
1136    uint8_t  BuildNrModeret=0;
1137    uint8_t  idx;
1138    uint8_t  plmnidx;
1139    uint8_t  plmnCnt=1;
1140    GNB_DU_Served_Cells_Item_t *srvCellItem;
1141    duServedCell->list.size = plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t *);
1142    duServedCell->list.count = plmnCnt;
1143
1144    DU_ALLOC(duServedCell->list.array, duServedCell->list.size);
1145    if(duServedCell->list.array == NULLP)
1146    {
1147       return RFAILED;
1148    }
1149    for(plmnidx=0; plmnidx<plmnCnt; plmnidx++)
1150    {
1151       DU_ALLOC(duServedCell->list.array[plmnidx],\
1152             sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1153       if(duServedCell->list.array[plmnidx] == NULLP)
1154       {
1155          return RFAILED;
1156       }
1157    }
1158    idx = 0;
1159    duServedCell->list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_Served_Cells_Item;
1160    duServedCell->list.array[idx]->criticality = Criticality_reject;
1161    duServedCell->list.array[idx]->value.present = \
1162                                                   GNB_DU_Served_Cells_ItemIEs__value_PR_GNB_DU_Served_Cells_Item;
1163    srvCellItem = \
1164                  &duServedCell->list.array[idx]->value.choice.GNB_DU_Served_Cells_Item;
1165    /*nRCGI*/
1166    BuildNrcgiret = BuildNrcgi(&srvCellItem->served_Cell_Information.nRCGI);
1167    if(BuildNrcgiret != ROK)
1168    {
1169       return RFAILED;
1170    }
1171    /*nRPCI*/
1172    srvCellItem->served_Cell_Information.nRPCI = \
1173                                                 duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
1174
1175    /*fiveGS_TAC*/
1176    BuildFiveGSTacret = BuildFiveGSTac(&srvCellItem->served_Cell_Information);
1177    if(BuildFiveGSTacret != ROK)
1178    {
1179       return RFAILED;
1180    }
1181    /*Served PLMNs*/
1182    BuildServedPlmnret = BuildServedPlmn(&srvCellItem->served_Cell_Information.servedPLMNs);
1183    if(BuildServedPlmnret !=ROK)
1184    {
1185       return RFAILED;
1186    }
1187    /*nR Mode Info with FDD*/
1188    BuildNrModeret = BuildNrMode(&srvCellItem->served_Cell_Information.nR_Mode_Info);
1189    if(BuildNrModeret != ROK)
1190    {
1191       return RFAILED;
1192    }
1193    /*Measurement timing Config*/
1194    srvCellItem->served_Cell_Information.measurementTimingConfiguration.\
1195       size = sizeof(uint8_t);
1196    DU_ALLOC(srvCellItem->served_Cell_Information.\
1197          measurementTimingConfiguration.buf,srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1198    if(srvCellItem->served_Cell_Information.\
1199          measurementTimingConfiguration.buf == NULLP)
1200    {
1201       return RFAILED;
1202    }
1203    srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf[0] = \
1204                                                                                 duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
1205
1206    /* GNB DU System Information */
1207    DU_ALLOC(srvCellItem->gNB_DU_System_Information,
1208          sizeof(GNB_DU_System_Information_t));
1209    if(!srvCellItem->gNB_DU_System_Information)
1210    {
1211       return RFAILED;
1212    }
1213    /* MIB */
1214    srvCellItem->gNB_DU_System_Information->mIB_message.size = duCfgParam.srvdCellLst[0].duSysInfo.mibLen;
1215    DU_ALLOC(srvCellItem->gNB_DU_System_Information->mIB_message.buf,
1216          srvCellItem->gNB_DU_System_Information->mIB_message.size);
1217    if(!srvCellItem->gNB_DU_System_Information->mIB_message.buf)
1218    {
1219       return RFAILED;
1220    }
1221    memcpy(srvCellItem->gNB_DU_System_Information->mIB_message.buf, duCfgParam.srvdCellLst[0].duSysInfo.mibMsg, \
1222                    srvCellItem->gNB_DU_System_Information->mIB_message.size);
1223
1224    /* SIB1 */
1225    srvCellItem->gNB_DU_System_Information->sIB1_message.size =\
1226                                                               duCfgParam.srvdCellLst[0].duSysInfo.sib1Len;
1227
1228    DU_ALLOC(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,
1229          srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1230    if(!srvCellItem->gNB_DU_System_Information->sIB1_message.buf)
1231    {
1232       return RFAILED;
1233    }
1234    for(int x=0; x<srvCellItem->gNB_DU_System_Information->sIB1_message.size; x++)
1235    {
1236       srvCellItem->gNB_DU_System_Information->sIB1_message.buf[x]=\
1237                                                                   duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg[x];
1238    }
1239    return ROK;
1240 }
1241 /*******************************************************************
1242  *
1243  * @brief Builds RRC Version
1244  *
1245  * @details
1246  *
1247  *    Function : BuildRrcVer
1248  *
1249  *    Functionality: Building RRC Version
1250  *
1251  * @params[in] int idx,int elementCnt,RRC_Version_t *rrcver
1252  * @return ROK     - success
1253  *         RFAILED - failure
1254  *
1255  * ****************************************************************/
1256 uint8_t BuildRrcVer(RRC_Version_t *rrcVer)
1257 {
1258    uint8_t rrcExt;
1259    uint8_t rrcLatest;
1260    rrcVer->latest_RRC_Version.size = sizeof(uint8_t);
1261    DU_ALLOC(rrcVer->latest_RRC_Version.buf,sizeof(uint8_t));
1262    if(rrcVer->latest_RRC_Version.buf == NULLP)
1263    {
1264       return RFAILED;
1265    }
1266    rrcVer->latest_RRC_Version.buf[0] = 0;
1267    rrcVer->latest_RRC_Version.bits_unused = 5;
1268    DU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1269    if(rrcVer->iE_Extensions == NULLP)
1270    {
1271       return RFAILED;
1272    }
1273    rrcVer->iE_Extensions->list.count = 1;
1274    rrcVer->iE_Extensions->list.size = sizeof(RRC_Version_ExtIEs_t *);
1275    DU_ALLOC(rrcVer->iE_Extensions->list.array,rrcVer->iE_Extensions->list.size);
1276    if(rrcVer->iE_Extensions->list.array == NULLP)
1277    {
1278       return RFAILED;
1279    }
1280    rrcExt = 0;
1281    DU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
1282          sizeof(RRC_Version_ExtIEs_t));
1283    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
1284    {
1285       return RFAILED;
1286    }
1287    rrcVer->iE_Extensions->list.array[rrcExt]->id = \
1288                                                    ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
1289    rrcVer->iE_Extensions->list.array[rrcExt]->criticality = Criticality_reject;
1290    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.present =\
1291                                                                       RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
1292    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1293       .Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
1294    DU_ALLOC(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1295          .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1296          array[rrcExt]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1297    if(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1298          .Latest_RRC_Version_Enhanced.buf == NULLP)
1299    {
1300       return RFAILED;
1301    }
1302    rrcLatest = 0;
1303    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1304       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 15;
1305    rrcLatest++;
1306    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1307       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 5;
1308    rrcLatest++;
1309    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1310       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 0;
1311    return ROK;
1312 }
1313 /*******************************************************************
1314  *
1315  * @brief Sends F1 msg over SCTP
1316  *
1317  * @details
1318  *
1319  *    Function : sendF1APMsg
1320  *
1321  *    Functionality: Sends F1 msg over SCTP
1322  *
1323  * @params[in] Region region
1324  *             Pool pool
1325  * @return ROK     - success
1326  *         RFAILED - failure
1327  *
1328  * ****************************************************************/
1329 uint8_t sendF1APMsg()
1330 {
1331    Buffer *mBuf = NULLP;
1332
1333    if(ODU_GET_MSG_BUF(DU_APP_MEM_REGION, DU_POOL, &mBuf) == ROK)
1334    {
1335       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
1336       {
1337             ODU_PRINT_MSG(mBuf, 0,0);
1338
1339             if(sctpSend(mBuf, F1_INTERFACE) != ROK)
1340             {
1341                DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
1342                ODU_PUT_MSG_BUF(mBuf);
1343                return RFAILED;
1344             }
1345       }
1346       else
1347       {
1348          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
1349          ODU_PUT_MSG_BUF(mBuf);
1350          return RFAILED;
1351       }
1352       ODU_PUT_MSG_BUF(mBuf);
1353    }
1354    else
1355    {
1356       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
1357       return RFAILED;
1358    }
1359    return ROK;
1360 } /* sendF1APMsg */
1361
1362 /*******************************************************************
1363  *
1364  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1365  *
1366  * @details
1367  *
1368  *    Function :  FreeRrcVer
1369  *
1370  *    Functionality: deallocating the memory of function BuildRrcVer
1371  *
1372  * @params[in] RRC_Version_t *rrcVer
1373  *
1374  * @return void
1375  *
1376  *****************************************************************/
1377 void FreeRrcVer(RRC_Version_t *rrcVer)
1378 {
1379    if(rrcVer->latest_RRC_Version.buf != NULLP)
1380    {
1381       if(rrcVer->iE_Extensions != NULLP)
1382       {
1383          if(rrcVer->iE_Extensions->list.array != NULLP)
1384          {
1385             if(rrcVer->iE_Extensions->list.array[0] != NULLP)
1386             {
1387                if(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf
1388                      != NULLP)
1389                {
1390                   DU_FREE(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice\
1391                         .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1392                         array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1393                }
1394                DU_FREE(rrcVer->iE_Extensions->list.array[0],sizeof(RRC_Version_ExtIEs_t));
1395             }
1396             DU_FREE(rrcVer->iE_Extensions->list.array,sizeof(RRC_Version_ExtIEs_t*));
1397          }
1398          DU_FREE(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1399       }
1400       DU_FREE(rrcVer->latest_RRC_Version.buf,rrcVer->latest_RRC_Version.size);
1401    }
1402 }
1403 /*******************************************************************
1404  *
1405  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1406  *
1407  * @details
1408  *
1409  *    Function :  FreeServedCellList
1410  *
1411  *    Functionality:  deallocating the memory of function BuildServedCellList
1412
1413  *
1414  * @params[in] GNB_DU_Served_Cells_List_t *duServedCell
1415  *
1416  * @return void
1417  *
1418  * ****************************************************************/
1419 void FreeServedCellList( GNB_DU_Served_Cells_List_t *duServedCell)
1420 {
1421    uint8_t   plmnCnt=MAX_PLMN;
1422    uint8_t  extensionCnt=IE_EXTENSION_LIST_COUNT;
1423    uint8_t  plmnIdx=0, sliceIdx=0;
1424    GNB_DU_Served_Cells_Item_t *srvCellItem;
1425    ServedPLMNs_Item_t  *servedPlmnItem;
1426    SliceSupportItem_t  *sliceSupportItem;
1427
1428    if(duServedCell->list.array!=NULLP)
1429    {
1430       if(duServedCell->list.array[0]!=NULLP)
1431       {
1432          srvCellItem= &duServedCell->list.array[0]->value.choice.GNB_DU_Served_Cells_Item;
1433
1434          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1435                srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size * sizeof(uint8_t));
1436          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1437                srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size * sizeof(uint8_t));
1438
1439          if(srvCellItem->served_Cell_Information.fiveGS_TAC!=NULLP)
1440          {
1441             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
1442                   sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
1443             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,sizeof(FiveGS_TAC_t));
1444          }
1445
1446          if(srvCellItem->served_Cell_Information.servedPLMNs.list.array!=NULLP)
1447          {
1448             if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx] != NULLP)
1449             {
1450                servedPlmnItem = srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx];
1451                DU_FREE(servedPlmnItem->pLMN_Identity.buf, servedPlmnItem->pLMN_Identity.size);
1452
1453                if(servedPlmnItem->iE_Extensions != NULLP)
1454                {
1455                   if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1456                   {
1457                      if(servedPlmnItem->iE_Extensions->list.array[0] != NULLP)
1458                      {
1459                         if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1460                         SliceSupportList.list.array != NULLP)
1461                         {
1462                            for(sliceIdx =0; sliceIdx<servedPlmnItem->iE_Extensions->list.array[0]->\
1463                            extensionValue.choice.SliceSupportList.list.count; sliceIdx++)
1464                            {
1465                               if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1466                               SliceSupportList.list.array[sliceIdx] != NULLP)
1467                               {
1468                                  sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[0]->\
1469                                  extensionValue.choice.SliceSupportList.list.array[sliceIdx];
1470
1471                                  DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sizeof(uint8_t));
1472
1473                                  if(sliceSupportItem->sNSSAI.sD != NULLP)
1474                                  {
1475                                     DU_FREE(sliceSupportItem->sNSSAI.sD->buf,\
1476                                     sliceSupportItem->sNSSAI.sD->size);
1477                                     DU_FREE(sliceSupportItem->sNSSAI.sD, sizeof(OCTET_STRING_t));
1478                                  }
1479
1480                                  DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.\
1481                                  choice.SliceSupportList.list.array[sliceIdx], sizeof(SliceSupportItem_t));
1482                               }
1483                            }
1484                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1485                            SliceSupportList.list.array, sizeof(SliceSupportItem_t*));
1486                         }
1487                         DU_FREE(servedPlmnItem->iE_Extensions->list.array[0],\
1488                         sizeof(ServedPLMNs_ItemExtIEs_t));
1489                      }
1490                      DU_FREE(servedPlmnItem->iE_Extensions->list.array,\
1491                      extensionCnt*sizeof(ServedPLMNs_ItemExtIEs_t*));
1492                   }
1493                   DU_FREE(servedPlmnItem->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P3_t));
1494                }
1495                DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx],\
1496                sizeof(ServedPLMNs_Item_t));
1497             }
1498             DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array,\
1499             sizeof(ServedPLMNs_Item_t *));
1500          }
1501
1502          if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD != NULLP)
1503          {
1504             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
1505                   freqBandListNr.list.array != NULLP)
1506             {
1507                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
1508                uL_NRFreqInfo.freqBandListNr.list.array[0],sizeof(FreqBandNrItem_t));
1509                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
1510                uL_NRFreqInfo.freqBandListNr.list.array,sizeof(FreqBandNrItem_t*));
1511             }
1512
1513             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1514                   freqBandListNr.list.array)
1515             {
1516                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1517                      freqBandListNr.list.array[0],sizeof(FreqBandNrItem_t));
1518                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1519                      freqBandListNr.list.array,sizeof(FreqBandNrItem_t *));
1520             }
1521             DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD, sizeof(FDD_Info_t));
1522          }
1523
1524          DU_FREE(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1525                srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1526
1527          if(srvCellItem->gNB_DU_System_Information != NULLP)
1528          {
1529             if(srvCellItem->gNB_DU_System_Information->mIB_message.buf != NULLP)
1530             {
1531                DU_FREE(srvCellItem->gNB_DU_System_Information->mIB_message.buf,\
1532                      srvCellItem->gNB_DU_System_Information->mIB_message.size);
1533             }
1534
1535             if(srvCellItem->gNB_DU_System_Information->sIB1_message.buf != NULLP)
1536             {
1537                DU_FREE(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,\
1538                      srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1539             }
1540
1541             DU_FREE(srvCellItem->gNB_DU_System_Information, sizeof(GNB_DU_System_Information_t));
1542          }
1543
1544          DU_FREE(duServedCell->list.array[0], sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1545       }
1546       DU_FREE(duServedCell->list.array, plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t*));
1547    }
1548 }
1549
1550 /*******************************************************************
1551  *
1552  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1553  *
1554  * @details
1555  *
1556  *    Function :  FreeF1SetupReq
1557  *
1558  *    Functionality:  deallocating the memory of function BuildAndSendF1SetupReq
1559  *
1560  * @params[in] F1AP_PDU_t *f1apMsg
1561  *
1562  * @return void
1563  *
1564  * ****************************************************************/
1565 void FreeF1SetupReq(F1AP_PDU_t *f1apMsg)
1566 {
1567    uint8_t ieIdx, ieIdx2;
1568    F1SetupRequest_t *f1SetupReq=NULLP;
1569
1570    if(f1apMsg != NULLP)
1571    {
1572       if(f1apMsg->choice.initiatingMessage != NULLP)
1573       {
1574          f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1575          if(f1SetupReq->protocolIEs.list.array != NULLP)
1576          {
1577             for(ieIdx = 0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
1578             {
1579                if(f1SetupReq->protocolIEs.list.array[ieIdx] != NULLP)
1580                {
1581                   switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
1582                   {
1583                      case ProtocolIE_ID_id_TransactionID:
1584                         break;
1585                      case ProtocolIE_ID_id_gNB_DU_ID:
1586                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1587                               f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1588                         break;
1589                      case ProtocolIE_ID_id_gNB_DU_Name:
1590                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,\
1591                               strlen((char *)duCfgParam.duName));
1592                         break;
1593                      case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
1594                         FreeServedCellList(&f1SetupReq->protocolIEs.list.\
1595                               array[ieIdx]->value.choice.GNB_DU_Served_Cells_List);
1596                         break;
1597                      case ProtocolIE_ID_id_GNB_DU_RRC_Version:
1598                         FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version);
1599                         break;
1600                      default:
1601                         DU_LOG("\nERROR  -->  Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id);
1602                         break;
1603                   }
1604                }
1605             }
1606             for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++)
1607             {
1608                DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx2],sizeof(F1SetupRequestIEs_t));
1609             }
1610             DU_FREE(f1SetupReq->protocolIEs.list.array,\
1611                   f1SetupReq->protocolIEs.list.size);
1612          }
1613          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1614       }
1615       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1616    }
1617 }
1618 /*******************************************************************
1619  *
1620  * @brief Builds and Send the F1SetupRequest
1621  *
1622  * @details
1623  *
1624  *    Function : BuildAndSendF1SetupReq
1625  *
1626  * Functionality:Fills the F1SetupRequest
1627  *
1628  * @return ROK     - success
1629  *         RFAILED - failure
1630  *
1631  ******************************************************************/
1632 uint8_t BuildAndSendF1SetupReq()
1633 {
1634    uint8_t   ret, ieIdx, elementCnt;
1635    F1AP_PDU_t                 *f1apMsg = NULLP;
1636    F1SetupRequest_t           *f1SetupReq=NULLP;
1637    GNB_DU_Served_Cells_List_t *duServedCell=NULLP;
1638    RRC_Version_t              *rrcVer=NULLP;
1639    asn_enc_rval_t             encRetVal;        /* Encoder return value */
1640    ret= RFAILED;
1641
1642    DU_LOG("\nINFO   -->  F1AP : Building F1 Setup Request\n");
1643    do
1644    {
1645       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1646       if(f1apMsg == NULLP)
1647       {
1648          break;
1649       }
1650       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1651       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1652       if(f1apMsg->choice.initiatingMessage == NULLP)
1653       {
1654          break;
1655       }
1656       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_F1Setup;
1657       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
1658       f1apMsg->choice.initiatingMessage->value.present = \
1659                                                          InitiatingMessage__value_PR_F1SetupRequest;
1660
1661       f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1662
1663       elementCnt = (duCfgParam.duName != NULL) ? 5 : 4;
1664
1665       f1SetupReq->protocolIEs.list.count = elementCnt;
1666       f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t );
1667
1668       /* Initialize the F1Setup members */
1669       DU_ALLOC(f1SetupReq->protocolIEs.list.array,f1SetupReq->protocolIEs.list.size);
1670       if(f1SetupReq->protocolIEs.list.array == NULLP)
1671       {
1672          break;
1673       }
1674       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
1675       {
1676          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx],\
1677                sizeof(F1SetupRequestIEs_t));
1678          if(f1SetupReq->protocolIEs.list.array[ieIdx] == NULLP)
1679          {
1680             break;
1681          }
1682       }
1683
1684       ieIdx = 0;
1685       /*TransactionID*/
1686       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransactionID;
1687       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1688       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present =\
1689                                                                F1SetupRequestIEs__value_PR_TransactionID;
1690       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = \
1691                                                                              TRANS_ID;
1692
1693       /*DU ID*/
1694       ieIdx++;
1695       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
1696       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1697       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1698                                                                 F1SetupRequestIEs__value_PR_GNB_DU_ID;
1699       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size =\
1700                                                                              sizeof(uint8_t);
1701
1702       DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1703             f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1704       if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == \
1705             NULLP)
1706       {
1707          break;
1708       }
1709
1710       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] =\
1711          duCfgParam.duId;
1712
1713       /*DU Name*/
1714       if(duCfgParam.duName != NULL)
1715       {
1716          ieIdx++;
1717          f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_Name;
1718          f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
1719          f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = F1SetupRequestIEs__value_PR_GNB_DU_Name;
1720          f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.size =\
1721             strlen((char *)duCfgParam.duName);
1722          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.\
1723                GNB_DU_Name.buf, strlen((char *)duCfgParam.duName));
1724          if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.\
1725                buf == NULLP)
1726          {
1727             break;
1728          }
1729          strcpy((char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.\
1730                choice.GNB_DU_Name.buf,
1731                (char*)&duCfgParam.duName);
1732
1733       }
1734
1735       /*Served Cell list */
1736       ieIdx++;
1737       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1738                                                      ProtocolIE_ID_id_gNB_DU_Served_Cells_List;
1739       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1740       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1741                                                                 F1SetupRequestIEs__value_PR_GNB_DU_Served_Cells_List;
1742       duServedCell = &f1SetupReq->protocolIEs.list.\
1743                      array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
1744       if(BuildServedCellList(duServedCell))
1745       {
1746          break;
1747       }
1748       /*RRC Version*/
1749       ieIdx++;
1750       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1751                                                      ProtocolIE_ID_id_GNB_DU_RRC_Version ;
1752       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1753       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1754                                                                 F1SetupRequestIEs__value_PR_RRC_Version;
1755       rrcVer = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
1756       if(BuildRrcVer(rrcVer))
1757       {
1758          break;
1759       }
1760       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1761
1762       /* Encode the F1SetupRequest type as APER */
1763       memset(encBuf, 0, ENC_BUF_MAX_LEN);
1764       encBufSize = 0;
1765       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1766             encBuf);
1767
1768       /* Encode results */
1769       if(encRetVal.encoded == ENCODE_FAIL)
1770       {
1771          DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupRequest structure (at %s)\n",\
1772                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1773          break;
1774       }
1775       else
1776       {
1777          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1SetupRequest\n");
1778          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
1779          {
1780             printf("%x",encBuf[ieIdx]);
1781          }
1782       }
1783
1784       /* Sending msg */
1785       if(sendF1APMsg() != ROK)
1786       {
1787          DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup request failed");
1788          break;
1789       }
1790
1791       ret=ROK;
1792       break;
1793    }while(true);
1794
1795    FreeF1SetupReq(f1apMsg);
1796
1797    return ret;
1798 }/* End of BuildAndSendF1SetupReq */
1799
1800 /*******************************************************************
1801  *
1802  * @brief Deallocating memory allocated for Served_Cells_To_Modify_Item_t
1803  *
1804  * @details
1805  *
1806  *    Function : freeCellsToModifyItem
1807  *
1808  *    Functionality: Deallocating memory of variables allocated in
1809  *                    BuildAndSendDUConfigUpdate function
1810  *
1811  * @params[in]  Served_Cells_To_Modify_Item_t *modifyItem
1812  *
1813  * @return ROK     - void
1814  *
1815  * ****************************************************************/
1816
1817 void freeCellsToModifyItem(Served_Cells_To_Modify_Item_t *modifyItem)
1818 {
1819    uint8_t arrIdx=0, servedPlmnIdx=0, sliceLstIdx=0;
1820    ServedPLMNs_Item_t *servedPlmnItem = NULLP;
1821    SliceSupportItem_t *sliceSupportItem = NULLP;
1822
1823    DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf, modifyItem->oldNRCGI.pLMN_Identity.size);
1824    DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf, modifyItem->oldNRCGI.nRCellIdentity.size);
1825
1826    DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1827            modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
1828    DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1829          modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
1830
1831    if(modifyItem->served_Cell_Information.servedPLMNs.list.array != NULLP)
1832    {
1833       if(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx] != NULLP)
1834       {
1835          servedPlmnItem = modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx];
1836
1837          DU_FREE(servedPlmnItem->pLMN_Identity.buf,servedPlmnItem->pLMN_Identity.size);
1838
1839          if(servedPlmnItem->iE_Extensions != NULLP)
1840          {
1841             if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1842             {
1843                if(servedPlmnItem->iE_Extensions->list.array[arrIdx] != NULLP)
1844                {
1845                   if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1846                         list.array != NULLP)
1847                   {
1848                      for(sliceLstIdx =0; sliceLstIdx<servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
1849                            extensionValue.choice.SliceSupportList.list.count; sliceLstIdx++)
1850                      {
1851                         if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1852                               list.array[sliceLstIdx] != NULLP)
1853                         {
1854
1855                            sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1856                                               SliceSupportList.list.array[sliceLstIdx];
1857
1858                            DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sliceSupportItem->sNSSAI.sST.size);
1859                            if(sliceSupportItem->sNSSAI.sD != NULLP)
1860                            {
1861                               DU_FREE(sliceSupportItem->sNSSAI.sD->buf, sliceSupportItem->sNSSAI.sD->size);
1862                               DU_FREE(sliceSupportItem->sNSSAI.sD,sizeof(OCTET_STRING_t));
1863                            }
1864                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1865                                  SliceSupportList.list.array[sliceLstIdx], sizeof(SliceSupportItem_t));
1866                         }
1867                      }
1868                      DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.\
1869                            choice.SliceSupportList.list.array,\
1870                            servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
1871                            extensionValue.choice.SliceSupportList.list.size);
1872                   }
1873                }
1874                for(servedPlmnIdx=0; servedPlmnIdx< servedPlmnItem->iE_Extensions->list.count ; servedPlmnIdx++)
1875                {
1876                   DU_FREE(servedPlmnItem->iE_Extensions->list.array[servedPlmnIdx], sizeof(ServedPLMNs_ItemExtIEs_t ));
1877                }
1878                DU_FREE(servedPlmnItem->iE_Extensions->list.array, servedPlmnItem->iE_Extensions->list.size);
1879             }
1880             DU_FREE(servedPlmnItem->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1881          }
1882       }
1883       for(servedPlmnIdx=0; servedPlmnIdx<modifyItem->served_Cell_Information.servedPLMNs.list.count; servedPlmnIdx++)
1884       {
1885          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[servedPlmnIdx], sizeof(ServedPLMNs_Item_t));
1886       }
1887       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1888          modifyItem->served_Cell_Information.servedPLMNs.list.size);
1889    }
1890
1891    if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD != NULLP)
1892    {
1893       if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1894       {
1895          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
1896                array[arrIdx], sizeof(FreqBandNrItem_t));
1897          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array, \
1898                modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1899       }
1900
1901       if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1902       {
1903          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.\
1904              array[arrIdx], sizeof(FreqBandNrItem_t));
1905          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,\
1906                modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1907       }
1908       DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD,sizeof(FDD_Info_t));
1909    }
1910
1911    DU_FREE(modifyItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1912       modifyItem->served_Cell_Information.measurementTimingConfiguration.size);
1913 }
1914
1915 /*******************************************************************
1916  *
1917  * @brief Deallocating memory of BuildAndSendDUConfigUpdate
1918  *
1919  * @details
1920  *
1921  *    Function : FreeDUConfigUpdate
1922  *
1923  *    Functionality: Deallocating memory of variables allocated in
1924  *                    BuildAndSendDUConfigUpdate function
1925  *
1926  * @params[in]  F1AP_PDU_t *f1apDuCfg
1927  *
1928  * @return ROK     - void
1929  *
1930  * ****************************************************************/
1931 void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg)
1932 {
1933    uint8_t  ieIdx=0, cellModifyIdx=0, cellDeleteIdx=0;
1934    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
1935    Served_Cells_To_Modify_List_t  *cellsToModify=NULLP;
1936    Served_Cells_To_Delete_List_t  *cellsToDelete=NULLP;
1937    Served_Cells_To_Delete_Item_t  *deleteItem = NULLP;
1938    Served_Cells_To_Delete_ItemIEs_t *deleteItemIe = NULLP;
1939
1940    if(f1apDuCfg != NULLP)
1941    {
1942       if(f1apDuCfg->choice.initiatingMessage != NULLP)
1943       {
1944          duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->\
1945                        value.choice.GNBDUConfigurationUpdate;
1946          if(duCfgUpdate->protocolIEs.list.array != NULLP)
1947          {
1948             for(ieIdx=0; ieIdx<duCfgUpdate->protocolIEs.list.count; ieIdx++)
1949             {
1950                if(duCfgUpdate->protocolIEs.list.array[ieIdx] != NULLP)
1951                {
1952                   switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
1953                   {
1954                      case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
1955                         {
1956                            cellsToModify = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1957                                            value.choice.Served_Cells_To_Modify_List;
1958                            if(cellsToModify->list.array != NULLP)
1959                            {
1960                               for(cellModifyIdx=0; cellModifyIdx<cellsToModify->list.count ;cellModifyIdx++)
1961                               {
1962                                  if(cellsToModify->list.array[cellModifyIdx] != NULLP)
1963                                  {
1964                                     freeCellsToModifyItem(&cellsToModify->list.array[cellModifyIdx]->value.choice.\
1965                                           Served_Cells_To_Modify_Item);
1966                                     DU_FREE(cellsToModify->list.array[cellModifyIdx],\
1967                                           sizeof(Served_Cells_To_Modify_ItemIEs_t));
1968                                  }
1969                               }
1970                               DU_FREE(cellsToModify->list.array,cellsToModify->list.size);
1971                            }
1972                            break;
1973                         }
1974                      case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
1975                         {
1976                            cellsToDelete = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1977                                            value.choice.Served_Cells_To_Delete_List;
1978                            if(cellsToDelete->list.array != NULLP)
1979                            {
1980                               for(cellDeleteIdx=0; cellDeleteIdx<cellsToDelete->list.count ;cellDeleteIdx++)
1981                               {
1982                                  if(cellsToDelete->list.array[cellDeleteIdx] != NULLP)
1983                                  {
1984                                     deleteItemIe = ((Served_Cells_To_Delete_ItemIEs_t*)\
1985                                           cellsToDelete->list.array[cellDeleteIdx]);
1986                                     deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
1987                                     DU_FREE(deleteItem->oldNRCGI.pLMN_Identity.buf,\
1988                                           deleteItem->oldNRCGI.pLMN_Identity.size);
1989                                     DU_FREE(deleteItem->oldNRCGI.nRCellIdentity.buf,\
1990                                           deleteItem->oldNRCGI.nRCellIdentity.size);
1991                                     DU_FREE(cellsToDelete->list.array[cellDeleteIdx],\
1992                                           sizeof(Served_Cells_To_Delete_ItemIEs_t));
1993                                  }
1994                               }
1995                               DU_FREE(cellsToDelete->list.array,cellsToDelete->list.size);
1996                            }
1997
1998                            break;
1999                         }
2000                      case ProtocolIE_ID_id_gNB_DU_ID:
2001                         {
2002                            DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2003                                  duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2004                            break;
2005                         }
2006                   }
2007                   DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx],\
2008                         sizeof(GNBDUConfigurationUpdateIEs_t));
2009                }
2010             }
2011             DU_FREE(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2012          }
2013          DU_FREE(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2014       }
2015       DU_FREE(f1apDuCfg, (Size)sizeof(F1AP_PDU_t));
2016    }
2017 }
2018
2019 /*******************************************************************
2020  *
2021  * @brief Fills Served Plmns required in ServCellInfo IE
2022  *
2023  * @details
2024  *
2025  *    Function : fillServedPlmns
2026  *
2027  *    Functionality: Fills Served Plmns required in ServCellInfo IE
2028  *
2029  * @params[in] Pointer to ServedPLMNs_List_t *
2030  *
2031  * @return ROK     - success
2032  *         RFAILED - failure
2033  *
2034  *****************************************************************/
2035
2036 uint8_t fillServedPlmns(ServedPLMNs_List_t *servedPlmn)
2037 {
2038    uint8_t ieIdx=0, arrayIdx=0, ieListCnt=0, elementCnt=0, sliceLstIdx=0;
2039
2040    servedPlmn->list.array[arrayIdx]->pLMN_Identity.size = 3*sizeof(uint8_t);
2041    DU_ALLOC(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf, servedPlmn->list.\
2042          array[arrayIdx]->pLMN_Identity.size);
2043    if(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf == NULLP)
2044    {
2045       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2046       return RFAILED;
2047    }
2048    buildPlmnId(duCfgParam.srvdCellLst[arrayIdx].duCellInfo.cellInfo.srvdPlmn[arrayIdx].plmn,\
2049          servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf);
2050    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
2051    if(servedPlmn->list.array[arrayIdx]->iE_Extensions == NULLP)
2052    {
2053       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2054       return RFAILED;
2055    }
2056
2057    ieListCnt=1;
2058    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.count = ieListCnt;
2059    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.size = ieListCnt *sizeof(ServedPLMNs_ItemExtIEs_t *);
2060    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array,servedPlmn->list.array[arrayIdx]->\
2061          iE_Extensions->list.size);
2062    if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array == NULLP)
2063    {
2064       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2065       return RFAILED;
2066    }
2067    for(ieIdx=arrayIdx;ieIdx<ieListCnt;ieIdx++)
2068    {
2069       DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx],\
2070             sizeof(ServedPLMNs_ItemExtIEs_t));
2071       if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx] == NULLP)
2072       {
2073          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2074          return RFAILED;
2075       }
2076    }
2077
2078    ieIdx = 0;
2079    elementCnt = NUM_OF_SUPPORTED_SLICE;
2080    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->id =ProtocolIE_ID_id_TAISliceSupportList;
2081    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->criticality = Criticality_ignore;
2082    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.present = \
2083    ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
2084    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2085       list.count = elementCnt;
2086    servedPlmn->list.array[arrayIdx]->\
2087       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2088       list.size = elementCnt * sizeof(SliceSupportItem_t *);
2089    DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2090          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2091          list.array,servedPlmn->list.array[arrayIdx]->\
2092          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.size);
2093    if(servedPlmn->list.array[arrayIdx]->\
2094          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2095          list.array == NULLP)
2096    {
2097       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2098       return RFAILED;
2099    }
2100
2101    for(sliceLstIdx =0; sliceLstIdx< elementCnt; sliceLstIdx++)
2102    {
2103       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2104       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2105       list.array[sliceLstIdx],sizeof( SliceSupportItem_t));
2106       if(servedPlmn->list.array[arrayIdx]->\
2107       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2108       list.array[sliceLstIdx] == NULLP)
2109       {
2110          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2111          return RFAILED;
2112       }
2113
2114       servedPlmn->list.array[arrayIdx]->\
2115       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2116       list.array[sliceLstIdx]->sNSSAI.sST.size = sizeof(uint8_t);
2117       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2118       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2119       list.array[sliceLstIdx]->sNSSAI.sST.buf,servedPlmn->list.array[arrayIdx]->\
2120       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->\
2121       sNSSAI.sST.size);
2122
2123       if(servedPlmn->list.array[arrayIdx]->\
2124       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2125       list.array[sliceLstIdx]->sNSSAI.sST.buf == NULLP)
2126       {
2127          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2128          return RFAILED;
2129       }
2130       servedPlmn->list.array[arrayIdx]->\
2131       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2132       list.array[sliceLstIdx]->sNSSAI.sST.buf[arrayIdx] =  duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
2133       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
2134
2135       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2136       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2137       list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
2138       if(servedPlmn->list.array[arrayIdx]->\
2139       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2140       list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
2141       {
2142          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2143          return RFAILED;
2144       }
2145       servedPlmn->list.array[arrayIdx]->\
2146       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2147       list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
2148       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2149       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2150       list.array[sliceLstIdx]->sNSSAI.sD->buf,servedPlmn->list.array[arrayIdx]->\
2151       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2152       list.array[sliceLstIdx]->sNSSAI.sD->size);
2153       if(servedPlmn->list.array[arrayIdx]->\
2154       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2155       list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
2156       {
2157          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2158          return RFAILED;
2159       }
2160       memcpy(servedPlmn->list.array[arrayIdx]->\
2161       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2162       list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
2163       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sd,\
2164       servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2165       list.array[sliceLstIdx]->sNSSAI.sD->size);
2166    }
2167    return ROK;
2168 }
2169
2170 /*******************************************************************
2171  *
2172  * @brief Fills Nr Fdd Info required in ServCellInfo IE
2173  *
2174  * @details
2175  *
2176  *    Function : fillNrFddInfo
2177  *
2178  *    Functionality: Fills Nr Fdd Info required in ServCellInfo IE
2179  *
2180  * @params[in] Pointer to NR_Mode_Info_t *
2181  *
2182  * @return ROK     - success
2183  *         RFAILED - failure
2184  *
2185  *****************************************************************/
2186
2187 uint8_t fillNrFddInfo(NR_Mode_Info_t *nrFdd)
2188 {
2189    nrFdd->choice.fDD->uL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.\
2190       f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn;
2191    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.count = 1;
2192    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t*);
2193    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
2194          array, nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size);
2195    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2196    {
2197       return RFAILED;
2198    }
2199    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0], \
2200       sizeof(FreqBandNrItem_t));
2201    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2202    {
2203       return RFAILED;
2204    }
2205    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2206       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
2207       freqBand[0].nrFreqBand;
2208    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2209    nrFdd->choice.fDD->dL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.\
2210       dlNrFreqInfo.nrArfcn;
2211    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.count = 1;
2212    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
2213    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,nrFdd->\
2214          choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
2215    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2216    {
2217       return RFAILED;
2218    }
2219    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0],\
2220          sizeof(FreqBandNrItem_t));
2221    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2222    {
2223       return RFAILED;
2224    }
2225    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2226       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
2227       freqBand[0].nrFreqBand;
2228    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2229
2230    /*Transmission Bandwidth*/
2231    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2232       f1Mode.mode.fdd.ulTxBw.nrScs;
2233    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2234       f1Mode.mode.fdd.ulTxBw.nrb;
2235    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2236       f1Mode.mode.fdd.dlTxBw.nrScs;
2237    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2238       f1Mode.mode.fdd.dlTxBw.nrb;
2239
2240    return ROK;
2241 }
2242
2243 /*******************************************************************
2244  *
2245  * @brief Fills ServCellInfo IE
2246  *
2247  * @details
2248  *
2249  *    Function : fillServedCellInfo
2250  *
2251  *    Functionality: Fills ServCellInfo
2252  *
2253  * @params[in] Pointer to Served_Cell_Information_t *
2254  *
2255  * @return ROK     - success
2256  *         RFAILED - failure
2257  *
2258  *****************************************************************/
2259
2260 uint8_t fillServedCellInfo(Served_Cell_Information_t *srvCellInfo)
2261 {
2262    uint8_t tmp, ieIdx, ieListCnt;
2263
2264    /*nRCGI*/
2265    srvCellInfo->nRCGI.pLMN_Identity.size =3*sizeof(uint8_t);
2266    DU_ALLOC(srvCellInfo->nRCGI.pLMN_Identity.buf,\
2267          srvCellInfo->nRCGI.pLMN_Identity.size);
2268    if(srvCellInfo->nRCGI.pLMN_Identity.buf == NULLP)
2269    {
2270       return RFAILED;
2271    }
2272    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2273          srvCellInfo->nRCGI.pLMN_Identity.buf);
2274    srvCellInfo->nRCGI.nRCellIdentity.size =5*sizeof(uint8_t);
2275    DU_ALLOC(srvCellInfo->nRCGI.nRCellIdentity.buf,\
2276          srvCellInfo->nRCGI.nRCellIdentity.size);
2277    if(srvCellInfo->nRCGI.nRCellIdentity.buf == NULLP)
2278    {
2279       return RFAILED;
2280    }
2281    for (tmp = 0 ; tmp < srvCellInfo->\
2282          nRCGI.nRCellIdentity.size-1 ; tmp++)
2283    {
2284       srvCellInfo->nRCGI.nRCellIdentity.buf[tmp] = 0;
2285    }
2286    srvCellInfo->nRCGI.nRCellIdentity.buf[4] = 16;
2287    srvCellInfo->nRCGI.nRCellIdentity.bits_unused =4;
2288
2289    /*nRPCI*/
2290    srvCellInfo->nRPCI = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
2291
2292    /*servedPLMNs*/
2293    ieListCnt = 1;
2294    srvCellInfo->servedPLMNs.list.count = ieListCnt;
2295    srvCellInfo->servedPLMNs.list.size = ieListCnt*sizeof(ServedPLMNs_Item_t *);
2296    DU_ALLOC(srvCellInfo->servedPLMNs.list.array,\
2297          srvCellInfo->servedPLMNs.list.size);
2298    if(srvCellInfo->servedPLMNs.list.array == NULLP)
2299    {
2300       return RFAILED;
2301    }
2302    for(ieIdx=0; ieIdx < ieListCnt; ieIdx++)
2303    {
2304       DU_ALLOC(srvCellInfo->servedPLMNs.list.array[ieIdx],\
2305             sizeof(ServedPLMNs_Item_t));
2306       if(srvCellInfo->servedPLMNs.list.array[ieIdx]== NULLP)
2307       {
2308          return RFAILED;
2309       }
2310    }
2311    if(fillServedPlmns(&srvCellInfo->servedPLMNs))
2312    {
2313       return RFAILED;
2314    }
2315
2316    /*nR Mode Info with FDD*/
2317    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_fDD;
2318    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.fDD,\
2319          sizeof(FDD_Info_t));
2320    if(srvCellInfo->nR_Mode_Info.choice.fDD == NULLP)
2321    {
2322       return RFAILED;
2323    }
2324    if(fillNrFddInfo(&srvCellInfo->nR_Mode_Info))
2325       return RFAILED;
2326
2327    /*Measurement timing Config*/
2328    srvCellInfo->measurementTimingConfiguration.size = sizeof(uint8_t);
2329    DU_ALLOC(srvCellInfo->measurementTimingConfiguration.\
2330          buf,srvCellInfo->measurementTimingConfiguration.size);
2331    if(srvCellInfo->measurementTimingConfiguration.buf == NULLP)
2332    {
2333       return RFAILED;
2334    }
2335    srvCellInfo->measurementTimingConfiguration.\
2336          buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
2337
2338    return ROK;
2339 }
2340
2341 /*******************************************************************
2342  *
2343  * @brief Fills ServCellToModItem IE
2344  *
2345  * @details
2346  *
2347  *    Function : fillServCellToModItem
2348  *
2349  *    Functionality: Fills ServCellToModItem IE
2350  *
2351  * @params[in] Pointer to Served_Cells_To_Modify_Item_t *
2352  *
2353  * @return ROK     - success
2354  *         RFAILED - failure
2355  *
2356  *****************************************************************/
2357
2358 uint8_t fillServCellToModItem(Served_Cells_To_Modify_Item_t *modifyItem)
2359 {
2360    uint8_t ieIdx;
2361
2362    /*pLMN_Identity*/
2363    modifyItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2364    DU_ALLOC(modifyItem->oldNRCGI.pLMN_Identity.buf,modifyItem->oldNRCGI.pLMN_Identity.size);
2365    if(modifyItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2366    {
2367       return RFAILED;
2368    }
2369    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2370          modifyItem->oldNRCGI.pLMN_Identity.buf);
2371
2372    /*nRCellIdentity*/
2373    modifyItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2374    DU_ALLOC(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2375          modifyItem->oldNRCGI.nRCellIdentity.size);
2376    if(modifyItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2377    {
2378       return RFAILED;
2379    }
2380    for(ieIdx = 0; ieIdx < modifyItem->oldNRCGI.nRCellIdentity.size-1; ieIdx++)
2381    {
2382       modifyItem->oldNRCGI.nRCellIdentity.buf[ieIdx] = 0;
2383    }
2384    modifyItem->oldNRCGI.nRCellIdentity.buf[4] = 16;
2385    modifyItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
2386
2387    if(fillServedCellInfo(&modifyItem->served_Cell_Information))
2388       return RFAILED;
2389    else
2390       return ROK;
2391 }
2392
2393 /*******************************************************************
2394  *
2395  * @brief Builds ServCellToModList
2396  *
2397  * @details
2398  *
2399  *    Function : buildServCellToModList
2400  *
2401  *    Functionality: Builds the serv cell to Mod List
2402  *
2403  * @params[in] Pointer to Served_Cells_To_Modify_List_t *
2404  *
2405  * @return ROK     - success
2406  *         RFAILED - failure
2407  *
2408  *****************************************************************/
2409
2410 uint8_t buildServCellToModList(Served_Cells_To_Modify_List_t *cellsToModify)
2411 {
2412    uint8_t ieListCnt, ieIdx;
2413    Served_Cells_To_Modify_Item_t *modifyItem = NULLP;
2414
2415    ieListCnt = 1;
2416    cellsToModify->list.count = ieListCnt;
2417    cellsToModify->list.size = ieListCnt*sizeof(Served_Cells_To_Modify_ItemIEs_t *);
2418    DU_ALLOC(cellsToModify->list.array,cellsToModify->list.size);
2419    if(cellsToModify->list.array == NULLP)
2420    {
2421       return RFAILED;
2422    }
2423    for(ieIdx=0; ieIdx< ieListCnt; ieIdx++)
2424    {
2425       DU_ALLOC(cellsToModify->list.array[ieIdx],sizeof(Served_Cells_To_Modify_ItemIEs_t));
2426       if(cellsToModify->list.array[ieIdx] == NULLP)
2427       {
2428          return RFAILED;
2429       }
2430    }
2431    cellsToModify->list.array[0]->id = ProtocolIE_ID_id_Served_Cells_To_Modify_Item;
2432    cellsToModify->list.array[0]->criticality = Criticality_reject;
2433    cellsToModify->list.array[0]->value.present =\
2434       Served_Cells_To_Modify_ItemIEs__value_PR_Served_Cells_To_Modify_Item;
2435    modifyItem=&cellsToModify->list.array[0]->value.choice.Served_Cells_To_Modify_Item;
2436
2437    if(fillServCellToModItem(modifyItem))
2438       return RFAILED;
2439    else
2440       return ROK;
2441 }
2442 /*******************************************************************
2443  *
2444  * @brief filling the DeleteItemList
2445  *
2446  * @details
2447  *
2448  *    Function : fillCellToDeleteItem
2449  *
2450  *    Functionality: Filling the DeleteItemIe
2451  *
2452  * @params[in] Pointer to Served_Cells_To_Delete_ItemIEs_t
2453  *
2454  * @return ROK     - success
2455  *         RFAILED - failure
2456  *
2457  *****************************************************************/
2458 uint8_t fillCellToDeleteItem(struct Served_Cells_To_Delete_ItemIEs *deleteItemIe)
2459 {
2460    uint8_t arrIdx;
2461    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
2462
2463    deleteItemIe->id = ProtocolIE_ID_id_Served_Cells_To_Delete_Item;
2464    deleteItemIe->criticality = Criticality_reject;
2465    deleteItemIe->value.present =\
2466    Served_Cells_To_Delete_ItemIEs__value_PR_Served_Cells_To_Delete_Item;
2467    deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
2468
2469    /*pLMN_Identity*/
2470    deleteItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2471    DU_ALLOC(deleteItem->oldNRCGI.pLMN_Identity.buf,deleteItem->oldNRCGI.pLMN_Identity.size);
2472    if(deleteItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2473    {
2474       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2475       return RFAILED;
2476    }
2477    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2478          deleteItem->oldNRCGI.pLMN_Identity.buf);
2479
2480    /*nRCellIdentity*/
2481    deleteItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2482    DU_ALLOC(deleteItem->oldNRCGI.nRCellIdentity.buf,\
2483          deleteItem->oldNRCGI.nRCellIdentity.size);
2484    if(deleteItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2485    {
2486       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2487       return RFAILED;
2488    }
2489    for(arrIdx = 0; arrIdx < deleteItem->oldNRCGI.nRCellIdentity.size-1; arrIdx++)
2490    {
2491       deleteItem->oldNRCGI.nRCellIdentity.buf[arrIdx] = 0;
2492    }
2493    deleteItem->oldNRCGI.nRCellIdentity.buf[4] = 16;
2494    deleteItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
2495    return ROK;
2496 }
2497 /*******************************************************************
2498  *
2499  * @brief Builds ServCellToDeleteList
2500  *
2501  * @details
2502  *
2503  *    Function : buildServCellToDeleteList
2504  *
2505  *    Functionality: Builds the serv cell to delete List
2506  *
2507  * @params[in] Pointer to Served_Cells_To_Delete_List_t *
2508  *
2509  * @return ROK     - success
2510  *         RFAILED - failure
2511  *
2512  *****************************************************************/
2513
2514 uint8_t buildServCellToDeleteList(Served_Cells_To_Delete_List_t *cellsToDelete)
2515 {
2516    uint8_t ieListCnt, arrIdx;
2517
2518    ieListCnt = 1;
2519    cellsToDelete->list.count = ieListCnt;
2520    cellsToDelete->list.size = ieListCnt*sizeof(Served_Cells_To_Delete_ItemIEs_t *);
2521
2522    DU_ALLOC(cellsToDelete->list.array,cellsToDelete->list.size);
2523    if(cellsToDelete->list.array == NULLP)
2524    {
2525       DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2526       return RFAILED;
2527    }
2528
2529    for(arrIdx=0; arrIdx< ieListCnt; arrIdx++)
2530    {
2531       DU_ALLOC(cellsToDelete->list.array[arrIdx],sizeof(Served_Cells_To_Delete_ItemIEs_t));
2532       if(cellsToDelete->list.array[arrIdx] == NULLP)
2533       {
2534          DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2535          return RFAILED;
2536       }
2537    }
2538
2539    arrIdx=0;
2540    if(fillCellToDeleteItem((Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx]) !=ROK)
2541    {
2542       DU_LOG("\nERROR  -->  F1AP: buildServCellToDeleteList(): failed to fill Served_Cells_To_Delete_ItemIEs");
2543       return RFAILED;
2544    }
2545    return ROK;
2546 }
2547
2548 /*******************************************************************
2549  *
2550  * @brief Builds and sends the DUConfigUpdate
2551  *
2552  * @details
2553  *
2554  *    Function : BuildAndSendDUConfigUpdate
2555  *
2556  *    Functionality: Constructs the DU Update message and sends
2557  *                   it to the CU through SCTP.
2558  *
2559  * @params[in] void **buf,Buffer to which encoded pattern is written into
2560  * @params[in] int *size,size of buffer
2561  *
2562  * @return ROK     - success
2563  *         RFAILED - failure
2564  *
2565  * ****************************************************************/
2566 uint8_t BuildAndSendDUConfigUpdate(ServCellAction servCellAction)
2567 {
2568    uint8_t ret =0, ieIdx=0, elementCnt=0;
2569    bool memAlloctionFailure = false;
2570    F1AP_PDU_t                 *f1apDuCfg = NULLP;
2571    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
2572    asn_enc_rval_t encRetVal;     /* Encoder return value */
2573
2574    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2575    ret= RFAILED;
2576
2577    while(true)
2578    {
2579       DU_LOG("\nINFO   -->  F1AP : Building DU config update\n");
2580       /* Allocate the memory for F1DuCfg */
2581       DU_ALLOC(f1apDuCfg, sizeof(F1AP_PDU_t));
2582       if(f1apDuCfg == NULLP)
2583       {
2584          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2585          break;
2586       }
2587
2588       f1apDuCfg->present = F1AP_PDU_PR_initiatingMessage;
2589       DU_ALLOC(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2590       if(f1apDuCfg->choice.initiatingMessage == NULLP)
2591       {
2592          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2593          break;
2594       }
2595
2596       f1apDuCfg->choice.initiatingMessage->procedureCode = \
2597                                                            ProcedureCode_id_gNBDUConfigurationUpdate;
2598       f1apDuCfg->choice.initiatingMessage->criticality = Criticality_reject;
2599       f1apDuCfg->choice.initiatingMessage->value.present = \
2600                                                            InitiatingMessage__value_PR_GNBDUConfigurationUpdate;
2601       duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\
2602                     choice.GNBDUConfigurationUpdate;
2603       elementCnt = 3;
2604       duCfgUpdate->protocolIEs.list.count = elementCnt;
2605       duCfgUpdate->protocolIEs.list.size = \
2606                                            elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t*);
2607
2608       /* Initialize the F1Setup members */
2609       DU_ALLOC(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2610       if(duCfgUpdate->protocolIEs.list.array == NULLP)
2611       {
2612          DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2613          break;
2614       }
2615       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
2616       {
2617          DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx],sizeof(GNBDUConfigurationUpdateIEs_t));
2618          if(duCfgUpdate->protocolIEs.list.array[ieIdx] == NULLP)
2619          {
2620             DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2621             memAlloctionFailure = true;
2622             break;
2623          }
2624       }
2625
2626       if(memAlloctionFailure == true)
2627       {
2628          break;
2629       }
2630       /*TransactionID*/
2631       ieIdx = 0;
2632       duCfgUpdate->protocolIEs.list.array[ieIdx]->id=ProtocolIE_ID_id_TransactionID;
2633       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
2634       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2635       GNBDUConfigurationUpdateIEs__value_PR_TransactionID;
2636       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = TRANS_ID;
2637
2638       ieIdx++;
2639       if(servCellAction == SERV_CELL_TO_MODIFY)
2640       {
2641          /*Served Cell to Modify */
2642          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2643          ProtocolIE_ID_id_Served_Cells_To_Modify_List;
2644          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2645          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2646          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Modify_List;
2647          if(buildServCellToModList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2648                   Served_Cells_To_Modify_List))
2649          {
2650             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToModList");
2651             break;
2652          }
2653       }
2654       else
2655       {
2656          /*Served Cell to Delete */
2657          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2658          ProtocolIE_ID_id_Served_Cells_To_Delete_List;
2659          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2660          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2661          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Delete_List;
2662          if(buildServCellToDeleteList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2663          Served_Cells_To_Delete_List)!=ROK)
2664          {
2665             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToDeleteList");
2666             break;
2667          }
2668
2669       }
2670       // NOTE :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
2671       /*GNB DU ID */
2672       ieIdx++;
2673       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
2674       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
2675       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2676       GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID;
2677       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size = sizeof(uint8_t);
2678       DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2679             duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2680       if(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == NULLP)
2681       {
2682          DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): Memory allocation failed for GNB_DU_ID");
2683          break;
2684       }
2685       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] = duCfgParam.duId;
2686
2687       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
2688
2689       /* Encode the DU Config Update type as APER */
2690       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
2691       encBufSize = 0;
2692       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
2693
2694       /* Checking encode results */
2695       if(encRetVal.encoded == ENCODE_FAIL)
2696       {
2697          DU_LOG("ERROR  -->  F1AP : Could not encode DUConfigUpdate structure (at %s)\n",\
2698                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2699          break;
2700       }
2701       else
2702       {
2703          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DUConfigUpdate\n");
2704          for(ieIdx =0; ieIdx < encBufSize; ieIdx++)
2705          {
2706             printf("%x",encBuf[ieIdx]);
2707          }
2708       }
2709       /* Sending msg */
2710       if(sendF1APMsg() != ROK)
2711       {
2712          DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update failed");
2713          break;
2714       }
2715
2716       ret = ROK;
2717       break;
2718    }
2719
2720    addToReservedF1apPduList(TRANS_ID,f1apDuCfg);
2721    return ret;
2722 }
2723
2724
2725 /*******************************************************************
2726  *
2727  * @brief free the ULRRCMessageTransfer
2728  *
2729  * @details
2730  *
2731  *    Function : FreeULRRCMessageTransfer
2732  *
2733  *    Functionality: Deallocating the memory of variable allocated in
2734  *                      FreeULRRCMessageTransfer
2735  *
2736  * @params[in]
2737  *
2738  * @return ROK     - void
2739  *
2740  ******************************************************************/
2741 void FreeULRRCMessageTransfer( F1AP_PDU_t *f1apMsg)
2742 {
2743    uint8_t idx1;
2744    ULRRCMessageTransfer_t  *ulRRCMsg;
2745
2746    if(f1apMsg != NULLP)
2747    {
2748       if(f1apMsg->choice.initiatingMessage != NULLP)
2749       {
2750          ulRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2751          if(ulRRCMsg->protocolIEs.list.array != NULLP)
2752          {
2753             for(idx1=0;idx1<ulRRCMsg->protocolIEs.list.count;idx1++)
2754             {
2755                if(ulRRCMsg->protocolIEs.list.array[idx1] != NULLP)
2756                {
2757                   if(ulRRCMsg->protocolIEs.list.array[idx1]->value.present ==
2758                         ULRRCMessageTransferIEs__value_PR_RRCContainer)
2759                   {
2760                      DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2761                            ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2762                   }
2763                   DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1],sizeof(ULRRCMessageTransferIEs_t));
2764                }
2765             }
2766             DU_FREE(ulRRCMsg->protocolIEs.list.array,ulRRCMsg->protocolIEs.list.size );
2767          }
2768          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2769       }
2770       DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
2771    }
2772 }
2773 /*******************************************************************
2774  *
2775  * @brief Builds and sends the ULRRCMessageTransfer
2776  *
2777  * @details
2778  *
2779  *    Function : BuildAndSendULRRCMessageTransfer
2780  *
2781  *    Functionality: Constructs the UL RRC Message Transfer and sends
2782  *                   it to the CU through SCTP.
2783  *
2784  * @params[in]
2785  *
2786  * @return ROK     - success
2787  *         RFAILED - failure
2788  *
2789  * ****************************************************************/
2790 uint8_t BuildAndSendULRRCMessageTransfer(DuUeCb  ueCb, uint8_t lcId, \
2791       uint16_t msgLen, uint8_t *rrcMsg)
2792 {
2793    uint8_t   elementCnt =0;
2794    uint8_t   idx1 =0;
2795    uint8_t   idx =0;
2796    F1AP_PDU_t                   *f1apMsg = NULLP;
2797    ULRRCMessageTransfer_t       *ulRRCMsg = NULLP;
2798    asn_enc_rval_t               encRetVal;        /* Encoder return value */
2799    uint8_t ret =RFAILED;
2800
2801    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2802
2803    while(true)
2804    {
2805       DU_LOG("\n INFO   -->  F1AP : Building UL RRC Message Transfer Message\n");
2806
2807       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
2808       if(f1apMsg == NULLP)
2809       {
2810          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2811          break;
2812       }
2813       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
2814       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2815       if(f1apMsg->choice.initiatingMessage == NULLP)
2816       {
2817          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
2818          break;
2819       }
2820       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_ULRRCMessageTransfer;
2821       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
2822       f1apMsg->choice.initiatingMessage->value.present = \
2823                                                          InitiatingMessage__value_PR_ULRRCMessageTransfer;
2824       ulRRCMsg =
2825          &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2826       elementCnt = 4;
2827       ulRRCMsg->protocolIEs.list.count = elementCnt;
2828       ulRRCMsg->protocolIEs.list.size = \
2829                                         elementCnt * sizeof(ULRRCMessageTransferIEs_t *);
2830
2831       /* Initialize the F1Setup members */
2832       DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size);
2833       if(ulRRCMsg->protocolIEs.list.array == NULLP)
2834       {
2835          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
2836          break;
2837       }
2838       for(idx=0; idx<elementCnt; idx++)
2839       {
2840          DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t));
2841          if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP)
2842          {
2843             break;
2844          }
2845       }
2846
2847       idx1 = 0;
2848
2849       /*GNB CU UE F1AP ID*/
2850       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
2851       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2852       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2853                                                               ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
2854       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = ueCb.gnbCuUeF1apId;
2855
2856       /*GNB DU UE F1AP ID*/
2857       idx1++;
2858       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
2859       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2860       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2861                                                               ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
2862       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = ueCb.gnbDuUeF1apId;
2863
2864       /*SRBID*/
2865       idx1++;
2866       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
2867       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2868       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2869                                                               ULRRCMessageTransferIEs__value_PR_SRBID;
2870       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = lcId;
2871
2872       /*RRCContainer*/
2873       idx1++;
2874       ulRRCMsg->protocolIEs.list.array[idx1]->id  = ProtocolIE_ID_id_RRCContainer;
2875       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2876       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2877                                                               ULRRCMessageTransferIEs__value_PR_RRCContainer;
2878       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size = msgLen;
2879       DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2880             ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
2881       if(!ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
2882       {
2883          DU_LOG(" ERROR  -->  F1AP : Memory allocation for BuildAndSendULRRCMessageTransfer failed");
2884          break;
2885       }
2886       memset(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, 0, msgLen);
2887       memcpy(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, \
2888             rrcMsg, ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2889
2890       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2891
2892       /* Encode the F1SetupRequest type as APER */
2893       memset(encBuf, 0, ENC_BUF_MAX_LEN);
2894       encBufSize = 0;
2895       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
2896             encBuf);
2897       /* Encode results */
2898       if(encRetVal.encoded == ENCODE_FAIL)
2899       {
2900          DU_LOG( "\nERROR  -->  F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
2901                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2902          break;
2903       }
2904       else
2905       {
2906          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
2907          for(int i=0; i< encBufSize; i++)
2908          {
2909             printf("%x",encBuf[i]);
2910          }
2911       }
2912
2913       /* Sending  msg  */
2914       if(sendF1APMsg()  !=      ROK)
2915       {
2916          DU_LOG("\nERROR  -->   F1AP : Sending  UL RRC Message Transfer Failed");
2917          break;
2918       }
2919       ret = ROK;
2920       break;
2921    }
2922    FreeULRRCMessageTransfer(f1apMsg);
2923
2924    return ret;
2925 }/* End of BuildAndSendULRRCMessageTransfer*/
2926
2927 /*******************************************************************
2928  *
2929  * @brief Builds tag config
2930  *
2931  * @details
2932  *
2933  *    Function : BuildTagConfig
2934  *
2935  *    Functionality: Builds tag config in MacCellGroupConfig
2936  *
2937  * @params[in] TAG_Config *tag_Config
2938  *
2939  * @return ROK     - success
2940  *         RFAILED - failure
2941  *
2942  * ****************************************************************/
2943 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
2944 {
2945    struct TAG_Config__tag_ToAddModList *tagList;
2946    uint8_t                     idx, elementCnt;
2947
2948    tagConfig->tag_ToReleaseList = NULLP;
2949    tagConfig->tag_ToAddModList = NULLP;
2950    DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
2951    if(!tagConfig->tag_ToAddModList)
2952    {
2953       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2954       return RFAILED;
2955    }
2956
2957    elementCnt = 1; //ODU_VALUE_ONE;
2958    tagList = tagConfig->tag_ToAddModList;
2959    tagList->list.count = elementCnt;
2960    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
2961
2962    tagList->list.array = NULLP;
2963    DU_ALLOC(tagList->list.array, tagList->list.size);
2964    if(!tagList->list.array)
2965    {
2966       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2967       return RFAILED;
2968    }
2969
2970    for(idx=0; idx<tagList->list.count; idx++)
2971    {
2972       tagList->list.array[idx] = NULLP;
2973       DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
2974       if(!tagList->list.array[idx])
2975       {
2976          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2977          return RFAILED;
2978       }
2979    }
2980
2981    idx = 0;
2982    tagList->list.array[idx]->tag_Id = TAG_ID;
2983    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
2984
2985    return ROK;
2986 }
2987
2988 /*******************************************************************
2989  *
2990  * @brief Builds PHR Config
2991  *
2992  * @details
2993  *
2994  *    Function : BuildPhrConfig
2995  *
2996  *    Functionality: Builds phrConfig in MacCellGroupConfig
2997  *
2998  * @params[in] PHR Config *
2999  *
3000  * @return ROK     - success
3001  *         RFAILED - failure
3002  *
3003  * ****************************************************************/
3004 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
3005 {
3006
3007    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
3008    phrConfig->choice.setup = NULLP;
3009    DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
3010    if(!phrConfig->choice.setup)
3011    {
3012       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
3013       return RFAILED;
3014    }
3015
3016    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
3017    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
3018    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
3019    phrConfig->choice.setup->multiplePHR              = false;
3020    phrConfig->choice.setup->dummy                    = false;
3021    phrConfig->choice.setup->phr_Type2OtherCell       = false;
3022    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
3023
3024    return ROK;
3025 }
3026
3027 /*******************************************************************
3028  *
3029  * @brief Builds BSR Config
3030  *
3031  * @details
3032  *
3033  *    Function : BuildBsrConfig
3034  *
3035  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
3036  *
3037  * @params[in] BSR_Config *bsrConfig
3038  *
3039  * @return ROK     - success
3040  *         RFAILED - failure
3041  *
3042  * ****************************************************************/
3043 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
3044 {
3045    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
3046    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
3047    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
3048
3049    return ROK;
3050 }
3051
3052 /*******************************************************************
3053  *
3054  * @brief Builds scheduling request config
3055  *
3056  * @details
3057  *
3058  *    Function : BuildSchedulingReqConfig
3059  *
3060  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
3061  *
3062  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
3063  *
3064  * @return ROK     - success
3065  *         RFAILED - failure
3066  *
3067  * ****************************************************************/
3068 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
3069 {
3070    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
3071    uint8_t                     idx, elementCnt;
3072
3073    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
3074    DU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
3075          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
3076    if(!schedulingRequestConfig->schedulingRequestToAddModList)
3077    {
3078       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3079       return RFAILED;
3080    }
3081
3082    elementCnt = 1; //ODU_VALUE_ONE;
3083    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
3084    schReqList->list.count = elementCnt;
3085    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
3086
3087    schReqList->list.array = NULLP;
3088    DU_ALLOC(schReqList->list.array, schReqList->list.size);
3089    if(!schReqList->list.array)
3090    {
3091       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3092       return RFAILED;
3093    }
3094
3095    for(idx=0;idx<schReqList->list.count; idx++)
3096    {
3097       schReqList->list.array[idx] = NULLP;
3098       DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
3099       if(!schReqList->list.array[idx])
3100       {
3101          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3102          return RFAILED;
3103       }
3104    }
3105
3106    idx = 0;
3107    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
3108
3109    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
3110    DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
3111    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
3112    {
3113       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3114       return RFAILED;
3115    }
3116    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
3117    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
3118    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
3119
3120    return ROK;
3121 }
3122
3123 /*******************************************************************
3124  *
3125  * @brief Builds RLC Config
3126  *
3127  * @details
3128  *
3129  *    Function : BuildRlcConfig
3130  *
3131  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
3132  *
3133  * @params[in] RLC_Config *rlcConfig
3134  *
3135  * @return ROK     - success
3136  *         RFAILED - failure
3137  *
3138  * ****************************************************************/
3139 uint8_t BuildRlcConfig(struct RLC_Config *rlcConfig)
3140 {
3141
3142    rlcConfig->present = RLC_Config_PR_am;
3143
3144    rlcConfig->choice.am = NULLP;
3145    DU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
3146    if(!rlcConfig->choice.am)
3147    {
3148       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3149       return RFAILED;
3150    }
3151
3152    /* UL */
3153    rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
3154    DU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3155    if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
3156    {
3157       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3158       return RFAILED;
3159    }
3160    *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3161    rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
3162    rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
3163    rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
3164    rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
3165
3166    /* DL */
3167    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
3168    DU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3169    if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
3170    {
3171       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3172       return RFAILED;
3173    }
3174    *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3175    rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
3176    rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
3177
3178    return ROK;
3179 }
3180
3181 /*******************************************************************
3182  *
3183  * @brief Builds MAC LC Config
3184  *
3185  * @details
3186  *
3187  *    Function : BuildMacLCConfig
3188  *
3189  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
3190  *
3191  * @params[in] struct LogicalChannelConfig macLcConfig
3192  *
3193  * @return ROK     - success
3194  *         RFAILED - failure
3195  *
3196  * ****************************************************************/
3197 uint8_t BuildMacLCConfig(struct LogicalChannelConfig *macLcConfig)
3198 {
3199
3200    macLcConfig->ul_SpecificParameters = NULLP;
3201    DU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
3202    if(!macLcConfig->ul_SpecificParameters)
3203    {
3204       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3205       return RFAILED;
3206    }
3207
3208    macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
3209    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     PRIORTISIED_BIT_RATE;
3210    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     BUCKET_SIZE_DURATION;
3211    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
3212    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
3213    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
3214    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
3215
3216    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
3217    DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
3218    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
3219    {
3220       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3221       return RFAILED;
3222    }
3223    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
3224
3225    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
3226    DU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
3227    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
3228    {
3229       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3230       return RFAILED;
3231    }
3232    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
3233
3234    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
3235    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
3236    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
3237
3238    return ROK;
3239 }
3240
3241 /*******************************************************************
3242  *
3243  * @brief Builds RLC Bearer to Add/Mod list
3244  *
3245  * @details
3246  *
3247  *    Function :BuildRlcBearerToAddModList
3248  *
3249  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
3250  *
3251  * @params[in] rlc_BearerToAddModList
3252  *
3253  * @return ROK     - success
3254  *         RFAILED - failure
3255  *
3256  * ****************************************************************/
3257 uint8_t BuildRlcBearerToAddModList(struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
3258 {
3259    uint8_t                     idx, elementCnt;
3260
3261    elementCnt = 1;
3262    rlcBearerList->list.count = elementCnt;
3263    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
3264
3265    rlcBearerList->list.array = NULLP;
3266    DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
3267    if(!rlcBearerList->list.array)
3268    {
3269       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3270       return RFAILED;
3271    }
3272
3273    for(idx=0; idx<rlcBearerList->list.count; idx++)
3274    {
3275       rlcBearerList->list.array[idx] = NULLP;
3276       DU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
3277       if(!rlcBearerList->list.array[idx])
3278       {
3279          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3280          return RFAILED;
3281       }
3282    }
3283
3284    idx = 0;
3285    rlcBearerList->list.array[idx]->logicalChannelIdentity = SRB1_LCID;
3286
3287    DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, \
3288       sizeof(struct RLC_BearerConfig__servedRadioBearer));
3289    if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3290    {
3291       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3292       return RFAILED;
3293    }
3294
3295    rlcBearerList->list.array[idx]->servedRadioBearer->present = \
3296       RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
3297    rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = \
3298       SRB1_LCID;
3299
3300    rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3301    rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3302    DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3303    if(!rlcBearerList->list.array[idx]->rlc_Config)
3304    {
3305       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3306       return RFAILED;
3307    }
3308
3309    if(BuildRlcConfig(rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3310    {
3311       DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3312       return RFAILED;
3313    }
3314
3315    rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3316    DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, \
3317       sizeof(struct LogicalChannelConfig));
3318    if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3319    {
3320       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3321       return RFAILED;
3322    }
3323
3324    if(BuildMacLCConfig(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3325    {
3326       DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3327       return RFAILED;
3328    }
3329
3330    return ROK;
3331 }
3332
3333 /*******************************************************************
3334  *
3335  * @brief Build Control resource set to add/modify list
3336  *
3337  * @details
3338  *
3339  *    Function : BuildControlRSetToAddModList
3340  *
3341  *    Functionality: Build Control resource set to add/modify list
3342  *
3343  * @params[in]
3344  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3345  *
3346  * @return ROK     - success
3347  *         RFAILED - failure
3348  *
3349  * ****************************************************************/
3350    uint8_t BuildControlRSetToAddModList
3351 (
3352  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3353  )
3354 {
3355    uint8_t idx;
3356    uint8_t elementCnt;
3357    uint8_t numBytes, bitsUnused;
3358    struct ControlResourceSet *controlRSet;
3359    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3360    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3361
3362
3363    elementCnt = 1;
3364    controlRSetList->list.count = elementCnt;
3365    controlRSetList->list.size = \
3366                                 elementCnt * sizeof(struct ControlResourceSet *);
3367
3368    controlRSetList->list.array = NULLP;
3369    DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3370    if(!controlRSetList->list.array)
3371    {
3372       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3373       return RFAILED;
3374    }
3375
3376    for(idx = 0; idx < elementCnt; idx++)
3377    {
3378       controlRSetList->list.array[idx] = NULLP;
3379       DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3380       if(!controlRSetList->list.array[idx])
3381       {
3382          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3383          return RFAILED;
3384       }
3385    }
3386
3387    idx=0;
3388    controlRSet = controlRSetList->list.array[idx];
3389
3390    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3391
3392    /* size 6 bytes
3393     * 3 LSBs unsued
3394     * Bit string stored ff0000000000
3395     */
3396    numBytes = 6;
3397    bitsUnused = 3;
3398    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3399
3400    controlRSet->frequencyDomainResources.buf = NULLP;
3401    DU_ALLOC(controlRSet->frequencyDomainResources.buf, \
3402          controlRSet->frequencyDomainResources.size);
3403    if(!controlRSet->frequencyDomainResources.buf)
3404    {
3405       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3406       return RFAILED;
3407    }
3408
3409    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3410    coreset0EndPrb = CORESET0_END_PRB;
3411    coreset1StartPrb = coreset0EndPrb + 6;
3412    coreset1NumPrb = CORESET1_NUM_PRB;
3413    /* calculate the PRBs */
3414    freqDomRscAllocType0(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3415    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3416    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3417
3418    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3419    controlRSet->cce_REG_MappingType.present = \
3420                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3421
3422    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3423    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3424    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3425    controlRSet->tci_PresentInDCI = NULLP;
3426 #if 0
3427    uint8_t tciStateIdx;
3428
3429    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3430          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3431    if(!controlRset->tci_StatesPDCCH_ToAddList)
3432    {
3433       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3434       return RFAILED;
3435    }
3436
3437    elementCnt = 1;
3438    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3439    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3440    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3441          controlRset->tci_StatesPDCCH_ToAddList->list.size)
3442       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3443       {
3444          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3445          return RFAILED;
3446       }
3447
3448    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3449    {
3450       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3451       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3452       {
3453          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3454          return RFAILED;
3455       }
3456    }
3457
3458    tciStateIdx = 0;
3459    /* TODO */
3460    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3461
3462    DU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3463    if(!controlRset->tci_PresentInDCI)
3464    {
3465       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3466       return RFAILED;
3467    }
3468    /* TODO */
3469    *(controlRset->tci_PresentInDCI);
3470 #endif
3471
3472    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3473    DU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3474    if(!controlRSet->pdcch_DMRS_ScramblingID)
3475    {
3476       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3477       return RFAILED;
3478    }
3479    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3480
3481    return ROK;
3482 } /* End BuildControlRSetToAddModList */
3483
3484 /*******************************************************************
3485  *
3486  * @brief Build search space to add/modify list
3487  *
3488  * @details
3489  *
3490  *    Function : BuildSearchSpcToAddModList
3491  *
3492  *    Functionality: Build search space to add/modify list
3493  *
3494  * @params[in]
3495  * @return ROK     - success
3496  *         RFAILED - failure
3497  *
3498  * ****************************************************************/
3499    uint8_t BuildSearchSpcToAddModList
3500 (
3501  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
3502  )
3503 {
3504    uint8_t idx;
3505    uint8_t numBytes;
3506    uint8_t byteIdx;
3507    uint8_t bitsUnused;
3508    uint8_t elementCnt;
3509    struct SearchSpace *searchSpc;
3510
3511    elementCnt = 1;
3512    searchSpcList->list.count = elementCnt;
3513    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3514
3515    searchSpcList->list.array = NULLP;
3516    DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3517    if(!searchSpcList->list.array)
3518    {
3519       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3520       return RFAILED;
3521    }
3522
3523    for(idx = 0; idx < elementCnt; idx++)
3524    {
3525       searchSpcList->list.array[idx] = NULLP;
3526       DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3527       if(!searchSpcList->list.array[idx])
3528       {
3529          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3530          return RFAILED;
3531       }
3532    }
3533
3534    idx = 0;
3535    searchSpc = searchSpcList->list.array[idx];
3536
3537    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3538
3539    searchSpc->controlResourceSetId = NULLP;
3540    DU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3541    if(!searchSpc->controlResourceSetId)
3542    {
3543       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3544       return RFAILED;
3545    }
3546    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3547
3548    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3549    DU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
3550          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3551    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3552    {
3553       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3554       return RFAILED;
3555    }
3556    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
3557                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3558
3559    searchSpc->duration = NULLP;
3560    searchSpc->monitoringSymbolsWithinSlot = NULLP;
3561    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3562    if(!searchSpc->monitoringSymbolsWithinSlot)
3563    {
3564       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3565       return RFAILED;
3566    }
3567
3568    /* Values taken from reference logs :
3569     * size 2 bytes
3570     * 2 LSBs unsued
3571     * Bit string stores 8000
3572     */
3573    numBytes = 2;
3574    bitsUnused = 2;
3575
3576    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3577    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3578    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
3579          searchSpc->monitoringSymbolsWithinSlot->size);
3580    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3581    {
3582       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3583       return RFAILED;
3584    }
3585
3586    byteIdx = 0;
3587    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
3588                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3589    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3590    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3591
3592    searchSpc->nrofCandidates = NULLP;
3593    DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3594    if(!searchSpc->nrofCandidates)
3595    {
3596       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3597       return RFAILED;
3598    }
3599
3600    searchSpc->nrofCandidates->aggregationLevel1 = \
3601                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3602    searchSpc->nrofCandidates->aggregationLevel2 = \
3603                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3604    searchSpc->nrofCandidates->aggregationLevel4 = \
3605                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3606    searchSpc->nrofCandidates->aggregationLevel8 = \
3607                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3608    searchSpc->nrofCandidates->aggregationLevel16 = \
3609                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3610
3611    searchSpc->searchSpaceType = NULLP;
3612    DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3613    if(!searchSpc->searchSpaceType)
3614    {
3615       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3616       return RFAILED;
3617    }
3618
3619    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3620
3621    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3622    DU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
3623          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3624    if(!searchSpc->searchSpaceType->choice.ue_Specific)
3625    {
3626       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3627       return RFAILED;
3628    }
3629    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
3630                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3631
3632    return ROK;
3633 }/* End BuildSearchSpcToAddModList */
3634
3635 /*******************************************************************
3636  *
3637  * @brief Builds BWP DL dedicated PDCCH config
3638  *
3639  * @details
3640  *
3641  *    Function : BuildBWPDlDedPdcchCfg
3642  *
3643  *    Functionality: Builds BWP DL dedicated PDCCH config
3644  *
3645  * @params[in] struct PDCCH_Config *pdcchCfg
3646  *
3647  * @return ROK     - success
3648  *         RFAILED - failure
3649  *
3650  * ****************************************************************/
3651 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
3652 {
3653    pdcchCfg->controlResourceSetToAddModList = NULLP;
3654    DU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
3655          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3656    if(!pdcchCfg->controlResourceSetToAddModList)
3657    {
3658       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3659       return RFAILED;
3660    }
3661
3662    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
3663    {
3664       return RFAILED;
3665    }
3666
3667    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3668
3669    pdcchCfg->searchSpacesToAddModList = NULLP;
3670    DU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3671          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3672    if(!pdcchCfg->searchSpacesToAddModList)
3673    {
3674       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3675       return RFAILED;
3676    }
3677
3678    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3679    {
3680       return RFAILED;
3681    }
3682
3683    pdcchCfg->searchSpacesToReleaseList = NULLP;
3684    pdcchCfg->downlinkPreemption = NULLP;
3685    pdcchCfg->tpc_PUSCH = NULLP;
3686    pdcchCfg->tpc_PUCCH = NULLP;
3687    pdcchCfg->tpc_SRS = NULLP;
3688
3689    return ROK;
3690 }
3691
3692 /*******************************************************************
3693  *
3694  * @brief Builds DMRS DL PDSCH Mapping type A
3695  *
3696  * @details
3697  *
3698  *    Function : BuildDMRSDLPdschMapTypeA
3699  *
3700  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3701  *
3702  * @params[in]
3703  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3704  * @return ROK     - success
3705  *         RFAILED - failure
3706  *
3707  * ****************************************************************/
3708    uint8_t BuildDMRSDLPdschMapTypeA
3709 (
3710  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3711  )
3712 {
3713    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3714    dmrsDlCfg->choice.setup = NULLP;
3715    DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3716    if(!dmrsDlCfg->choice.setup)
3717    {
3718       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3719       return RFAILED;
3720    }
3721
3722    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3723    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3724    DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3725    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3726    {
3727       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3728       return RFAILED;
3729    }
3730    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3731
3732    dmrsDlCfg->choice.setup->maxLength = NULLP;
3733    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3734    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3735    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3736
3737    return ROK;
3738 }
3739
3740 /*******************************************************************
3741  *
3742  * @brief Builds TCI states to add/modify list
3743  *
3744  * @details
3745  *
3746  *    Function : BuildTCIStatesToAddModList
3747  *
3748  *    Functionality:Builds TCI states to add/modify list
3749  *
3750  * @params[in]
3751  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3752  *
3753  * @return ROK     - success
3754  *         RFAILED - failure
3755  *
3756  * ****************************************************************/
3757 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3758 {
3759    return ROK;
3760 }
3761
3762 /*******************************************************************
3763  *
3764  * @brief Builds PDSCH time domain allocation list
3765  *
3766  * @details
3767  *
3768  *    Function : BuildPdschTimeDomAllocList
3769  *
3770  *    Functionality: Builds PDSCH time domain allocation list
3771  *
3772  * @params[in]
3773  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3774  *
3775  * @return ROK     - success
3776  *         RFAILED - failure
3777  *
3778  * ****************************************************************/
3779    uint8_t BuildPdschTimeDomAllocList
3780 (
3781  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3782  )
3783 {
3784    uint8_t idx;
3785    uint8_t elementCnt;
3786    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3787
3788    timeDomAllocList->present = \
3789                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3790
3791    timeDomAllocList->choice.setup = NULLP;
3792    DU_ALLOC(timeDomAllocList->choice.setup, \
3793          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3794    if(!timeDomAllocList->choice.setup)
3795    {
3796       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3797       return RFAILED;
3798    }
3799
3800    elementCnt = 2;
3801    timeDomAllocList->choice.setup->list.count = elementCnt;
3802    timeDomAllocList->choice.setup->list.size = \
3803                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3804
3805    timeDomAllocList->choice.setup->list.array = NULLP;
3806    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3807          timeDomAllocList->choice.setup->list.size);
3808    if(!timeDomAllocList->choice.setup->list.array)
3809    {
3810       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3811       return RFAILED;
3812    }
3813
3814    for(idx = 0; idx < elementCnt; idx++)
3815    {
3816       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3817       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3818             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3819       if(!timeDomAllocList->choice.setup->list.array[idx])
3820       {
3821          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3822          return RFAILED;
3823       }
3824    }
3825
3826    idx = 0;
3827    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3828    DU_ALLOC(timeDomAlloc->k0, sizeof(long));
3829    if(!timeDomAlloc->k0)
3830    {
3831       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3832       return RFAILED;
3833    }
3834    *(timeDomAlloc->k0) = 0;
3835    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3836    timeDomAlloc->startSymbolAndLength = \
3837                                         calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
3838
3839    idx++;
3840    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3841    DU_ALLOC(timeDomAlloc->k0, sizeof(long));
3842    if(!timeDomAlloc->k0)
3843    {
3844       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3845       return RFAILED;
3846    }
3847    *(timeDomAlloc->k0) = 1;
3848    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3849    timeDomAlloc->startSymbolAndLength = calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
3850
3851    return ROK;
3852 }
3853
3854 /*******************************************************************
3855  *
3856  * @brief Builds PDSCH PRB Bundling type
3857  *
3858  * @details
3859  *
3860  *    Function : BuildPdschPrbBundlingType
3861  *
3862  *    Functionality: Builds PDSCH PRB Bundling type
3863  *
3864  * @params[in]
3865  * struct PDSCH_Config__prb_BundlingType *prbBndlType
3866  *
3867  * @return ROK     - success
3868  *         RFAILED - failure
3869  *
3870  * ****************************************************************/
3871    uint8_t BuildPdschPrbBundlingType
3872 (
3873  struct PDSCH_Config__prb_BundlingType *prbBndlType
3874  )
3875 {
3876    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
3877
3878    prbBndlType->choice.staticBundling = NULLP;
3879    DU_ALLOC(prbBndlType->choice.staticBundling, \
3880          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
3881    if(!prbBndlType->choice.staticBundling)
3882    {
3883       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
3884       return RFAILED;
3885    }
3886    prbBndlType->choice.staticBundling->bundleSize = NULLP;
3887
3888    return ROK;
3889 }
3890
3891 /*******************************************************************
3892  *
3893  * @brief Builds BWP DL dedicated PDSCH config
3894  *
3895  * @details
3896  *
3897  *    Function : BuildBWPDlDedPdschCfg
3898  *
3899  *    Functionality: Builds BWP DL dedicated PDSCH config
3900  *
3901  * @params[in] struct PDSCH_Config *pdschCfg
3902  *
3903  * @return ROK     - success
3904  *         RFAILED - failure
3905  *
3906  * ****************************************************************/
3907 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
3908 {
3909    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
3910
3911    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
3912    DU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
3913          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
3914    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
3915    {
3916       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3917       return RFAILED;
3918    }
3919
3920    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
3921    {
3922       return RFAILED;
3923    }
3924
3925    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
3926    pdschCfg->tci_StatesToAddModList = NULLP;
3927    pdschCfg->tci_StatesToReleaseList = NULLP;
3928    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
3929 #if 0
3930    DU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
3931    if(!pdschCfg->tci_StatesToAddModList)
3932    {
3933       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3934       return RFAILED;
3935    }
3936    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
3937    {
3938       return RFAILED;
3939    }
3940 #endif
3941
3942    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
3943
3944    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
3945    DU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
3946          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
3947    if(!pdschCfg->pdsch_TimeDomainAllocationList)
3948    {
3949       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3950       return RFAILED;
3951    }
3952
3953    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
3954    {
3955       return RFAILED;
3956    }
3957
3958    pdschCfg->pdsch_AggregationFactor = NULLP;
3959    pdschCfg->rateMatchPatternToAddModList = NULLP;
3960    pdschCfg->rateMatchPatternToReleaseList = NULLP;
3961    pdschCfg->rateMatchPatternGroup1 = NULLP;
3962    pdschCfg->rateMatchPatternGroup2 = NULLP;
3963    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
3964    pdschCfg->mcs_Table = NULLP;
3965
3966    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
3967    DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
3968    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
3969    {
3970       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3971       return RFAILED;
3972    }
3973    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
3974
3975    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
3976    {
3977       return RFAILED;
3978    }
3979
3980    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
3981    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
3982    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3983    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3984    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3985    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3986    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
3987
3988    return ROK;
3989 }
3990
3991 /*******************************************************************
3992  *
3993  * @brief Builds intitial DL BWP
3994  * @details
3995  *
3996  *    Function : BuildInitialDlBWP
3997  *
3998  *    Functionality: Builds intitial DL BWP in spCellCfgDed
3999  *
4000  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4001  *
4002  * @return ROK     - success
4003  *         RFAILED - failure
4004  *
4005  * ****************************************************************/
4006 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
4007 {
4008    dlBwp->pdcch_Config = NULLP;
4009    DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
4010    if(!dlBwp->pdcch_Config)
4011    {
4012       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4013       return RFAILED;
4014    }
4015    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
4016
4017    dlBwp->pdcch_Config->choice.setup = NULLP;
4018    DU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
4019    if(!dlBwp->pdcch_Config->choice.setup)
4020    {
4021       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4022       return RFAILED;
4023    }
4024    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
4025    {
4026       return RFAILED;
4027    }
4028
4029    dlBwp->pdsch_Config = NULLP;
4030    DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
4031    if(!dlBwp->pdsch_Config)
4032    {
4033       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4034       return RFAILED;
4035    }
4036    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
4037
4038    dlBwp->pdsch_Config->choice.setup = NULLP;
4039    DU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
4040    if(!dlBwp->pdsch_Config->choice.setup)
4041    {
4042       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4043       return RFAILED;
4044    }
4045
4046    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
4047    {
4048       return RFAILED;
4049    }
4050
4051    dlBwp->sps_Config = NULLP;
4052    dlBwp->radioLinkMonitoringConfig = NULLP;
4053    return ROK;
4054 }
4055
4056 /*******************************************************************
4057  *
4058  * @brief Builds DMRS UL Pusch Mapping type A
4059  *
4060  * @details
4061  *
4062  *    Function : BuildDMRSULPuschMapTypeA
4063  *
4064  *    Functionality: Builds DMRS UL Pusch Mapping type A
4065  *
4066  * @params[in]
4067  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4068  * @return ROK     - success
4069  *         RFAILED - failure
4070  *
4071  * ****************************************************************/
4072    uint8_t BuildDMRSULPuschMapTypeA
4073 (
4074  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4075  )
4076 {
4077    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
4078    dmrsUlCfg->choice.setup= NULLP;
4079    DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
4080    if(!dmrsUlCfg->choice.setup)
4081    {
4082       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4083       return RFAILED;
4084    }
4085
4086    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
4087    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
4088    DU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
4089    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4090    {
4091       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4092       return RFAILED;
4093    }
4094    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
4095
4096    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
4097    dmrsUlCfg->choice.setup->maxLength = NULLP;
4098    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
4099    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
4100          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4101    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4102    {
4103       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4104       return RFAILED;
4105    }
4106
4107    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
4108    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4109          sizeof(long));
4110    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
4111    {
4112       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4113       return RFAILED;
4114    }
4115    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
4116
4117    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
4118    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
4119    return ROK;
4120 }
4121
4122 /*******************************************************************
4123  *
4124  * @brief Build PUSCH time domain allocation list
4125  *
4126  * @details
4127  *
4128  *    Function : BuildPuschTimeDomAllocList
4129  *
4130  *    Functionality: Build PUSCH time domain allocation list
4131  *
4132  * @params[in]
4133  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4134  *
4135  * @return ROK     - success
4136  *         RFAILED - failure
4137  *
4138  * ****************************************************************/
4139    uint8_t BuildPuschTimeDomAllocList
4140 (
4141  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4142  )
4143 {
4144    uint8_t idx;
4145    uint8_t elementCnt;
4146    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
4147
4148    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
4149    timeDomAllocList->choice.setup = NULLP;
4150    DU_ALLOC(timeDomAllocList->choice.setup, \
4151          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4152    if(!timeDomAllocList->choice.setup)
4153    {
4154       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4155       return RFAILED;
4156    }
4157
4158    elementCnt = 2;
4159    timeDomAllocList->choice.setup->list.count = elementCnt;
4160    timeDomAllocList->choice.setup->list.size = \
4161                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
4162    timeDomAllocList->choice.setup->list.array = NULLP;
4163    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
4164          timeDomAllocList->choice.setup->list.size);
4165    if(!timeDomAllocList->choice.setup->list.array)
4166    {
4167       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4168       return RFAILED;
4169    }
4170
4171    for(idx = 0; idx < elementCnt; idx++)
4172    {
4173       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4174       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
4175             sizeof(PUSCH_TimeDomainResourceAllocation_t));
4176       if(!timeDomAllocList->choice.setup->list.array[idx])
4177       {
4178          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4179          return RFAILED;
4180       }
4181    }
4182
4183    idx = 0;
4184    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4185    DU_ALLOC(timeDomAlloc->k2, sizeof(long));
4186    if(!timeDomAlloc->k2)
4187    {
4188       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4189       return RFAILED;
4190    }
4191    *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
4192    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4193    timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
4194
4195    idx++;
4196    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4197    DU_ALLOC(timeDomAlloc->k2, sizeof(long));
4198    if(!timeDomAlloc->k2)
4199    {
4200       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4201       return RFAILED;
4202    }
4203    *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
4204    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4205    timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
4206
4207    return ROK;
4208 }
4209
4210 /*******************************************************************
4211  *
4212  * @brief Builds BWP UL dedicated PUSCH Config
4213  *
4214  * @details
4215  *
4216  *    Function : BuildBWPUlDedPuschCfg
4217  *
4218  *    Functionality:
4219  *      Builds BWP UL dedicated PUSCH Config
4220  *
4221  * @params[in] : PUSCH_Config_t *puschCfg
4222  *
4223  * @return ROK     - success
4224  *         RFAILED - failure
4225  *
4226  * ****************************************************************/
4227 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
4228 {
4229    puschCfg->dataScramblingIdentityPUSCH = NULLP;
4230    DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4231    if(!puschCfg->dataScramblingIdentityPUSCH)
4232    {
4233       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4234       return RFAILED;
4235    }
4236    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
4237
4238    puschCfg->txConfig = NULLP;
4239    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4240    DU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4241          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4242    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4243    {
4244       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4245       return RFAILED;
4246    }
4247
4248    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4249    {
4250       return RFAILED;
4251    }
4252
4253    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4254    puschCfg->pusch_PowerControl = NULLP;
4255    puschCfg->frequencyHopping = NULLP;
4256    puschCfg->frequencyHoppingOffsetLists = NULLP;
4257    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4258
4259    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4260    DU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
4261          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4262    if(!puschCfg->pusch_TimeDomainAllocationList)
4263    {
4264       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4265       return RFAILED;
4266    }
4267
4268    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
4269    {
4270       return RFAILED;
4271    }
4272
4273    puschCfg->pusch_AggregationFactor = NULLP;
4274    puschCfg->mcs_Table = NULLP;
4275    puschCfg->mcs_TableTransformPrecoder = NULLP;
4276    puschCfg->transformPrecoder = NULLP;
4277    DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4278    if(!puschCfg->transformPrecoder)
4279    {
4280       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4281       return RFAILED;
4282    }
4283    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4284
4285    puschCfg->codebookSubset = NULLP;
4286    puschCfg->maxRank = NULLP;
4287    puschCfg->rbg_Size = NULLP;
4288    puschCfg->uci_OnPUSCH = NULLP;
4289    puschCfg->tp_pi2BPSK = NULLP;
4290
4291    return ROK;
4292 }
4293
4294 /*******************************************************************
4295  *
4296  * @brief Builds BWP UL dedicated PUCCH Config
4297  *
4298  * @details
4299  *
4300  *    Function : BuildBWPUlDedPucchCfg
4301  *
4302  *    Functionality:
4303  *      Builds BWP UL dedicated PUCCH Config
4304  *
4305  * @params[in] : PUCCH_Config_t *pucchCfg
4306  *
4307  * @return ROK     - success
4308  *         RFAILED - failure
4309  *
4310  * ****************************************************************/
4311 uint8_t BuildBWPUlDedPucchCfg(PUCCH_Config_t *pucchCfg)
4312 {
4313    uint8_t arrIdx, elementCnt;
4314
4315    DU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
4316    if(pucchCfg->dl_DataToUL_ACK == NULLP)
4317    {
4318       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4319       return RFAILED;
4320    }
4321
4322    elementCnt = 2;
4323    pucchCfg->dl_DataToUL_ACK->list.count = elementCnt;
4324    pucchCfg->dl_DataToUL_ACK->list.size = elementCnt * sizeof(long *);
4325    DU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
4326    if(pucchCfg->dl_DataToUL_ACK->list.array == NULLP)
4327    {
4328       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4329       return RFAILED;
4330    }
4331
4332    for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
4333    {
4334       DU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
4335       if(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx] == NULLP)
4336       {
4337           DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4338           return RFAILED;
4339       }
4340    }
4341
4342    arrIdx = 0;
4343    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx++]) = 1;
4344    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx]) = 2;
4345    return ROK;
4346 }
4347
4348 /*******************************************************************
4349  *
4350  * @brief Fills SRS resource to add/modify list
4351  *
4352  * @details
4353  *
4354  *    Function : BuildSrsRsrcAddModList
4355  *
4356  *    Functionality: Fills SRS resource to add/modify list
4357  *
4358  * @params[in]
4359  * @return ROK     - success
4360  *         RFAILED - failure
4361  *
4362  * ****************************************************************/
4363 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
4364 {
4365    uint8_t   elementCnt;
4366    uint8_t   rsrcIdx;
4367
4368    elementCnt = 1;
4369    resourceList->list.count = elementCnt;
4370    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
4371    resourceList->list.array = NULLP;
4372    DU_ALLOC(resourceList->list.array, resourceList->list.size);
4373    if(!resourceList->list.array)
4374    {
4375       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4376       return RFAILED;
4377    }
4378
4379    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4380    {
4381       DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4382       if(!resourceList->list.array[rsrcIdx])
4383       {
4384          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4385          return RFAILED;
4386       }
4387    }
4388
4389    rsrcIdx = 0;
4390    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
4391    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
4392    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
4393
4394    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
4395    DU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
4396          sizeof(struct SRS_Resource__transmissionComb__n2));
4397    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
4398    {
4399       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4400       return RFAILED;
4401    }
4402    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
4403       = SRS_COMB_OFFSET_N2;
4404    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
4405       = SRS_CYCLIC_SHIFT_N2;
4406
4407    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
4408                                                                       PUSCH_START_SYMBOL;
4409    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
4410                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
4411    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
4412                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
4413
4414    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
4415    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
4416    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
4417    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
4418    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
4419    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
4420                                                                SRS_Resource__groupOrSequenceHopping_neither;
4421
4422    /* Setting resource type to aperiodic for intergration purposes */
4423    resourceList->list.array[rsrcIdx]->resourceType.present = \
4424                                                              SRS_Resource__resourceType_PR_aperiodic;
4425    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
4426    DU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
4427          sizeof(struct SRS_Resource__resourceType__aperiodic));
4428    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
4429    {
4430       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4431       return RFAILED;
4432    }
4433    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
4434
4435    return ROK;
4436 }
4437
4438 /*******************************************************************
4439  *
4440  * @brief Build SRS resource set Add/mod list
4441  *
4442  * @details
4443  *
4444  *    Function : BuildSrsRsrcSetAddModList
4445  *
4446  *    Functionality: Build SRS resource set Add/mod list
4447  *
4448  * @params[in]
4449  * @return ROK     - success
4450  *         RFAILED - failure
4451  *
4452  * ****************************************************************/
4453    uint8_t BuildSrsRsrcSetAddModList
4454 (
4455  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
4456  )
4457 {
4458    uint8_t  elementCnt;
4459    uint8_t  rSetIdx;
4460    uint8_t  rsrcIdx;
4461    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
4462
4463    elementCnt = 1;
4464    rsrcSetList->list.count = elementCnt;
4465    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
4466    rsrcSetList->list.array = NULLP;
4467    DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
4468    if(!rsrcSetList->list.array)
4469    {
4470       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4471       return RFAILED;
4472    }
4473
4474    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4475    {
4476       DU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4477       if(!rsrcSetList->list.array[rSetIdx])
4478       {
4479          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4480          return RFAILED;
4481       }
4482    }
4483
4484    rSetIdx = 0;
4485    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
4486
4487    /* Fill Resource Id list in resource set */
4488    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
4489    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4490          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4491    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4492    {
4493       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4494       return RFAILED;
4495    }
4496
4497    elementCnt = 1;
4498    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4499    rsrcIdList->list.count = elementCnt;
4500    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
4501    rsrcIdList->list.array = NULLP;
4502    DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
4503    if(!rsrcIdList->list.array)
4504    {
4505       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4506       return RFAILED;
4507    }
4508
4509    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4510    {
4511       DU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4512       if(!rsrcIdList->list.array[rsrcIdx])
4513       {
4514          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4515          return RFAILED;
4516       }
4517    }
4518
4519    rsrcIdx = 0;
4520    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
4521
4522    /* Fill resource type */
4523    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
4524                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
4525
4526    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
4527    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4528          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4529    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
4530    {
4531       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4532       return RFAILED;
4533    }
4534    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
4535       = APERIODIC_SRS_RESRC_TRIGGER;
4536
4537    /* TODO : Fill values for below IEs as expected by Viavi */
4538    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
4539    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
4540
4541
4542    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
4543    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
4544    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
4545    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
4546    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
4547
4548    return ROK;
4549 }
4550
4551 /*******************************************************************
4552  *
4553  * @brief Builds BWP UL dedicated SRS Config
4554  *
4555  * @details
4556  *
4557  *    Function : BuildBWPUlDedSrsCfg
4558  *
4559  *    Functionality: Builds BWP UL dedicated SRS Config
4560  *
4561  * @params[in] SRS Config
4562  * @return ROK     - success
4563  *         RFAILED - failure
4564  *
4565  * ****************************************************************/
4566 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
4567 {
4568    srsCfg->srs_ResourceSetToReleaseList = NULLP;
4569    srsCfg->srs_ResourceSetToAddModList = NULLP;
4570    DU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
4571          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4572    if(!srsCfg->srs_ResourceSetToAddModList)
4573    {
4574       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4575       return RFAILED;
4576    }
4577    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
4578    {
4579       return RFAILED;
4580    }
4581
4582    srsCfg->srs_ResourceToReleaseList = NULLP;
4583
4584    /* Resource to Add/Modify list */
4585    srsCfg->srs_ResourceToAddModList = NULLP;
4586    DU_ALLOC(srsCfg->srs_ResourceToAddModList, \
4587          sizeof(struct SRS_Config__srs_ResourceToAddModList));
4588    if(!srsCfg->srs_ResourceToAddModList)
4589    {
4590       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4591       return RFAILED;
4592    }
4593
4594    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
4595    {
4596       return RFAILED;
4597    }
4598
4599    srsCfg->tpc_Accumulation = NULLP;
4600
4601    return ROK;
4602 }
4603
4604
4605
4606 /*******************************************************************
4607  *
4608  * @brief Builds Pusch Serving cell Config
4609  *
4610  * @details
4611  *
4612  *    Function : BuildPuschSrvCellCfg
4613  *
4614  *    Functionality: Builds Pusch Serving cell Config
4615  *
4616  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
4617  *
4618  * @return ROK     - success
4619  *         RFAILED - failure
4620  *
4621  * ****************************************************************/
4622 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
4623 {
4624    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
4625    puschCfg->choice.setup = NULLP;
4626    DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4627    if(!puschCfg->choice.setup)
4628    {
4629       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4630       return RFAILED;
4631    }
4632
4633    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4634    puschCfg->choice.setup->rateMatching = NULLP;
4635    puschCfg->choice.setup->xOverhead = NULLP;
4636    puschCfg->choice.setup->ext1 = NULLP;
4637    DU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
4638    if(!puschCfg->choice.setup->ext1)
4639    {
4640       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4641       return RFAILED;
4642    }
4643
4644    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
4645    DU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
4646    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
4647    {
4648       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4649       return RFAILED;
4650    }
4651    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
4652
4653    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
4654    DU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
4655    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
4656    {
4657       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4658       return RFAILED;
4659    }
4660    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
4661    return ROK;
4662 }
4663
4664 /*******************************************************************
4665  *
4666  * @brief Builds inital UL BWP
4667  *
4668  * @details
4669  *
4670  *    Function : BuildInitialUlBWP
4671  *
4672  *    Functionality: Builds initial UL BWP
4673  *
4674  * @params[in] BWP_UplinkDedicated_t *ulBwp
4675  * @return ROK     - success
4676  *         RFAILED - failure
4677  *
4678  * ****************************************************************/
4679 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4680 {
4681    ulBwp->pucch_Config = NULLP;
4682    DU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
4683    if(!ulBwp->pucch_Config)
4684    {
4685       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4686       return RFAILED;
4687    }
4688
4689    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
4690    ulBwp->pucch_Config->choice.setup = NULLP;
4691    DU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
4692    if(!ulBwp->pucch_Config->choice.setup)
4693    {
4694       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4695       return RFAILED;
4696    }
4697
4698    if(BuildBWPUlDedPucchCfg(ulBwp->pucch_Config->choice.setup) != ROK)
4699    {
4700       return RFAILED;
4701    }
4702
4703    /* Fill BWP UL dedicated PUSCH config */
4704    ulBwp->pusch_Config = NULLP;
4705    DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4706    if(!ulBwp->pusch_Config)
4707    {
4708       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4709       return RFAILED;
4710    }
4711
4712    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
4713    ulBwp->pusch_Config->choice.setup = NULLP;
4714    DU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4715    if(!ulBwp->pusch_Config->choice.setup)
4716    {
4717       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4718       return RFAILED;
4719    }
4720
4721    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
4722    {
4723       return RFAILED;
4724    }
4725
4726    ulBwp->configuredGrantConfig = NULLP;
4727
4728    /* Fill BPW UL dedicated SRS config */
4729    ulBwp->srs_Config = NULLP;
4730    DU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4731    if(!ulBwp->srs_Config)
4732    {
4733       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4734       return RFAILED;
4735    }
4736
4737    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
4738    ulBwp->srs_Config->choice.setup = NULLP;
4739    DU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4740    if(!ulBwp->srs_Config->choice.setup)
4741    {
4742       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4743       return RFAILED;
4744    }
4745
4746    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
4747    {
4748       return RFAILED;
4749    }
4750
4751    ulBwp->beamFailureRecoveryConfig = NULLP;
4752
4753    return ROK;
4754 }
4755
4756 /*******************************************************************
4757  *
4758  * @brief Builds UL config
4759  * @details
4760  *
4761  *    Function : BuildUlCfg
4762  *
4763  *    Functionality: Builds UL config in spCellCfgDed
4764  *
4765  * @params[in] UplinkConfig_t *ulCfg
4766  *
4767  * @return ROK     - success
4768  *         RFAILED - failure
4769  *
4770  * ****************************************************************/
4771 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
4772 {
4773    ulCfg->initialUplinkBWP = NULLP;
4774    DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4775    if(!ulCfg->initialUplinkBWP)
4776    {
4777       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4778       return RFAILED;
4779    }
4780
4781    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
4782    {
4783       return RFAILED;
4784    }
4785
4786    ulCfg->uplinkBWP_ToReleaseList = NULLP;
4787    ulCfg->uplinkBWP_ToAddModList = NULLP;
4788    ulCfg->firstActiveUplinkBWP_Id = NULLP;
4789    DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4790    if(!ulCfg->firstActiveUplinkBWP_Id)
4791    {
4792       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4793       return RFAILED;
4794    }
4795    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
4796
4797    ulCfg->pusch_ServingCellConfig = NULLP;
4798    DU_ALLOC(ulCfg->pusch_ServingCellConfig, \
4799          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4800    if(!ulCfg->pusch_ServingCellConfig)
4801    {
4802       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4803       return RFAILED;
4804    }
4805
4806    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
4807    {
4808       return RFAILED;
4809    }
4810
4811    ulCfg->carrierSwitching = NULLP;
4812    ulCfg->ext1 = NULLP;
4813    return ROK;
4814 }
4815
4816 /*******************************************************************
4817  *
4818  * @brief Builds PDSCH serving cell config
4819  * @details
4820  *
4821  *    Function : BuildPdschSrvCellCfg
4822  *
4823  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
4824  *
4825  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
4826  *
4827  * @return ROK     - success
4828  *         RFAILED - failure
4829  *
4830  * ****************************************************************/
4831 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
4832 {
4833    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
4834    pdschCfg->choice.setup = NULLP;
4835    DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
4836    if(!pdschCfg->choice.setup)
4837    {
4838       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4839       return RFAILED;
4840    }
4841
4842    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4843    pdschCfg->choice.setup->xOverhead = NULLP;
4844    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
4845    DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
4846    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
4847    {
4848       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4849       return RFAILED;
4850    }
4851    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
4852    pdschCfg->choice.setup->pucch_Cell = NULLP;
4853    pdschCfg->choice.setup->ext1 = NULLP;
4854
4855    return ROK;
4856 }
4857
4858 /*******************************************************************
4859  *
4860  * @brief Builds CSI Meas config
4861  * @details
4862  *
4863  *    Function : BuildCsiMeasCfg
4864  *
4865  *    Functionality: Builds CSI Meas config in spCellCfgDed
4866  *
4867  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
4868  *
4869  * @return ROK     - success
4870  *         RFAILED - failure
4871  *
4872  * ****************************************************************/
4873 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
4874 {
4875
4876    return ROK;
4877 }
4878
4879 /*******************************************************************
4880  *
4881  * @brief Builds Spcell config dedicated
4882  * @details
4883  *
4884  *    Function : BuildSpCellCfgDed
4885  *
4886  *    Functionality: Builds sp cell config dedicated in spCellCfg
4887  *
4888  * @params[in] ServingCellConfig_t srvCellCfg
4889  *
4890  * @return ROK     - success
4891  *         RFAILED - failure
4892  *
4893  * ****************************************************************/
4894 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
4895 {
4896    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
4897    DU_ALLOC(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
4898    if(!srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
4899    {
4900       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4901       return RFAILED;
4902    }
4903
4904    srvCellCfg->initialDownlinkBWP = NULLP;
4905    DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
4906    if(!srvCellCfg->initialDownlinkBWP)
4907    {
4908       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4909       return RFAILED;
4910    }
4911
4912    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
4913    {
4914       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
4915       return RFAILED;
4916    }
4917    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
4918    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
4919
4920    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
4921    DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
4922    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
4923    {
4924       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4925       return RFAILED;
4926    }
4927    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4928
4929    srvCellCfg->bwp_InactivityTimer = NULLP;
4930
4931    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
4932    DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
4933    if(!srvCellCfg->defaultDownlinkBWP_Id)
4934    {
4935       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4936       return RFAILED;
4937    }
4938    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4939
4940    srvCellCfg->uplinkConfig = NULLP;
4941    DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
4942    if(!srvCellCfg->uplinkConfig)
4943    {
4944       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4945       return RFAILED;
4946    }
4947
4948    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
4949    {
4950       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
4951       return RFAILED;
4952    }
4953    srvCellCfg->supplementaryUplink = NULLP;
4954    srvCellCfg->pdcch_ServingCellConfig = NULLP;
4955
4956    srvCellCfg->pdsch_ServingCellConfig = NULLP;
4957    DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
4958    if(!srvCellCfg->pdsch_ServingCellConfig)
4959    {
4960       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4961       return RFAILED;
4962    }
4963
4964    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
4965    {
4966       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
4967       return RFAILED;
4968    }
4969
4970    srvCellCfg->csi_MeasConfig = NULLP;
4971 #if 0
4972    DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
4973       if(!srvCellCfg->csi_MeasConfig)
4974       {
4975          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4976          return RFAILED;
4977       }
4978
4979    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
4980    {
4981       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
4982       return RFAILED;
4983    }
4984 #endif
4985    srvCellCfg->sCellDeactivationTimer = NULLP;
4986    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
4987    srvCellCfg->tag_Id = TAG_ID;
4988    srvCellCfg->dummy = NULLP;
4989    srvCellCfg->pathlossReferenceLinking = NULLP;
4990    srvCellCfg->servingCellMO = NULLP;
4991    srvCellCfg->ext1 = NULLP;
4992
4993    return ROK;
4994 }
4995 /*******************************************************************
4996  *
4997  * @brief Builds Spcell config
4998  *
4999  * @details
5000  *
5001  *    Function : BuildSpCellCfg
5002  *
5003  *    Functionality: Builds sp cell config in DuToCuRrcContainer
5004  *
5005  * @params[in] SpCellConfig_t spCellCfg
5006  *
5007  * @return ROK     - success
5008  *         RFAILED - failure
5009  *
5010  * ****************************************************************/
5011 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
5012 {
5013
5014    spCellCfg->servCellIndex = NULLP;
5015    DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
5016    if(!spCellCfg->servCellIndex)
5017    {
5018       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5019       return RFAILED;
5020    }
5021    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
5022
5023    spCellCfg->reconfigurationWithSync = NULLP;
5024    spCellCfg->rlf_TimersAndConstants = NULLP;
5025    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
5026    DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5027    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
5028    {
5029       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5030       return RFAILED;
5031    }
5032    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
5033
5034    spCellCfg->spCellConfigDedicated = NULLP;
5035    DU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5036    if(!spCellCfg->spCellConfigDedicated)
5037    {
5038       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5039       return RFAILED;
5040    }
5041    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
5042    {
5043       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
5044       return RFAILED;
5045    }
5046    return ROK;
5047 }
5048 /*******************************************************************
5049  *
5050  * @brief Builds Phy cell group config
5051  *
5052  * @details
5053  *
5054  *    Function : BuildPhyCellGrpCfg
5055  *
5056  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
5057  *
5058  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
5059  *
5060  * @return ROK     - success
5061  *         RFAILED - failure
5062  *
5063  * ****************************************************************/
5064 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
5065 {
5066    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
5067    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
5068
5069    phyCellGrpCfg->p_NR_FR1 = NULLP;
5070    DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5071    if(!phyCellGrpCfg->p_NR_FR1)
5072    {
5073       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
5074       return RFAILED;
5075    }
5076    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
5077    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
5078    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
5079    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
5080    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
5081    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
5082    phyCellGrpCfg->cs_RNTI = NULLP;
5083    phyCellGrpCfg->ext1 = NULLP;
5084    phyCellGrpCfg->ext2 = NULLP;
5085
5086    return ROK;
5087 }
5088 /*******************************************************************
5089  *
5090  * @brief Builds Mac cell group config
5091  *
5092  * @details
5093  *
5094  *    Function : BuildMacCellGrpCfg
5095  *
5096  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
5097  *
5098  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
5099  *
5100  * @return ROK     - success
5101  *         RFAILED - failure
5102  *
5103  * ****************************************************************/
5104 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
5105 {
5106    macCellGrpCfg->drx_Config = NULLP;
5107    macCellGrpCfg->schedulingRequestConfig = NULLP;
5108    DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5109    if(!macCellGrpCfg->schedulingRequestConfig)
5110    {
5111       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5112       return RFAILED;
5113    }
5114
5115    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
5116    {
5117       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
5118       return RFAILED;
5119    }
5120
5121    macCellGrpCfg->bsr_Config = NULLP;
5122    DU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5123    if(!macCellGrpCfg->bsr_Config)
5124    {
5125       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5126       return RFAILED;
5127    }
5128
5129    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
5130    {
5131       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
5132       return RFAILED;
5133    }
5134
5135    macCellGrpCfg->tag_Config = NULLP;
5136    DU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
5137    if(!macCellGrpCfg->tag_Config)
5138    {
5139       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5140       return RFAILED;
5141    }
5142
5143    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
5144    {
5145       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
5146       return RFAILED;
5147    }
5148
5149    macCellGrpCfg->phr_Config = NULLP;
5150    DU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
5151    if(!macCellGrpCfg->phr_Config)
5152    {
5153       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5154       return RFAILED;
5155    }
5156
5157    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
5158    {
5159       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
5160       return RFAILED;
5161    }
5162
5163    macCellGrpCfg->skipUplinkTxDynamic = false;
5164    macCellGrpCfg->ext1 = NULLP;
5165
5166    return ROK;
5167 }
5168 /*******************************************************************
5169  *
5170  * @brief Frees memeory allocated for SearchSpcToAddModList
5171  *
5172  * @details
5173  *
5174  *    Function : FreeSearchSpcToAddModList
5175  *
5176  *    Functionality: Deallocating memory of SearchSpcToAddModList
5177  *
5178  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
5179  *
5180  * @return void
5181  *
5182  4221 * ****************************************************************/
5183 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
5184 {
5185    uint8_t idx1=0;
5186    uint8_t idx2=0;
5187    struct  SearchSpace *searchSpc=NULLP;
5188
5189    if(searchSpcList->list.array)
5190    {
5191       if(searchSpcList->list.array[idx2])
5192       {
5193          searchSpc = searchSpcList->list.array[idx2];
5194          if(searchSpc->controlResourceSetId)
5195          {
5196             if(searchSpc->monitoringSlotPeriodicityAndOffset)
5197             {
5198                if(searchSpc->monitoringSymbolsWithinSlot)
5199                {
5200                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
5201                   {
5202                      if(searchSpc->nrofCandidates)
5203                      {
5204                         if(searchSpc->searchSpaceType)
5205                         {
5206                            DU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
5207                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
5208                            DU_FREE(searchSpc->searchSpaceType, sizeof(struct
5209                                     SearchSpace__searchSpaceType));
5210                         }
5211                         DU_FREE(searchSpc->nrofCandidates,
5212                               sizeof(struct SearchSpace__nrofCandidates));
5213                      }
5214                      DU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
5215                            searchSpc->monitoringSymbolsWithinSlot->size);
5216                   }
5217                   DU_FREE(searchSpc->monitoringSymbolsWithinSlot,
5218                         sizeof(BIT_STRING_t));
5219                }
5220                DU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
5221                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
5222             }
5223             DU_FREE(searchSpc->controlResourceSetId,
5224                   sizeof(ControlResourceSetId_t));
5225          }
5226       }
5227       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
5228       {
5229          DU_FREE(searchSpcList->list.array[idx1],
5230                sizeof(struct SearchSpace));
5231       }
5232       DU_FREE(searchSpcList->list.array,searchSpcList->list.size);
5233    }
5234 }
5235 /*******************************************************************
5236  *
5237  * @brief Frees memory allocated for PdschTimeDomAllocList
5238  *
5239  * @details
5240  *
5241  *    Function : FreePdschTimeDomAllocList
5242  *
5243  *    Functionality: Deallocating memory of PdschTimeDomAllocList
5244  *
5245  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
5246  *
5247  * @return void
5248  *
5249  * ****************************************************************/
5250 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
5251 {
5252    uint8_t idx1=0;
5253
5254    if(timeDomAllocList->choice.setup)
5255    {
5256       if(timeDomAllocList->choice.setup->list.array)
5257       {
5258          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
5259          {
5260             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1]->k0, sizeof(long));
5261             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
5262                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
5263          }
5264          DU_FREE(timeDomAllocList->choice.setup->list.array, \
5265                timeDomAllocList->choice.setup->list.size);
5266       }
5267       DU_FREE(timeDomAllocList->choice.setup,\
5268             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
5269    }
5270 }
5271 /*******************************************************************
5272  *
5273  * @brief Frees memory allocated for PuschTimeDomAllocList
5274  *
5275  *@details
5276  *
5277  *    Function : FreePuschTimeDomAllocList
5278  *
5279  *    Functionality: Deallocating memory of PuschTimeDomAllocList
5280  *
5281  * @params[in] PUSCH_Config_t *puschCfg
5282  *
5283  * @return void
5284  *
5285  * ****************************************************************/
5286 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
5287 {
5288    uint8_t rsrcListIdx=0;
5289    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
5290
5291    if(puschCfg->pusch_TimeDomainAllocationList)
5292    {
5293       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
5294       if(timeDomAllocList_t->choice.setup)
5295       {
5296          if(timeDomAllocList_t->choice.setup->list.array)
5297          {
5298             for(rsrcListIdx = 0; rsrcListIdx<timeDomAllocList_t->choice.setup->list.count; rsrcListIdx++)
5299             {
5300                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx]->k2, sizeof(long));
5301                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx],\
5302                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
5303             }
5304             DU_FREE(timeDomAllocList_t->choice.setup->list.array, \
5305                   timeDomAllocList_t->choice.setup->list.size);
5306          }
5307          DU_FREE(timeDomAllocList_t->choice.setup, \
5308                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
5309       }
5310       DU_FREE(puschCfg->transformPrecoder, sizeof(long));
5311       DU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
5312             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
5313    }
5314
5315 }
5316 /*******************************************************************
5317  *
5318  * @brief Frees memory allocated for InitialUlBWP
5319  *
5320  * @details
5321  *
5322  *    Function : FreeInitialUlBWP
5323  *
5324  *    Functionality: Deallocating memory of InitialUlBWP
5325  *
5326  * @params[in] BWP_UplinkDedicated_t *ulBwp
5327  *
5328  * @return void
5329  *
5330  * ****************************************************************/
5331 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5332 {
5333    uint8_t  rSetIdx, rsrcIdx, k1Idx;
5334    SRS_Config_t   *srsCfg = NULLP;
5335    PUSCH_Config_t *puschCfg = NULLP;
5336    PUCCH_Config_t *pucchCfg = NULLP;
5337    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
5338    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
5339    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
5340    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
5341
5342    if(ulBwp->pucch_Config)
5343    {
5344       if(ulBwp->pucch_Config->choice.setup)
5345       {
5346           pucchCfg = ulBwp->pucch_Config->choice.setup;
5347           if(pucchCfg->dl_DataToUL_ACK)
5348           {
5349              if(pucchCfg->dl_DataToUL_ACK->list.array)
5350              {
5351                 for(k1Idx = 0; k1Idx < pucchCfg->dl_DataToUL_ACK->list.count; k1Idx++)
5352                 {
5353                    DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[k1Idx], sizeof(long));
5354                 }
5355                 DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
5356              }
5357              DU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
5358           }
5359           DU_FREE(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
5360       }
5361       DU_FREE(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
5362    }
5363
5364    if(ulBwp->pusch_Config)
5365    {
5366       if(ulBwp->pusch_Config->choice.setup)
5367       {
5368          puschCfg=ulBwp->pusch_Config->choice.setup;
5369          if(puschCfg->dataScramblingIdentityPUSCH)
5370          {
5371             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
5372             {
5373                FreePuschTimeDomAllocList(puschCfg);
5374                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
5375                if(dmrsUlCfg->choice.setup)
5376                {
5377                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
5378                   {
5379                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
5380                      {
5381                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
5382                               sizeof(long));
5383                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
5384                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
5385                      }
5386                      DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
5387                            sizeof(long));
5388                   }
5389                   DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
5390                }
5391                DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
5392                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
5393             }
5394             DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
5395          }
5396          DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5397       }
5398       DU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5399
5400       /* Free SRS-Config */
5401       if(ulBwp->srs_Config)
5402       {
5403          if(ulBwp->srs_Config->choice.setup)
5404          {
5405             srsCfg = ulBwp->srs_Config->choice.setup;
5406
5407             /* Free Resource Set to add/mod list */
5408             if(srsCfg->srs_ResourceSetToAddModList)
5409             {
5410                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
5411                if(rsrcSetList->list.array)
5412                {
5413                   rSetIdx = 0;
5414
5415                   /* Free SRS resource Id list in this SRS resource set */
5416                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5417                   {
5418                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5419
5420                      if(rsrcIdList->list.array)
5421                      {
5422                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5423                         {
5424                            DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5425                         }
5426                         DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
5427                      }
5428                      DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5429                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5430                   }
5431
5432                   /* Free resource type info for this SRS resource set */
5433                   DU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5434                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5435
5436                   /* Free memory for each resource set */
5437                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5438                   {
5439                      DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5440                   }
5441                   DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
5442                }
5443                DU_FREE(srsCfg->srs_ResourceSetToAddModList, \
5444                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5445             }
5446
5447             /* Free resource to add/modd list */
5448             if(srsCfg->srs_ResourceToAddModList)
5449             {
5450                resourceList = srsCfg->srs_ResourceToAddModList;
5451                if(resourceList->list.array)
5452                {
5453                   rsrcIdx = 0;
5454                   DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
5455                         sizeof(struct SRS_Resource__transmissionComb__n2));
5456                   DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
5457                         sizeof(struct SRS_Resource__resourceType__aperiodic));
5458
5459                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5460                   {
5461                      DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5462                   }
5463                   DU_FREE(resourceList->list.array, resourceList->list.size);
5464                }
5465                DU_FREE(srsCfg->srs_ResourceToAddModList, \
5466                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
5467             }
5468
5469             DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5470          }
5471          DU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5472       }
5473    }
5474 }
5475 /*******************************************************************
5476  *
5477  * @brief Frees memory allocated for initialUplinkBWP
5478  *
5479  * @details
5480  *
5481  *    Function : FreeinitialUplinkBWP
5482  *
5483  *    Functionality: Deallocating memory of initialUplinkBWP
5484  *
5485  * @params[in] UplinkConfig_t *ulCfg
5486  *
5487  * @return void
5488  *
5489  *
5490  * ****************************************************************/
5491 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
5492 {
5493    BWP_UplinkDedicated_t *ulBwp=NULLP;
5494    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
5495
5496    if(ulCfg->initialUplinkBWP)
5497    {
5498       ulBwp=ulCfg->initialUplinkBWP;
5499       if(ulCfg->firstActiveUplinkBWP_Id)
5500       {
5501          if(ulCfg->pusch_ServingCellConfig)
5502          {
5503             puschCfg=ulCfg->pusch_ServingCellConfig;
5504             if(puschCfg->choice.setup)
5505             {
5506                if(puschCfg->choice.setup->ext1)
5507                {
5508                   DU_FREE(puschCfg->choice.setup->ext1->\
5509                         processingType2Enabled,sizeof(BOOLEAN_t));
5510                   DU_FREE(puschCfg->choice.setup->ext1->\
5511                         maxMIMO_Layers,sizeof(long));
5512                   DU_FREE(puschCfg->choice.setup->ext1, \
5513                         sizeof(struct PUSCH_ServingCellConfig__ext1));
5514                }
5515                DU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5516             }
5517             DU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5518          }
5519          DU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5520       }
5521       FreeInitialUlBWP(ulBwp);
5522       DU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5523    }
5524 }
5525 /*******************************************************************
5526  *
5527  * @brief Frees emmory allocated for BWPDlDedPdschCfg
5528  *
5529  * @details
5530  *
5531  *    Function : FreeBWPDlDedPdschCfg
5532  *
5533  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
5534  *
5535  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5536  *
5537  * @return void
5538  *
5539  *
5540  * ****************************************************************/
5541 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
5542 {
5543    struct PDSCH_Config *pdschCfg=NULLP;
5544    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
5545    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
5546    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
5547
5548    if(dlBwp->pdsch_Config->choice.setup)
5549    {
5550       pdschCfg=dlBwp->pdsch_Config->choice.setup;
5551       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
5552       {
5553          if(pdschCfg->pdsch_TimeDomainAllocationList)
5554          {
5555             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
5556             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
5557             {
5558                prbBndlType=&pdschCfg->prb_BundlingType;
5559                DU_FREE(prbBndlType->choice.staticBundling,\
5560                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
5561                DU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
5562             }
5563             FreePdschTimeDomAllocList(timeDomAllocList);
5564             DU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
5565                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
5566          }
5567          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
5568          if(dmrsDlCfg->choice.setup)
5569          {
5570             DU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
5571                   sizeof(long));
5572             DU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
5573          }
5574          DU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
5575                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
5576       }
5577       DU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
5578    }
5579 }
5580 /*******************************************************************
5581  *
5582  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
5583  *
5584  * @details
5585  *
5586  *    Function : FreeBWPDlDedPdcchCfg
5587  *
5588  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
5589  *
5590  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5591  *
5592  * @return void
5593  *
5594  *
5595  * ****************************************************************/
5596 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
5597 {
5598    uint8_t idx1=0;
5599    uint8_t idx2=0;
5600    struct PDCCH_Config *pdcchCfg=NULLP;
5601    struct ControlResourceSet *controlRSet=NULLP;
5602    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
5603
5604    if(dlBwp->pdcch_Config->choice.setup)
5605    {
5606       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
5607       if(pdcchCfg->controlResourceSetToAddModList)
5608       {
5609          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
5610          if(controlRSetList->list.array)
5611          {
5612             controlRSet = controlRSetList->list.array[idx2];
5613             if(controlRSet)
5614             {
5615                if(controlRSet->frequencyDomainResources.buf)
5616                {
5617                   if(controlRSet->pdcch_DMRS_ScramblingID)
5618                   {
5619                      if(pdcchCfg->searchSpacesToAddModList)
5620                      {
5621                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
5622                         DU_FREE(pdcchCfg->searchSpacesToAddModList, \
5623                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
5624                      }
5625                      DU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
5626                   }
5627                   DU_FREE(controlRSet->frequencyDomainResources.buf, \
5628                         controlRSet->frequencyDomainResources.size);
5629                }
5630             }
5631             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
5632             {
5633                DU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
5634             }
5635             DU_FREE(controlRSetList->list.array, controlRSetList->list.size);
5636          }
5637          DU_FREE(pdcchCfg->controlResourceSetToAddModList, \
5638                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
5639       }
5640       DU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
5641    }
5642 }
5643
5644 /*******************************************************************
5645  *
5646  * @brief Frees emmory allocated for DUToCURRCContainer
5647  *
5648  * @details
5649  *
5650  *    Function : FreeMemDuToCuRrcCont
5651  *
5652  *    Functionality: Deallocating memory of DuToCuRrcContainer
5653  *
5654  * @params[in] DuToCuRRCContainer, DuToCuRRCContainer
5655  *
5656  * @return ROK     - success
5657  *         RFAILED - failure
5658  *
5659  * ****************************************************************/
5660 uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg)
5661 {
5662    uint8_t idx=0;
5663    SpCellConfig_t *spCellCfg=NULLP;
5664    ServingCellConfig_t *srvCellCfg=NULLP;
5665    BWP_DownlinkDedicated_t *dlBwp=NULLP;
5666    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
5667    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
5668    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
5669    struct RLC_Config *rlcConfig=NULLP;
5670    struct LogicalChannelConfig *macLcConfig=NULLP;
5671    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
5672    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
5673    struct TAG_Config *tagConfig=NULLP;
5674    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
5675    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
5676    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
5677
5678    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
5679    if(rlcBearerList)
5680    {
5681       if(rlcBearerList->list.array)
5682       {
5683          for(idx=0; idx<rlcBearerList->list.count; idx++)
5684          {
5685             if(rlcBearerList->list.array[idx])
5686             {
5687                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
5688                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
5689                if(rlcConfig)
5690                {
5691                   if(rlcConfig->choice.am)
5692                   {
5693                      DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5694                      DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5695                      DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
5696                   }
5697                   DU_FREE(rlcConfig, sizeof(struct RLC_Config));
5698                }
5699                DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
5700                if(macLcConfig)
5701                {
5702                   if(macLcConfig->ul_SpecificParameters)
5703                   {
5704                      DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
5705                      DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
5706                      DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
5707                   }
5708                   DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
5709                }
5710                DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
5711             }
5712          }
5713          DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
5714       }
5715       DU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5716    }
5717
5718    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
5719    if(macCellGrpCfg)
5720    {
5721       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
5722       if(schedulingRequestConfig)
5723       {
5724          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
5725          if(schReqList)
5726          {
5727             if(schReqList->list.array)
5728             {
5729                for(idx=0;idx<schReqList->list.count; idx++)
5730                {
5731                   if(schReqList->list.array[idx])
5732                   {
5733                      DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
5734                      DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
5735                   }
5736                }
5737                DU_FREE(schReqList->list.array, schReqList->list.size);
5738             }
5739             DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
5740                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
5741             DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5742       }
5743       if(macCellGrpCfg->bsr_Config)
5744       {
5745          DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5746       }
5747       tagConfig = macCellGrpCfg->tag_Config;
5748       if(tagConfig)
5749       {
5750          tagList = tagConfig->tag_ToAddModList;
5751          if(tagList)
5752          {
5753             if(tagList->list.array)
5754             {
5755                for(idx=0; idx<tagList->list.count; idx++)
5756                {
5757                   DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
5758                }
5759                DU_FREE(tagList->list.array, tagList->list.size);
5760             }
5761             DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
5762          }
5763          DU_FREE(tagConfig, sizeof(struct TAG_Config));
5764       }
5765
5766       phrConfig = macCellGrpCfg->phr_Config;
5767       if(phrConfig)
5768       {
5769          DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
5770          DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
5771       }
5772
5773       DU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
5774    }
5775
5776    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
5777    if(phyCellGrpCfg)
5778    {
5779       DU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5780       DU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
5781    }
5782
5783    spCellCfg = cellGrpCfg->spCellConfig;
5784    if(spCellCfg)
5785    {
5786       if(spCellCfg->servCellIndex)
5787       {
5788          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
5789          {
5790             if(spCellCfg->spCellConfigDedicated)
5791             {
5792                srvCellCfg = spCellCfg->spCellConfigDedicated;
5793                if(srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
5794                {
5795                   if(srvCellCfg->initialDownlinkBWP)
5796                   {
5797                      dlBwp = srvCellCfg->initialDownlinkBWP;
5798                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
5799                      {
5800                         if(srvCellCfg->defaultDownlinkBWP_Id)
5801                         {
5802                            if(srvCellCfg->uplinkConfig)
5803                            {
5804                               if(srvCellCfg->pdsch_ServingCellConfig)
5805                               {
5806                                  pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
5807                                  if(pdschCfg->choice.setup)
5808                                  {
5809                                     DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
5810                                     DU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5811                                  }
5812                                  DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
5813                                           ServingCellConfig__pdsch_ServingCellConfig));
5814                               }
5815                               FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
5816                               DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
5817                            }
5818                            DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
5819                         }
5820                         DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
5821                      }
5822                      if(dlBwp->pdcch_Config)
5823                      {
5824                         if(dlBwp->pdsch_Config)
5825                         {
5826                            FreeBWPDlDedPdschCfg(dlBwp);
5827                            DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
5828                         }
5829                         FreeBWPDlDedPdcchCfg(dlBwp);
5830                         DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
5831                      }
5832                      DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
5833                   }
5834                   DU_FREE(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
5835                }
5836                DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5837             }
5838             DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5839          }
5840          DU_FREE(spCellCfg->servCellIndex, sizeof(long));
5841       }
5842       DU_FREE(spCellCfg,sizeof(SpCellConfig_t));
5843    }
5844    return ROK;
5845 }
5846 /*******************************************************************
5847  *
5848  * @brief Builds DU To CU RRC Container
5849  *
5850  * @details
5851  *
5852  *    Function : BuildDuToCuRrcContainer
5853  *
5854  *    Functionality: Builds DuToCuRrcContainer
5855  *
5856  * @params[in] idx, index in F1AP msg
5857  *             DuToCuRRCContainer, DuToCuRRCContainer
5858  *
5859  * @return ROK     - success
5860  *         RFAILED - failure
5861  *
5862  * ****************************************************************/
5863 uint8_t BuildDuToCuRrcContainer(DUtoCURRCContainer_t *duToCuRrcContainer)
5864 {
5865    uint8_t  ret = ROK;
5866    CellGroupConfigRrc_t  cellGrpCfg;
5867    asn_enc_rval_t        encRetVal;
5868    memset(&cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
5869    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
5870
5871    while(true)
5872    {
5873       cellGrpCfg.cellGroupId = CELL_GRP_ID;
5874
5875       cellGrpCfg.rlc_BearerToAddModList = NULLP;
5876       DU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5877       if(!cellGrpCfg.rlc_BearerToAddModList)
5878       {
5879          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5880          ret = RFAILED;
5881          break;
5882       }
5883       if(BuildRlcBearerToAddModList(cellGrpCfg.rlc_BearerToAddModList) != ROK)
5884       {
5885          DU_LOG("\nERROR  -->  F1AP : BuildRlcBearerToAddModList failed");
5886          ret = RFAILED;
5887          break;
5888       }
5889
5890       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
5891       cellGrpCfg.mac_CellGroupConfig = NULLP;
5892       DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
5893       if(!cellGrpCfg.mac_CellGroupConfig)
5894       {
5895          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5896          ret = RFAILED;
5897          break;
5898       }
5899       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
5900       {
5901          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
5902          ret = RFAILED;
5903          break;
5904       }
5905
5906       cellGrpCfg.physicalCellGroupConfig = NULLP;
5907       DU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
5908       if(!cellGrpCfg.physicalCellGroupConfig)
5909       {
5910          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5911          ret = RFAILED;
5912          break;
5913       }
5914       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
5915       {
5916          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
5917          ret = RFAILED;
5918          break;
5919       }
5920
5921       cellGrpCfg.spCellConfig = NULLP;
5922       DU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
5923       if(!cellGrpCfg.spCellConfig)
5924       {
5925          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5926          ret = RFAILED;
5927          break;
5928       }
5929       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
5930       {
5931          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
5932          ret = RFAILED;
5933          break;
5934       }
5935
5936       cellGrpCfg.sCellToAddModList = NULLP;
5937       cellGrpCfg.sCellToReleaseList = NULLP;
5938       cellGrpCfg.ext1 = NULLP;
5939
5940       /* encode cellGrpCfg into duToCuRrcContainer */
5941       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
5942       memset(encBuf, 0, ENC_BUF_MAX_LEN);
5943       encBufSize = 0;
5944       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
5945       /* Encode results */
5946       if(encRetVal.encoded == ENCODE_FAIL)
5947       {
5948          DU_LOG( "\nERROR  --> F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
5949                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5950          ret = RFAILED;
5951          break;
5952       }
5953       else
5954       {
5955          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
5956          for(int i=0; i< encBufSize; i++)
5957          {
5958             printf("%x",encBuf[i]);
5959          }
5960       }
5961
5962       duToCuRrcContainer->size = encBufSize;
5963       DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
5964       if(!duToCuRrcContainer->buf)
5965       {
5966          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
5967          ret = RFAILED;
5968          break;
5969       }
5970       if(ret == ROK)
5971       {
5972          memcpy(duToCuRrcContainer->buf, encBuf, duToCuRrcContainer->size);
5973       }
5974       break;
5975    }
5976    FreeMemDuToCuRrcCont(&cellGrpCfg);
5977    return ret;
5978 }
5979
5980 /*******************************************************************
5981  *
5982  * @brief Free memory allocated in InitialULRRCMessage
5983  *
5984  * @details
5985  *
5986  *    Function : freeInitUlRrcMsgTransfer
5987  *
5988  *    Functionality: Free memory allocated in InitialULRRCMessage
5989  *
5990  * @params[in]F1AP_PDU_t  *f1apMsg)
5991  *
5992  * @return ROK     - success
5993  *         RFAILED - failure
5994  *
5995  * ****************************************************************/
5996
5997 uint8_t freeInitUlRrcMsgTransfer(F1AP_PDU_t  *f1apMsg)
5998 {
5999    uint8_t ieIdx, arrIdx;
6000    InitialULRRCMessageTransfer_t *initULRRCMsg=NULLP;
6001
6002    if(f1apMsg)
6003    {
6004       if(f1apMsg->choice.initiatingMessage)
6005       {
6006          initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.\
6007             choice.InitialULRRCMessageTransfer;
6008          if(initULRRCMsg->protocolIEs.list.array)
6009          {
6010             for(ieIdx = 0; ieIdx < initULRRCMsg->protocolIEs.list.count; ieIdx++)
6011             {
6012                switch(initULRRCMsg->protocolIEs.list.array[ieIdx]->id)
6013                {
6014                   case ProtocolIE_ID_id_NRCGI:
6015                   {
6016                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf)
6017                      {
6018                         if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf)
6019                         {
6020                            DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf,\
6021                            initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.size);
6022                         }
6023                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf,\
6024                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.size);
6025                      }
6026                      break;
6027                   }
6028                   case ProtocolIE_ID_id_RRCContainer:
6029                   {
6030                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
6031                      {
6032                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,\
6033                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
6034                      }
6035                      break;
6036                   }
6037                   case ProtocolIE_ID_id_DUtoCURRCContainer:
6038                   {
6039                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf)
6040                      {
6041                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf,
6042                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.size);
6043                      }
6044                      break;
6045                   }
6046                   default:
6047                      break;
6048                }
6049              }
6050              for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
6051              {
6052                 if(initULRRCMsg->protocolIEs.list.array[arrIdx])
6053                 {
6054                    DU_FREE(initULRRCMsg->protocolIEs.list.array[arrIdx],\
6055                       sizeof(InitialULRRCMessageTransferIEs_t));
6056                 }
6057              }
6058              DU_FREE(initULRRCMsg->protocolIEs.list.array, initULRRCMsg->protocolIEs.list.size);
6059           }
6060          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
6061       }
6062       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
6063    }
6064    else
6065    {
6066       DU_LOG("\nERROR  -->  DU_APP : Recevied F1ap Pdu is null at freeInitUlRrcMsgTransfer()");
6067       return RFAILED;
6068    }
6069    return ROK;
6070 }
6071
6072 /*******************************************************************
6073  *
6074  * @brief Builds and sends the InitialULRRCMessage
6075  *
6076  * @details
6077  *
6078  *    Function : BuildAndSendInitialRrcMsgTransfer
6079  *
6080  *    Functionality: Constructs the Initial UL RRC Message Transfer and sends
6081  *                   it to the CU through SCTP.
6082  *
6083  * @params[in]
6084  *
6085  * @return ROK     - success
6086  *         RFAILED - failure
6087  *
6088  * ****************************************************************/
6089 uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti,
6090       uint16_t rrcContSize, uint8_t *rrcContainer)
6091 {
6092    uint8_t   ret;
6093    uint8_t   elementCnt;
6094    uint8_t   ieIdx;
6095    asn_enc_rval_t  encRetVal;
6096    F1AP_PDU_t  *f1apMsg = NULLP;
6097    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
6098    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
6099
6100    while(true)
6101    {
6102       DU_LOG("\n INFO   -->  F1AP : Building RRC Setup Request\n");
6103       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
6104       if(f1apMsg == NULLP)
6105       {
6106          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
6107          break;
6108       }
6109       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
6110       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
6111       if(f1apMsg->choice.initiatingMessage == NULLP)
6112       {
6113          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
6114          break;
6115       }
6116       f1apMsg->choice.initiatingMessage->procedureCode =\
6117                                                         ProcedureCode_id_InitialULRRCMessageTransfer;
6118       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
6119       f1apMsg->choice.initiatingMessage->value.present = \
6120                                                          InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
6121       initULRRCMsg =\
6122                     &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
6123       elementCnt = 5;
6124       initULRRCMsg->protocolIEs.list.count = elementCnt;
6125       initULRRCMsg->protocolIEs.list.size = \
6126                                             elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *);
6127       /* Initialize the F1Setup members */
6128       DU_ALLOC(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
6129       if(initULRRCMsg->protocolIEs.list.array == NULLP)
6130       {
6131          DU_LOG(" ERROR  -->  F1AP : Memory allocation for\
6132                RRCSetupRequestMessageTransferIEs failed");
6133          break;
6134       }
6135       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
6136       {
6137          DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx],\
6138                sizeof(InitialULRRCMessageTransferIEs_t));
6139          if(initULRRCMsg->protocolIEs.list.array[ieIdx] == NULLP)
6140          {
6141             break;
6142          }
6143       }
6144       ieIdx = 0;
6145       /*GNB DU UE F1AP ID*/
6146       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6147                                                         ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
6148       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  = Criticality_reject;
6149       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
6150                                                                   InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
6151       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
6152
6153
6154       /*NRCGI*/
6155       ieIdx++;
6156       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6157                                                         ProtocolIE_ID_id_NRCGI;
6158       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  =Criticality_reject;
6159       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
6160                                                                   InitialULRRCMessageTransferIEs__value_PR_NRCGI;
6161
6162       ret =\
6163            BuildNrcgi(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
6164       if(ret!=ROK)
6165       {
6166          break;
6167       }
6168
6169       /*CRNTI*/
6170       ieIdx++;
6171       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6172                                                         ProtocolIE_ID_id_C_RNTI;
6173       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6174       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6175                                                                  InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
6176       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.C_RNTI = crnti;
6177
6178       /*RRCContainer*/
6179       ieIdx++;
6180       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6181                                                         ProtocolIE_ID_id_RRCContainer;
6182       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6183       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6184                                                                  InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
6185
6186       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = rrcContSize;
6187       DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
6188             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size)
6189       if(!initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
6190       {
6191          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
6192          break;
6193
6194       }
6195       memcpy(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, rrcContainer,
6196             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
6197
6198
6199       /*DUtoCURRCContainer*/
6200       ieIdx++;
6201       initULRRCMsg->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCContainer;
6202       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6203       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6204                                                                  InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
6205
6206       ret = BuildDuToCuRrcContainer(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer);
6207       if(ret != ROK)
6208       {
6209          break;
6210       }
6211
6212       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
6213
6214       /* Encode the F1SetupRequest type as APER */
6215       memset(encBuf, 0, ENC_BUF_MAX_LEN);
6216       encBufSize = 0;
6217       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
6218       /* Encode results */
6219       if(encRetVal.encoded == ENCODE_FAIL)
6220       {
6221          DU_LOG( "\nERROR  --> F1AP : Could not encode Initial UL RRC Message Transfer\
6222                structure (at %s)\n",encRetVal.failed_type ? \
6223                encRetVal.failed_type->name : "unknown");
6224          ret = RFAILED;
6225          break;
6226       }
6227       else
6228       {
6229
6230          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for Initial UL RRC\
6231                Message transfer\n");
6232          for(int i=0; i< encBufSize; i++)
6233          {
6234             printf("%x",encBuf[i]);
6235          }
6236       }
6237       /* Sending  msg  */
6238       if(sendF1APMsg() != ROK)
6239       {
6240          DU_LOG("\nERROR  -->  F1AP : Sending Initial UL RRC Message Transfer Failed");
6241          ret = RFAILED;
6242          break;
6243       }
6244       break;
6245    }
6246    freeInitUlRrcMsgTransfer(f1apMsg);
6247    return ret;
6248 }/* End of BuildAndSendInitialRrcMsgTransfer*/
6249
6250 /*****  UE SETUP REQUEST *****/
6251
6252 /*******************************************************************
6253  *
6254  * @brief Free Qos And Snssai Drb Info
6255  *
6256  * @details
6257  *
6258  *    Function : freeDrbQosAndSnssaiInfo
6259  *
6260  *    Functionality: Free Qos And Snssai Drb Info
6261  *
6262  * @params[in] LcCfg *lcCfg,
6263  * @return void
6264  *
6265  * ****************************************************************/
6266 void freeDrbQosAndSnssaiInfo(LcCfg *lcCfg)
6267 {
6268    if(lcCfg->snssai)
6269    {
6270       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6271    }
6272    if(lcCfg->drbQos)
6273    {
6274       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
6275    }
6276 }
6277
6278 /******************************************************************
6279 *
6280 * @brief Function to delete the RLC Lc cfg from UE APP DB
6281 *
6282 * @details
6283 *
6284 *  Function : freeRlcLcCfg
6285 *
6286 *  Functionality: Function to delete the RLC Lc cfg from UE APP DB
6287 *
6288 *
6289  *****************************************************************/
6290
6291 void freeRlcLcCfg(RlcBearerCfg *lcCfg)
6292 {
6293    switch(lcCfg->rlcMode)
6294    {
6295       case RLC_AM :
6296          {
6297             if(lcCfg->u.amCfg)
6298             {
6299                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.amCfg, sizeof(AmBearerCfg));
6300             }
6301             break;
6302          }
6303       case RLC_UM_BI_DIRECTIONAL :
6304          {
6305             if(lcCfg->u.umBiDirCfg)
6306             {
6307                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
6308             }
6309             break;
6310          }
6311       case RLC_UM_UNI_DIRECTIONAL_UL :
6312          {
6313             if(lcCfg->u.umUniDirUlCfg)
6314             {
6315                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
6316             }
6317             break;
6318
6319          }
6320       case RLC_UM_UNI_DIRECTIONAL_DL :
6321          {
6322             if(lcCfg->u.umUniDirDlCfg)
6323             {
6324                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
6325             }
6326             break;
6327          }
6328       default:
6329          DU_LOG("\nERROR  -->  DU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
6330          break;
6331    }
6332 }
6333
6334 /*******************************************************************
6335  *
6336  * @brief Function to free MacLcCfg
6337  *
6338  * @details
6339  *
6340  *    Function : freeMacLcCfg
6341  *
6342  *    Functionality: Function to free MacLcCfg
6343  *
6344  * @params[in] LcCfg *lcCfg,
6345  * @return void
6346  *
6347  * ****************************************************************/
6348
6349 void  freeMacLcCfg(LcCfg *lcCfg)
6350 {
6351     /* Deleting DRBQOS */
6352    if(lcCfg->drbQos)
6353    {
6354       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
6355    }
6356    /* Deleting SNSSAI */
6357    if(lcCfg->snssai)
6358    {
6359       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6360    }
6361 }
6362 /*******************************************************************
6363  *
6364  * @brief Free UE NR Capability received in UE Context setup request
6365  *
6366  * @details
6367  *
6368  *    Function : freeAperDecodeUeNrCapability
6369  *
6370  *    Functionality:
6371  *       Free UE NR Capability received in UE Context setup request
6372  *
6373  * @params[in]
6374  * @return ROK     - success
6375  *         RFAILED - failure
6376  *
6377  * ****************************************************************/
6378 void freeAperDecodeUeNrCapability(void *ueNrCapability)
6379 {
6380    uint8_t arrIdx =0;
6381    FeatureSets_t *featureSets =NULLP;
6382    UE_NR_Capability_t *ueNrCap = (UE_NR_Capability_t *)ueNrCapability;
6383
6384    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
6385    {
6386       for(arrIdx = 0; arrIdx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; arrIdx++)
6387       {
6388          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx])
6389             free(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx]);
6390       }
6391       free(ueNrCap->rf_Parameters.supportedBandListNR.list.array);
6392    }
6393
6394    if(ueNrCap->featureSets)
6395    {
6396       featureSets = ueNrCap->featureSets;
6397       if(featureSets->featureSetsDownlinkPerCC)
6398       {
6399          if(featureSets->featureSetsDownlinkPerCC->list.array)
6400          {
6401             for(arrIdx = 0; arrIdx < featureSets->featureSetsDownlinkPerCC->list.count; arrIdx++)
6402             {
6403                if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx])
6404                {
6405                   if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL)
6406                      free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL);
6407                   free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]);
6408                }
6409             }
6410             free(featureSets->featureSetsDownlinkPerCC->list.array);
6411          }
6412          free(featureSets->featureSetsDownlinkPerCC);
6413       }
6414       if(featureSets->featureSetsUplinkPerCC)
6415       {
6416          if(featureSets->featureSetsUplinkPerCC->list.array)
6417          {
6418             for(arrIdx = 0; arrIdx < featureSets->featureSetsUplinkPerCC->list.count; arrIdx++)
6419             {
6420                if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx])
6421                {
6422                   if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL)
6423                      free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL);
6424                   free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]);
6425                }
6426             }
6427             free(featureSets->featureSetsUplinkPerCC->list.array);
6428          }
6429          free(featureSets->featureSetsUplinkPerCC);
6430       }
6431       free(ueNrCap->featureSets);
6432    }
6433 }
6434
6435 /*******************************************************************
6436 *
6437 * @brief Function to free PdcchSearchSpcToAddModList
6438          where memory allocated by aper_decoder
6439 *
6440 * @details
6441 *
6442 *    Function : freeAperDecodePdcchSearchSpcToAddModList
6443 *
6444 *    Functionality: Function to free PdcchSearchSpcToAddModList
6445 *
6446 * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
6447 * @return void
6448 *
6449 * ****************************************************************/
6450
6451 void freeAperDecodePdcchSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
6452 {
6453    uint8_t searchSpcArrIdx=0;
6454    uint8_t searchSpcArrIdx1=0;
6455    struct  SearchSpace *searchSpc=NULLP;
6456
6457
6458    if(searchSpcList->list.array)
6459    {
6460       if(searchSpcList->list.array[searchSpcArrIdx1])
6461       {
6462          searchSpc = searchSpcList->list.array[searchSpcArrIdx1];
6463          if(searchSpc->controlResourceSetId)
6464          {
6465             if(searchSpc->monitoringSlotPeriodicityAndOffset)
6466             {
6467                if(searchSpc->monitoringSymbolsWithinSlot)
6468                {
6469                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
6470                   {
6471                      if(searchSpc->nrofCandidates)
6472                      {
6473                         if(searchSpc->searchSpaceType)
6474                         {
6475                            free(searchSpc->searchSpaceType->choice.ue_Specific);
6476                            free(searchSpc->searchSpaceType);
6477                         }
6478                         free(searchSpc->nrofCandidates);
6479                      }
6480                      free(searchSpc->monitoringSymbolsWithinSlot->buf);
6481                   }
6482                   free(searchSpc->monitoringSymbolsWithinSlot);
6483                }
6484                free(searchSpc->monitoringSlotPeriodicityAndOffset);
6485             }
6486             free(searchSpc->controlResourceSetId);
6487          }
6488       }
6489       for(searchSpcArrIdx = 0; searchSpcArrIdx < searchSpcList->list.count; searchSpcArrIdx++)
6490       {
6491          free(searchSpcList->list.array[searchSpcArrIdx]);
6492       }
6493       free(searchSpcList->list.array);
6494    }
6495 }
6496 /*******************************************************************
6497 *
6498 * @brief Function for free part for the memory allocated by aper_decoder
6499 *
6500 * @details
6501 *
6502 *    Function : freeAperDecodeBWPDlDedPdcchConfig
6503 *
6504 *    Functionality: Function to free BWPDlDedPdcchConfig
6505 *
6506 * @params[in]
6507 * @return void
6508 *
6509 * ****************************************************************/
6510
6511
6512 void freeAperDecodeBWPDlDedPdcchConfig(BWP_DownlinkDedicated_t *dlBwp)
6513 {
6514    uint8_t arrIdx1=0;
6515    uint8_t arrIdx2=0;
6516    struct PDCCH_Config *pdcchCfg=NULLP;
6517    struct ControlResourceSet *controlRSet=NULLP;
6518    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
6519
6520    if(dlBwp->pdcch_Config->choice.setup)
6521    {
6522       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
6523       if(pdcchCfg->controlResourceSetToAddModList)
6524       {
6525          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
6526          if(controlRSetList->list.array)
6527          {
6528             controlRSet = controlRSetList->list.array[arrIdx2];
6529             if(controlRSet)
6530             {
6531                if(controlRSet->frequencyDomainResources.buf)
6532                {
6533                   if(controlRSet->pdcch_DMRS_ScramblingID)
6534                   {
6535                      if(pdcchCfg->searchSpacesToAddModList)
6536                      {
6537                         freeAperDecodePdcchSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
6538                         free(pdcchCfg->searchSpacesToAddModList);
6539                      }
6540                      free(controlRSet->pdcch_DMRS_ScramblingID);
6541                   }
6542                   free(controlRSet->frequencyDomainResources.buf);
6543                }
6544             }
6545             for(arrIdx1 = 0; arrIdx1 <controlRSetList->list.count; arrIdx1++)
6546             {
6547                free(controlRSetList->list.array[arrIdx1]);
6548             }
6549             free(controlRSetList->list.array);
6550          }
6551          free(pdcchCfg->controlResourceSetToAddModList);
6552       }
6553       free(dlBwp->pdcch_Config->choice.setup);
6554    }
6555 }
6556 /*******************************************************************
6557 *
6558 * @brief Function to free PdschTimeDomAllocationList
6559 *     where the memory allocated by aper_decoder
6560 *
6561 * @details
6562 *
6563 *    Function : freeAperDecodePdschTimeDomAllocationList
6564 *
6565 *    Functionality: Function to free PdschTimeDomAllocationList
6566 *
6567 * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
6568 * @return void
6569 *
6570 * ****************************************************************/
6571
6572
6573 void freeAperDecodePdschTimeDomAllocationList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
6574 {
6575    uint8_t arrIdx=0;
6576
6577    if(timeDomAllocList->choice.setup)
6578    {
6579       if(timeDomAllocList->choice.setup->list.array)
6580       {
6581          for(arrIdx = 0; arrIdx <timeDomAllocList->choice.setup->list.count ; arrIdx++)
6582          {
6583             free(timeDomAllocList->choice.setup->list.array[arrIdx]);
6584          }
6585          free(timeDomAllocList->choice.setup->list.array);
6586       }
6587       free(timeDomAllocList->choice.setup);
6588    }
6589 }
6590
6591 /*******************************************************************
6592 *
6593 * @brief Function to free BWPDlDedPdschConfig
6594 *        where the memory allocated by aper_decoder
6595 *
6596 * @details
6597 *
6598 *    Function : freeAperDecodeBWPDlDedPdschConfig
6599 *
6600 *    Functionality: Function to free BWPDlDedPdschConfig
6601 *
6602 * @params[in] BWP_DownlinkDedicated_t *dlBwp
6603 * @return void
6604 *
6605 * ****************************************************************/
6606
6607
6608 void freeAperDecodeBWPDlDedPdschConfig(BWP_DownlinkDedicated_t *dlBwp)
6609 {
6610    struct PDSCH_Config *pdschCfg=NULLP;
6611    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
6612    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
6613    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
6614
6615    if(dlBwp->pdsch_Config->choice.setup)
6616    {
6617       pdschCfg=dlBwp->pdsch_Config->choice.setup;
6618       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
6619       {
6620          if(pdschCfg->pdsch_TimeDomainAllocationList)
6621          {
6622             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
6623             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
6624             {
6625                prbBndlType=&pdschCfg->prb_BundlingType;
6626                free(prbBndlType->choice.staticBundling);
6627                free(pdschCfg->maxNrofCodeWordsScheduledByDCI);
6628             }
6629             freeAperDecodePdschTimeDomAllocationList(timeDomAllocList);
6630             free(pdschCfg->pdsch_TimeDomainAllocationList);
6631          }
6632          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
6633          if(dmrsDlCfg->choice.setup)
6634          {
6635             free(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition);
6636             free(dmrsDlCfg->choice.setup);
6637          }
6638          free(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA);
6639       }
6640       free(dlBwp->pdsch_Config->choice.setup);
6641    }
6642 }
6643 /*******************************************************************
6644 *
6645 * @brief Function to free PuschTimeDomAllocListCfg
6646                  where the memory allocated by aper_decoder
6647 *
6648 * @details
6649 *
6650 *    Function : freeAperDecodePuschTimeDomAllocListCfg
6651 *
6652 *    Functionality: Function to free PuschTimeDomAllocListCfg
6653 *
6654 * @params[in] PUSCH_Config_t *puschCfg
6655 * @return void
6656 *
6657 * ****************************************************************/
6658
6659
6660 void freeAperDecodePuschTimeDomAllocListCfg(PUSCH_Config_t *puschCfg)
6661 {
6662    uint8_t arrIdx=0;
6663    uint8_t arrIdx1=0;
6664    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
6665
6666    if(puschCfg->pusch_TimeDomainAllocationList)
6667    {
6668       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
6669       if(timeDomAllocList_t->choice.setup)
6670       {
6671          if(timeDomAllocList_t->choice.setup->list.array)
6672          {
6673             free(timeDomAllocList_t->choice.setup->list.array[arrIdx1]->k2);
6674             for(arrIdx = 0; arrIdx<timeDomAllocList_t->choice.setup->list.count; arrIdx++)
6675             {
6676                free(timeDomAllocList_t->choice.setup->list.array[arrIdx]);
6677             }
6678             free(timeDomAllocList_t->choice.setup->list.array);
6679          }
6680          free(timeDomAllocList_t->choice.setup);
6681       }
6682       free(puschCfg->transformPrecoder);
6683       free(puschCfg->pusch_TimeDomainAllocationList);
6684    }
6685 }
6686 /*******************************************************************
6687 *
6688 * @brief Function to free InitialUlBWPConfig where memory allocated by aper_decoder
6689 *
6690 * @details
6691 *
6692 *    Function : freeAperDecodeInitialUlBWPConfig
6693 *
6694 *    Functionality: Function to free InitialUlBWPConfig
6695 *
6696 * @params[in]  BWP_UplinkDedicated_t *ulBwp
6697 * @return void
6698 *
6699 * ****************************************************************/
6700
6701
6702 void freeAperDecodeInitialUlBWPConfig(BWP_UplinkDedicated_t *ulBwp)
6703 {
6704    uint8_t  rSetIdx =0;
6705    uint8_t  rsrcIdx =0;
6706    SRS_Config_t   *srsCfg = NULLP;
6707    PUSCH_Config_t *puschCfg = NULLP;
6708    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
6709    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
6710    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
6711    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
6712
6713    if(ulBwp->pusch_Config)
6714    {
6715       if(ulBwp->pusch_Config->choice.setup)
6716       {
6717          puschCfg=ulBwp->pusch_Config->choice.setup;
6718          if(puschCfg->dataScramblingIdentityPUSCH)
6719          {
6720             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
6721             {
6722                freeAperDecodePuschTimeDomAllocListCfg(puschCfg);
6723                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
6724                if(dmrsUlCfg->choice.setup)
6725                {
6726                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
6727                   {
6728                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
6729                      {
6730                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0);
6731                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled);
6732                      }
6733                      free(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition);
6734                   }
6735                   free(dmrsUlCfg->choice.setup);
6736                }
6737                free(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA);
6738             }
6739             free(puschCfg->dataScramblingIdentityPUSCH);
6740          }
6741          free(ulBwp->pusch_Config->choice.setup);
6742       }
6743       free(ulBwp->pusch_Config);
6744
6745       /* Free SRS-Config */
6746       if(ulBwp->srs_Config)
6747       {
6748          if(ulBwp->srs_Config->choice.setup)
6749          {
6750             srsCfg = ulBwp->srs_Config->choice.setup;
6751
6752             /* Free Resource Set to add/mod list */
6753             if(srsCfg->srs_ResourceSetToAddModList)
6754             {
6755                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
6756                if(rsrcSetList->list.array)
6757                {
6758                   rSetIdx = 0;
6759
6760                   /* Free SRS resource Id list in this SRS resource set */
6761                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
6762                   {
6763                      rsrcIdList =
6764                         rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
6765
6766                      if(rsrcIdList->list.array)
6767                      {
6768                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count;
6769                               rsrcIdx++)
6770                         {
6771                            free(rsrcIdList->list.array[rsrcIdx]);
6772                         }
6773                         free(rsrcIdList->list.array);
6774                      }
6775                      free(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList);
6776                   }
6777
6778                   /* Free resource type info for this SRS resource set */
6779
6780                   free(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic);
6781
6782                   /* Free memory for each resource set */
6783                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
6784                   {
6785                      free(rsrcSetList->list.array[rSetIdx]);
6786                   }
6787                   free(rsrcSetList->list.array);
6788                }
6789                free(srsCfg->srs_ResourceSetToAddModList);
6790             }
6791
6792             /* Free resource to add/modd list */
6793             if(srsCfg->srs_ResourceToAddModList)
6794             {
6795                resourceList = srsCfg->srs_ResourceToAddModList;
6796                if(resourceList->list.array)
6797                {
6798                   rsrcIdx = 0;
6799
6800                   free(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2);
6801                   free(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic);
6802
6803                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
6804                   {
6805                      free(resourceList->list.array[rsrcIdx]);
6806                   }
6807                   free(resourceList->list.array);
6808                }
6809                free(srsCfg->srs_ResourceToAddModList);
6810             }
6811
6812             free(ulBwp->srs_Config->choice.setup);
6813          }
6814          free(ulBwp->srs_Config);
6815       }
6816    }
6817 }
6818 /*******************************************************************
6819 *
6820 * @brief Function to free initialUplinkBWPConfig where memory allocated by aper_decoder
6821 *
6822 * @details
6823 *
6824 *    Function : freeAperDecodeinitialUplinkBWPConfig
6825 *
6826 *    Functionality: Function to free initialUplinkBWPConfig
6827 *
6828 * @params[in] UplinkConfig_t *ulCfg
6829 * @return void
6830 *
6831 * ****************************************************************/
6832
6833
6834 void freeAperDecodeinitialUplinkBWPConfig(UplinkConfig_t *ulCfg)
6835 {
6836    BWP_UplinkDedicated_t *ulBwp=NULLP;
6837    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
6838
6839    if(ulCfg->initialUplinkBWP)
6840    {
6841       ulBwp=ulCfg->initialUplinkBWP;
6842       if(ulCfg->firstActiveUplinkBWP_Id)
6843       {
6844          if(ulCfg->pusch_ServingCellConfig)
6845          {
6846             puschCfg=ulCfg->pusch_ServingCellConfig;
6847             if(puschCfg->choice.setup)
6848             {
6849                if(puschCfg->choice.setup->ext1)
6850                {
6851                   free(puschCfg->choice.setup->ext1->processingType2Enabled);
6852                   free(puschCfg->choice.setup->ext1->maxMIMO_Layers);
6853                   free(puschCfg->choice.setup->ext1);
6854                }
6855                free(puschCfg->choice.setup);
6856             }
6857             free(ulCfg->pusch_ServingCellConfig);
6858          }
6859          free(ulCfg->firstActiveUplinkBWP_Id);
6860       }
6861       freeAperDecodeInitialUlBWPConfig(ulBwp);
6862       free(ulCfg->initialUplinkBWP);
6863    }
6864 }
6865
6866 /*******************************************************************
6867  *
6868  * @brief Function to free DuUeCfg
6869  *
6870  * @details
6871  *
6872  *    Function : freeDuUeCfg
6873  *
6874  *    Functionality: Function to free DuUeCfg
6875  *
6876  * @params[in] DuUeCfg *ueCfg
6877  * @return void
6878  *
6879  * ****************************************************************/
6880 void freeDuUeCfg(DuUeCfg *ueCfg)
6881 {
6882    uint8_t lcIdx = 0;
6883    uint8_t arrIdx = 0;
6884    SpCellConfig_t *spCellCfg = NULLP;
6885    ServingCellConfig_t *srvCellCfg = NULLP;
6886    BWP_DownlinkDedicated_t *dlBwp = NULLP;
6887    MAC_CellGroupConfig_t *macCellGrpCfg = NULLP;
6888    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
6889    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList = NULLP;
6890    struct RLC_Config *rlcConfig = NULLP;
6891    struct LogicalChannelConfig *macLcConfig = NULLP;
6892    struct SchedulingRequestConfig *schedulingRequestConfig = NULLP;
6893    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList = NULLP;
6894    struct TAG_Config *tagConfig = NULLP;
6895    struct TAG_Config__tag_ToAddModList *tagList = NULLP;
6896    struct MAC_CellGroupConfig__phr_Config *phrConfig = NULLP;
6897    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg = NULLP;
6898    CellGroupConfigRrc_t *cellGrpCfg = ueCfg->cellGrpCfg;
6899
6900    if(ueCfg->ueNrCapability)
6901    {
6902       freeAperDecodeUeNrCapability(ueCfg->ueNrCapability);
6903       DU_FREE(ueCfg->ueNrCapability, sizeof(UE_NR_Capability_t));
6904       ueCfg->ueNrCapability = NULLP;
6905    }
6906
6907    if(ueCfg->cellGrpCfg)
6908    {
6909
6910       rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6911       if(rlcBearerList)
6912       {
6913          if(rlcBearerList->list.array)
6914          {
6915             for(arrIdx=0; arrIdx<rlcBearerList->list.count; arrIdx++)
6916             {
6917                if(rlcBearerList->list.array[arrIdx])
6918                {
6919                   rlcConfig   = rlcBearerList->list.array[arrIdx]->rlc_Config;
6920                   macLcConfig = rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig;
6921
6922                   if(rlcBearerList->list.array[arrIdx]->servedRadioBearer)
6923                   {
6924                      free(rlcBearerList->list.array[arrIdx]->servedRadioBearer);
6925                   }
6926                   if(rlcConfig)
6927                   {
6928                      if(rlcConfig->choice.am)
6929                      {
6930                         free(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength);
6931                         free(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength);
6932                         free(rlcConfig->choice.am);
6933                      }
6934                      free(rlcBearerList->list.array[arrIdx]->rlc_Config);
6935                   }
6936                   if(macLcConfig)
6937                   {
6938                      if(macLcConfig->ul_SpecificParameters)
6939                      {
6940                         free(macLcConfig->ul_SpecificParameters->schedulingRequestID);
6941                         free(macLcConfig->ul_SpecificParameters->logicalChannelGroup);
6942                         free(macLcConfig->ul_SpecificParameters);
6943                      }
6944                      free(rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig);
6945                   }
6946                   free(rlcBearerList->list.array[arrIdx]);
6947                }
6948             }
6949             free(rlcBearerList->list.array);
6950          }
6951          free(cellGrpCfg->rlc_BearerToAddModList);
6952       }
6953
6954       macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
6955       if(macCellGrpCfg)
6956       {
6957          schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
6958          if(schedulingRequestConfig)
6959          {
6960             schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
6961             if(schReqList)
6962             {
6963                if(schReqList->list.array)
6964                {
6965                   for(arrIdx=0;arrIdx<schReqList->list.count; arrIdx++)
6966                   {
6967                      if(schReqList->list.array[arrIdx])
6968                      {
6969                         free(schReqList->list.array[arrIdx]->sr_ProhibitTimer);
6970                         free(schReqList->list.array[arrIdx]);
6971                      }
6972                   }
6973                   free(schReqList->list.array);
6974                }
6975                free(schedulingRequestConfig->schedulingRequestToAddModList);
6976             }
6977             free(macCellGrpCfg->schedulingRequestConfig);
6978          }
6979          if(macCellGrpCfg->bsr_Config)
6980          {
6981             free(macCellGrpCfg->bsr_Config);
6982          }
6983          tagConfig = macCellGrpCfg->tag_Config;
6984          if(tagConfig)
6985          {
6986             tagList = tagConfig->tag_ToAddModList;
6987             if(tagList)
6988             {
6989                if(tagList->list.array)
6990                {
6991                   for(arrIdx=0; arrIdx<tagList->list.count; arrIdx++)
6992                   {
6993                      free(tagList->list.array[arrIdx]);
6994                   }
6995                   free(tagList->list.array);
6996                }
6997                free(tagConfig->tag_ToAddModList);
6998             }
6999             free(tagConfig);
7000          }
7001
7002          phrConfig = macCellGrpCfg->phr_Config;
7003          if(phrConfig)
7004          {
7005             free(phrConfig->choice.setup);
7006             free(phrConfig);
7007          }
7008
7009          free(macCellGrpCfg);
7010       }
7011
7012       phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
7013       if(phyCellGrpCfg)
7014       {
7015          free(phyCellGrpCfg->p_NR_FR1);
7016          free(phyCellGrpCfg);
7017       }
7018
7019       spCellCfg = cellGrpCfg->spCellConfig;
7020       if(spCellCfg)
7021       {
7022          if(spCellCfg->servCellIndex)
7023          {
7024             if(spCellCfg->rlmInSyncOutOfSyncThreshold)
7025             {
7026                if(spCellCfg->spCellConfigDedicated)
7027                {
7028                   srvCellCfg = spCellCfg->spCellConfigDedicated;
7029                   if(srvCellCfg->initialDownlinkBWP)
7030                   {
7031                      dlBwp = srvCellCfg->initialDownlinkBWP;
7032                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
7033                      {
7034                         if(srvCellCfg->defaultDownlinkBWP_Id)
7035                         {
7036                            if(srvCellCfg->uplinkConfig)
7037                            {
7038
7039                               if(srvCellCfg->pdsch_ServingCellConfig)
7040                               {
7041                                  pdschCfg=
7042                                     srvCellCfg->pdsch_ServingCellConfig;
7043                                  if(pdschCfg->choice.setup)
7044                                  {
7045
7046                                     free(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH);
7047                                     free(pdschCfg->choice.setup);
7048                                  }
7049
7050                                  free(srvCellCfg->pdsch_ServingCellConfig);
7051                               }
7052
7053                               freeAperDecodeinitialUplinkBWPConfig(srvCellCfg->uplinkConfig);
7054                               free(srvCellCfg->uplinkConfig);
7055                            }
7056                            free(srvCellCfg->defaultDownlinkBWP_Id);
7057                         }
7058
7059                         free(srvCellCfg->firstActiveDownlinkBWP_Id);
7060                      }
7061                      if(dlBwp->pdcch_Config)
7062                      {
7063                         if(dlBwp->pdsch_Config)
7064                         {
7065                            freeAperDecodeBWPDlDedPdschConfig(dlBwp);
7066                            free(dlBwp->pdsch_Config);
7067                         }
7068                         freeAperDecodeBWPDlDedPdcchConfig(dlBwp);
7069                         free(dlBwp->pdcch_Config);
7070                      }
7071                      free(srvCellCfg->initialDownlinkBWP);
7072                   }
7073
7074                   free(spCellCfg->spCellConfigDedicated);
7075                }
7076                free(spCellCfg->rlmInSyncOutOfSyncThreshold);
7077             }
7078             free(spCellCfg->servCellIndex);
7079          }
7080          free(spCellCfg);
7081       }
7082       DU_FREE(ueCfg->cellGrpCfg, sizeof(CellGroupConfigRrc_t));
7083       ueCfg->cellGrpCfg = NULLP;
7084    }
7085    if(ueCfg->ambrCfg)
7086    {
7087       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->ambrCfg, sizeof(AmbrCfg));
7088    }
7089    for(lcIdx = 0; lcIdx < ueCfg->numRlcLcs; lcIdx++)
7090    {
7091       freeRlcLcCfg(&ueCfg->rlcLcCfg[lcIdx]);
7092    }
7093    for(lcIdx = 0; lcIdx < ueCfg->numMacLcs; lcIdx++)
7094    {
7095       freeMacLcCfg(&ueCfg->macLcCfg[lcIdx]);
7096    }
7097    for(lcIdx = 0; lcIdx < ueCfg->numDrb; lcIdx++)
7098    {
7099       DU_FREE(ueCfg->upTnlInfo[lcIdx].tnlCfg1, sizeof(GtpTnlCfg));
7100    }
7101 }
7102
7103 /*******************************************************************
7104  *
7105  * @brief Function to free UecontextSetupDb
7106  *
7107  * @details
7108  *
7109  *    Function : freeF1UeDb
7110  *
7111  *    Functionality: Function to free UecontextSetupDb
7112  *
7113  * @params[in] UecontextSetupDb *
7114  * @return void
7115  *
7116  * ****************************************************************/
7117
7118 void freeF1UeDb(F1UeContextSetupDb *f1UeDb)
7119 {
7120
7121    if(f1UeDb->dlRrcMsg)
7122    {
7123       if(f1UeDb->dlRrcMsg->rrcMsgPdu)
7124       {
7125         //DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,\
7126                f1UeDb->dlRrcMsg->rrcMsgPdu, f1UeDb->dlRrcMsg->rrcMsgSize);
7127       }
7128       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
7129    }
7130    freeDuUeCfg(&f1UeDb->duUeCfg);
7131    memset(f1UeDb, 0, sizeof(F1UeContextSetupDb));
7132    DU_FREE(f1UeDb, sizeof(F1UeContextSetupDb));
7133 }
7134
7135 /*******************************************************************
7136  *
7137  * @brief Function to build Am cfg Info
7138  *
7139  * @details
7140  *
7141  *    Function : extractRlcAmCfg
7142  *
7143  *    Functionality: Function to build Am cfg Info
7144  *
7145  * @params[in] AmBearerCfg *
7146  *             void *
7147  *
7148  * @return ROK/RFAILED
7149  *
7150  * ****************************************************************/
7151
7152 void extractRlcAmCfg(AmBearerCfg *amCfgToSet, struct RLC_Config__am *rlcAmCfg)
7153 {
7154    if(rlcAmCfg)
7155    {
7156       /* UL AM */
7157       if(rlcAmCfg->dl_AM_RLC.sn_FieldLength)
7158       {
7159          amCfgToSet->ulAmCfg.snLenUl = *(rlcAmCfg->dl_AM_RLC.sn_FieldLength);
7160          /*TODO: Check the timer value when sent by real CU */
7161          amCfgToSet->ulAmCfg.reAssemTmr = rlcAmCfg->dl_AM_RLC.t_Reassembly;
7162          amCfgToSet->ulAmCfg.statProhTmr = rlcAmCfg->dl_AM_RLC.t_StatusProhibit;
7163       }
7164
7165       /* DL AM */
7166       if(rlcAmCfg->ul_AM_RLC.sn_FieldLength)
7167       {
7168          amCfgToSet->dlAmCfg.snLenDl = *(rlcAmCfg->ul_AM_RLC.sn_FieldLength);
7169          amCfgToSet->dlAmCfg.pollRetxTmr = rlcAmCfg->ul_AM_RLC.t_PollRetransmit;
7170          amCfgToSet->dlAmCfg.pollPdu   = rlcAmCfg->ul_AM_RLC.pollPDU;
7171          amCfgToSet->dlAmCfg.pollByte  = rlcAmCfg->ul_AM_RLC.pollByte;
7172          amCfgToSet->dlAmCfg.maxRetxTh = rlcAmCfg->ul_AM_RLC.maxRetxThreshold;
7173       }
7174    }
7175 }
7176
7177 /*******************************************************************
7178  *
7179  * @brief Function to build Um Bi Info
7180  *
7181  * @details
7182  *
7183  *    Function : extractRlcUmBiCfg
7184  *
7185  *    Functionality: Function to build Um Bi Info
7186  *
7187  * @params[in] UmBiDirBearerCfg *
7188  *             void *
7189  *
7190  * @return ROK/RFAILED
7191  *
7192  * ****************************************************************/
7193
7194 void extractRlcUmBiCfg(UmBiDirBearerCfg *umBiCfgToSet, struct RLC_Config__um_Bi_Directional *rlcBiCfg)
7195 {
7196    if(rlcBiCfg)
7197    {
7198       /* UL UM BI DIR Cfg */
7199       if(rlcBiCfg->dl_UM_RLC.sn_FieldLength)
7200       {
7201          umBiCfgToSet->ulUmCfg.snLenUlUm  = *(rlcBiCfg->dl_UM_RLC.sn_FieldLength);
7202          umBiCfgToSet->ulUmCfg.reAssemTmr = rlcBiCfg->dl_UM_RLC.t_Reassembly;
7203       }
7204
7205       /* DL UM BI DIR Cfg */
7206       if(rlcBiCfg->ul_UM_RLC.sn_FieldLength)
7207          umBiCfgToSet->dlUmCfg.snLenDlUm  = *(rlcBiCfg->ul_UM_RLC.sn_FieldLength);
7208    }
7209 }
7210
7211 /*******************************************************************
7212  *
7213  * @brief Function to build Um Ul Info
7214  *
7215  * @details
7216  *
7217  *    Function : extractRlcUmUlCfg
7218  *
7219  *    Functionality: Function to build Um Ul Info
7220  *
7221  * @params[in] UmUniDirUlBearerCfg *
7222  *             void *
7223  *
7224  * @return ROK/RFAILED
7225  *
7226  * ****************************************************************/
7227
7228 void extractRlcUmUlCfg(UmUniDirUlBearerCfg *umUlCfgToSet, struct RLC_Config__um_Uni_Directional_DL *umUlCfg)
7229 {
7230    if(umUlCfg)
7231    {
7232       if(umUlCfg->dl_UM_RLC.sn_FieldLength)
7233       {
7234          umUlCfgToSet->ulUmCfg.snLenUlUm  = *(umUlCfg->dl_UM_RLC.sn_FieldLength);
7235          umUlCfgToSet->ulUmCfg.reAssemTmr = umUlCfg->dl_UM_RLC.t_Reassembly;
7236       }
7237    }
7238 }
7239
7240 /*******************************************************************
7241  *
7242  * @brief Function to build Um Uni Dl Info
7243  *
7244  * @details
7245  *
7246  *    Function : extractRlcUmDlCfg
7247  *
7248  *    Functionality: Function to build Um Uni Dl Info
7249  *
7250  * @params[in] UmUniDirDlBearerCfg *
7251  *             void *
7252  *
7253  * @return ROK/RFAILED
7254  *
7255  * ****************************************************************/
7256 void extractRlcUmDlCfg(UmUniDirDlBearerCfg *umDlCfgToSet, struct RLC_Config__um_Uni_Directional_UL *umDlCfg)
7257 {
7258    if(umDlCfg)
7259    {
7260       if(umDlCfg->ul_UM_RLC.sn_FieldLength)
7261          umDlCfgToSet->dlUmCfg.snLenDlUm  = *(umDlCfg->ul_UM_RLC.sn_FieldLength);
7262    }
7263 }
7264
7265 /*******************************************************************
7266  *
7267  * @brief Function to extractRlcModeCfg
7268  *
7269  * @details
7270  *
7271  *    Function : extractRlcModeCfg
7272  *
7273  *    Functionality: Function to extractRlcModeCfg
7274  *
7275  * @params[in] RLC_Config_t *
7276  *             RlcBearerCfg *
7277  *             void  *
7278  * @return ROK/RFAILED
7279  *
7280  * ****************************************************************/
7281 void extractRlcModeCfg(uint8_t rlcMode, RlcBearerCfg *rlcDbCfg, RLC_Config_t *lcCfg)
7282 {
7283    if(lcCfg)
7284    {
7285       switch(rlcMode)
7286       {
7287          case RLC_AM :
7288             {
7289                if(lcCfg->choice.am)
7290                {
7291                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.amCfg, sizeof(AmBearerCfg));
7292                   if(rlcDbCfg->u.amCfg)
7293                      extractRlcAmCfg(rlcDbCfg->u.amCfg, lcCfg->choice.am);
7294                }
7295                break;
7296             }
7297          case RLC_UM_BI_DIRECTIONAL :
7298             {
7299                if(lcCfg->choice.um_Bi_Directional)
7300                {
7301                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
7302                   if(rlcDbCfg->u.umBiDirCfg)
7303                      extractRlcUmBiCfg(rlcDbCfg->u.umBiDirCfg, lcCfg->choice.um_Bi_Directional);
7304                }
7305                break;
7306             }
7307          case RLC_UM_UNI_DIRECTIONAL_UL :
7308             {
7309                if(lcCfg->choice.um_Uni_Directional_DL)
7310                {
7311                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
7312                   if(rlcDbCfg->u.umUniDirUlCfg)
7313                      extractRlcUmUlCfg(rlcDbCfg->u.umUniDirUlCfg, lcCfg->choice.um_Uni_Directional_DL);
7314                }
7315                break;
7316             }
7317          case RLC_UM_UNI_DIRECTIONAL_DL :
7318             {
7319                if(lcCfg->choice.um_Uni_Directional_UL)
7320                {
7321                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
7322                   if(rlcDbCfg->u.umUniDirDlCfg)
7323                      extractRlcUmDlCfg(rlcDbCfg->u.umUniDirDlCfg, lcCfg->choice.um_Uni_Directional_UL);
7324                }
7325                break;
7326             }
7327          default:
7328             DU_LOG("\nERROR  -->  DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
7329             break;
7330       }
7331    }
7332 }
7333
7334 /*******************************************************************
7335  *
7336  * @brief Function to extract extractUlLcCfg
7337  *
7338  * @details
7339  *
7340  *    Function : extractUlLcCfg
7341  *
7342  *    Functionality: Function to extract extractUlLcCfg
7343  *
7344  * @params[in] UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg
7345  * @return void
7346  *
7347  * ****************************************************************/
7348
7349 void extractUlLcCfg(UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg)
7350 {
7351    if(ulLcCfg)
7352    {
7353       if(ulLcCfg->ul_SpecificParameters)
7354       {
7355          f1UlLcCfg->priority = \
7356             ulLcCfg->ul_SpecificParameters->priority;
7357       if(ulLcCfg->ul_SpecificParameters->logicalChannelGroup)
7358       {
7359          f1UlLcCfg->lcGroup = \
7360            *(ulLcCfg->ul_SpecificParameters->logicalChannelGroup);
7361       }
7362       if(ulLcCfg->ul_SpecificParameters->schedulingRequestID)
7363       {
7364          f1UlLcCfg->schReqId = \
7365            *(ulLcCfg->ul_SpecificParameters->schedulingRequestID);
7366       }
7367       f1UlLcCfg->pbr = \
7368          ulLcCfg->ul_SpecificParameters->prioritisedBitRate;
7369       f1UlLcCfg->bsd = \
7370          ulLcCfg->ul_SpecificParameters->bucketSizeDuration;
7371       }
7372    }
7373 }
7374
7375 /*******************************************************************
7376  *
7377  * @brief Function to procRlcLcCfg
7378  *
7379  * @details
7380  *
7381  *    Function : procRlcLcCfg
7382  *
7383  *    Functionality: Function to procRlcLcCfg
7384  *
7385  * @params[in] rbId, lcId, rbType, rlcMod
7386  *             RLC_Config_t *, RlcBearerCfg * ,
7387  * @return void
7388  *
7389  * ****************************************************************/
7390
7391 void procRlcLcCfg(uint8_t rbId, uint8_t lcId, uint8_t rbType, uint8_t rlcMode,\
7392    uint8_t configType, RLC_Config_t *f1RlcCfg, RlcBearerCfg *lcCfg)
7393 {
7394
7395    lcCfg->rbId   = rbId;
7396    lcCfg->configType = configType;
7397
7398    if(rbType == RB_TYPE_SRB)
7399    {
7400       lcCfg->rbType = RB_TYPE_SRB;
7401       lcCfg->lcId   = rbId;
7402       lcCfg->lcType = LCH_DCCH;
7403       lcCfg->rlcMode = RLC_AM;
7404    }
7405    else if(rbType == RB_TYPE_DRB)
7406    {
7407       lcCfg->rbType = RB_TYPE_DRB;
7408       lcCfg->lcId   = lcId;
7409       lcCfg->lcType = LCH_DTCH;
7410       lcCfg->rlcMode = rlcMode;
7411    }
7412    if(f1RlcCfg) /* rlc mode config recived */
7413    {
7414       extractRlcModeCfg(lcCfg->rlcMode, lcCfg, f1RlcCfg);
7415    }
7416 }
7417
7418
7419
7420 /*******************************************************************
7421  *
7422  * @brief Fills DrbQos Info received by CU
7423  *
7424  * @details
7425  *
7426  *    Function : extractQosInfo
7427  *
7428  *    Functionality: Fills DrbQos Info received  by CU
7429  *
7430  * @params[in] DrbQosInfo *qosToAdd,
7431  *             QoSFlowLevelQoSParameters_t *qosFlowCfg
7432  * @return void
7433  *
7434  * ****************************************************************/
7435
7436 void extractQosInfo(DrbQosInfo *qosToAdd, QoSFlowLevelQoSParameters_t *qosFlowCfg)
7437 {
7438    uint8_t qosCntIdx = 0;
7439    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
7440
7441    qosToAdd->fiveQiType = qosFlowCfg->qoS_Characteristics.present;
7442    qosToAdd->u.nonDyn5Qi.fiveQi     =\
7443                                      qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
7444    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow)
7445    {
7446       qosToAdd->u.nonDyn5Qi.avgWindow = \
7447                                         *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
7448    }
7449    qosToAdd->u.nonDyn5Qi.maxDataBurstVol = \
7450                                            *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
7451    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel)
7452    {
7453       qosToAdd->u.nonDyn5Qi.priorLevel = \
7454                                          *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel);
7455    }
7456    qosToAdd->ngRanRetPri.priorityLevel = \
7457                                          qosFlowCfg->nGRANallocationRetentionPriority.priorityLevel;
7458    qosToAdd->ngRanRetPri.preEmptionCap = \
7459                                          qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionCapability;
7460    qosToAdd->ngRanRetPri.preEmptionVul = \
7461                                          qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionVulnerability;
7462    if(qosFlowCfg->gBR_QoS_Flow_Information)
7463    {
7464       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateDl, \
7465             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.buf, \
7466             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.size);
7467       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateUl, \
7468             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.buf, \
7469             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.size);
7470       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateDl,\
7471             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.buf, \
7472             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.size);
7473       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateUl,\
7474             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.buf, \
7475             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.size);
7476    }
7477    /*Extracting PDU_SESSION_ID*/
7478    qosIeExt = (ProtocolExtensionContainer_4624P74_t *)qosFlowCfg->iE_Extensions;
7479    if(qosIeExt)
7480    {
7481       for(qosCntIdx = 0; qosCntIdx < qosIeExt->list.count; qosCntIdx++)
7482       {
7483          if(qosIeExt->list.array[qosCntIdx]->extensionValue.present == \
7484                QoSFlowLevelQoSParameters_ExtIEs__extensionValue_PR_PDUSessionID)
7485          {
7486             qosToAdd->pduSessionId = qosIeExt->list.array[qosCntIdx]->extensionValue.choice.PDUSessionID;
7487             DU_LOG("\nDEBUG -->  DU_F1AP : extractQosInfo: PDU SessionID:%d",qosToAdd->pduSessionId);
7488          }
7489       }
7490    }
7491    qosToAdd->ulPduSessAggMaxBitRate = 0;
7492 }
7493
7494 /*******************************************************************
7495  *
7496  * @brief Function to extract GTP Tunnel Info from CU
7497  *
7498  * @details
7499  *
7500  *    Function : extractUpTnlInfo
7501  *
7502  *    Functionality: Function to extract GTP Tunnel Info from CU
7503  *
7504  * @params[in] F1AP message
7505  * @return ROK/RFAILED
7506  *
7507  * ****************************************************************/
7508
7509 uint8_t extractUpTnlInfo(uint8_t drbId, uint8_t configType,\
7510    ULUPTNLInformation_ToBeSetup_List_t *tnlInfo, UpTnlCfg *upTnlInfo)
7511 {
7512    uint8_t tnlIdx;
7513    uint32_t ipv4_du = 0;
7514    GTPTunnel_t *gtpTunnel = NULLP;
7515
7516    upTnlInfo->drbId = drbId;
7517    upTnlInfo->configType = configType;
7518 #ifdef O1_ENABLE
7519    cmInetAddr((S8*)g_cfg.DU_IPV4_Addr, &ipv4_du);
7520 #else
7521    cmInetAddr((char *)DU_IP_V4_ADDR, &ipv4_du);
7522 #endif
7523
7524    for(tnlIdx=0; tnlIdx < tnlInfo->list.count; tnlIdx++)
7525    {
7526       if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
7527       {
7528          if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel)
7529          {
7530             gtpTunnel = tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel;
7531             DU_ALLOC(upTnlInfo->tnlCfg1, sizeof(GtpTnlCfg));
7532             if(upTnlInfo->tnlCfg1 == NULLP)
7533             {
7534                DU_LOG("\nERROR  -->  F1AP : extractUpTnlInfo: Failed to allocate mmeory for tunnel cfg 1");
7535                return RFAILED;
7536             }
7537             bitStringToInt(&gtpTunnel->transportLayerAddress, &upTnlInfo->tnlCfg1->ulTnlAddress);
7538             upTnlInfo->tnlCfg1->dlTnlAddress = ipv4_du;
7539             if(gtpTunnel->gTP_TEID.size > 0)
7540             {
7541                teIdStringToInt(gtpTunnel->gTP_TEID.buf, &upTnlInfo->tnlCfg1->teId);
7542             }
7543          }
7544          break;
7545       }
7546    }
7547    return ROK;
7548 }
7549 /*******************************************************************
7550 *
7551 * @brief Function to extract Drb Qos Cfg Info from CU
7552 *
7553 * @details
7554 *
7555 *    Function : extractDrbQosCfg
7556 *
7557 *    Functionality: Function to extract Drb Qos Cfg Info from CU
7558 *
7559 * @params[in] DRB_Information_t *drbInfo, LcCfg *macLcToAdd
7560 * @return ROK/RFAILED
7561 *
7562 * ****************************************************************/
7563
7564 uint8_t extractDrbQosCfg(DRB_Information_t *drbInfo, LcCfg *macLcToAdd )
7565 {
7566    if(!macLcToAdd->drbQos)
7567    {
7568       DU_ALLOC_SHRABL_BUF(macLcToAdd->drbQos, sizeof(DrbQosInfo));
7569       if(macLcToAdd->drbQos == NULLP)
7570       {
7571          DU_LOG("\nERROR  -->  DUAPP:Memory failed at allocating DrbQos at extractDrbQosCfg()");
7572          return RFAILED;
7573       }
7574
7575    }
7576    if(drbInfo->dRB_QoS.qoS_Characteristics.present == QoS_Characteristics_PR_non_Dynamic_5QI)
7577    {
7578       extractQosInfo(macLcToAdd->drbQos, &drbInfo->dRB_QoS);
7579       macLcToAdd->dlLcCfg.lcp = macLcToAdd->drbQos->ngRanRetPri.priorityLevel;
7580    }
7581    if(!macLcToAdd->snssai)
7582    {
7583       DU_ALLOC_SHRABL_BUF(macLcToAdd->snssai, sizeof(Snssai));
7584       if(macLcToAdd->snssai == NULLP)
7585       {
7586          DU_LOG("\nERROR  -->  DUAPP : Memory failed at allocating SNSSAI at extractDrbQosCfg()");
7587          return RFAILED;
7588       }
7589    }
7590    memcpy(&macLcToAdd->snssai->sst, drbInfo->sNSSAI.sST.buf, \
7591          drbInfo->sNSSAI.sST.size);
7592    if(drbInfo->sNSSAI.sD)
7593    {
7594       memcpy(macLcToAdd->snssai->sd, drbInfo->sNSSAI.sD->buf, \
7595             drbInfo->sNSSAI.sD->size);
7596    }
7597    return ROK;
7598 }
7599 /*******************************************************************
7600  *
7601  * @brief Function to extract DRB info received from CU
7602  *
7603  * @details
7604  *
7605  *    Function : extractDrbCfg
7606  *
7607  *    Functionality: Function to extract DRB info received from CU
7608  *
7609  * @params[in] F1AP message
7610  * @return void
7611  *
7612  * ****************************************************************/
7613 uint8_t extractDrbCfg(DRBs_ToBeSetup_Item_t *drbItem, DRBs_ToBeSetupMod_Item_t *drbSetupModItem,\
7614 DRBs_ToBeModified_Item_t *drbModItem,  LcCfg *macLcToAdd, UpTnlCfg *upTnlInfo)
7615 {
7616    DRB_Information_t *drbInfo = NULLP;
7617
7618    if(drbItem != NULLP)
7619    {
7620       if(extractUpTnlInfo(drbItem->dRBID, CONFIG_ADD, &drbItem->uLUPTNLInformation_ToBeSetup_List, upTnlInfo) != ROK)
7621       {
7622          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7623          return RFAILED;
7624       }
7625       if(drbItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7626       {
7627          if(drbItem->qoSInformation.choice.choice_extension->value.present == QoSInformation_ExtIEs__value_PR_DRB_Information)
7628          {
7629             drbInfo = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7630             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7631             {
7632                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7633                return RFAILED;
7634             }
7635          }
7636       }
7637    }
7638    else if(drbSetupModItem != NULLP)
7639    {
7640       if(extractUpTnlInfo(drbSetupModItem->dRBID, CONFIG_ADD, &drbSetupModItem->uLUPTNLInformation_ToBeSetup_List,\
7641       upTnlInfo) != ROK)
7642       {
7643          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7644          return RFAILED;
7645       }
7646       if(drbSetupModItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7647       {
7648          if(drbSetupModItem->qoSInformation.choice.choice_extension->value.present ==\
7649          QoSInformation_ExtIEs__value_PR_DRB_Information)
7650          {
7651             drbInfo = &drbSetupModItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7652             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7653             {
7654                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7655                return RFAILED;
7656             }
7657
7658          }
7659       }
7660    }
7661    else if(drbModItem != NULLP)
7662    {
7663       if(extractUpTnlInfo(drbModItem->dRBID, CONFIG_MOD, &drbModItem->uLUPTNLInformation_ToBeSetup_List,\
7664       upTnlInfo) != ROK)
7665       {
7666          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7667          return RFAILED;
7668       }
7669       if(drbModItem->qoSInformation != NULLP)
7670       {
7671          if(drbModItem->qoSInformation->present == QoSInformation_PR_choice_extension)
7672          {
7673             if(drbModItem->qoSInformation->choice.choice_extension->value.present ==\
7674                   QoSInformation_ExtIEs__value_PR_DRB_Information)
7675             {
7676                drbInfo = &drbModItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information;
7677                if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7678                {
7679                   DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7680                   return RFAILED;
7681                }
7682
7683             }
7684          }
7685       }
7686    }
7687    return ROK;
7688 }
7689
7690 /*******************************************************************
7691  *
7692  * @brief Function to extract RB info received from CU
7693  *
7694  * @details
7695  *
7696  *    Function : extractMacRbCfg
7697  *
7698  *    Functionality: Function to extract RB info received from CU
7699  *
7700  * @params[in] F1AP message
7701  * @return ROK/RFAILED
7702  *
7703  * ****************************************************************/
7704
7705 uint8_t extractMacRbCfg(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbCfg,\
7706 DRBs_ToBeSetupMod_Item_t *drbSetupModCfg,  DRBs_ToBeModified_Item_t *drbModCfg, LogicalChannelConfig_t *ulLcCfg, LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7707 {
7708    if(drbCfg != NULLP)
7709    {
7710       if(extractDrbCfg(drbCfg, NULL, NULL, lcCfg, upTnlInfo) != ROK)
7711       {
7712          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7713          return RFAILED;
7714       }
7715    }
7716    else if(drbSetupModCfg != NULLP)
7717    {
7718       if(extractDrbCfg(NULL, drbSetupModCfg, NULL, lcCfg, upTnlInfo) != ROK)
7719       {
7720          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7721          return RFAILED;
7722       }
7723    }
7724    else if(drbModCfg != NULLP)
7725    {
7726       if(extractDrbCfg(NULL, NULL, drbModCfg, lcCfg, upTnlInfo) != ROK)
7727       {
7728          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7729          return RFAILED;
7730       }
7731    }
7732    else
7733    {
7734       lcCfg->drbQos = NULLP;
7735       lcCfg->snssai = NULLP;
7736       if(lcCfg->lcId == SRB2_LCID)
7737          lcCfg->dlLcCfg.lcp = LC_PRIORITY_3;
7738       else
7739          lcCfg->dlLcCfg.lcp = LC_PRIORITY_1;
7740    }
7741    if(ulLcCfg)
7742    {
7743       lcCfg->ulLcCfgPres = true;
7744       extractUlLcCfg(&lcCfg->ulLcCfg, ulLcCfg);
7745    }
7746    else
7747       lcCfg->ulLcCfgPres = false;
7748    return ROK;
7749 }
7750
7751 /*******************************************************************
7752  *
7753  * @brief Function processing LC config info received from CU
7754  *
7755  * @details
7756  *
7757  *    Function : procMacLcCfg
7758  *
7759  *    Functionality: Function processing LC config info received from CU
7760  *
7761  * @params[in] F1AP message
7762  * @return ROK/RFAILED
7763  *
7764  * ****************************************************************/
7765
7766 uint8_t procMacLcCfg(uint8_t lcId, uint8_t rbType, uint8_t configType, DRBs_ToBeSetup_Item_t *drbItem,\
7767 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, LogicalChannelConfig_t *ulLcCfg,\
7768 LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7769 {
7770    uint8_t ret = ROK;
7771
7772    lcCfg->lcId = lcId;
7773    lcCfg->configType = configType;
7774    if(rbType == RB_TYPE_SRB)
7775    {
7776       ret = extractMacRbCfg(lcId, NULL, NULL, NULL, ulLcCfg, lcCfg, NULL);
7777    }
7778    else if(rbType == RB_TYPE_DRB)
7779    {
7780       if(drbItem != NULL)
7781         ret = extractMacRbCfg(lcId, drbItem, NULL, NULL, ulLcCfg, lcCfg, upTnlInfo);
7782       else if(drbSetupModItem != NULL)
7783         ret = extractMacRbCfg(lcId, NULL, drbSetupModItem, NULL, ulLcCfg, lcCfg, upTnlInfo);
7784       else if(drbModItem != NULL)
7785         ret = extractMacRbCfg(lcId, NULL, NULL, drbModItem, ulLcCfg, lcCfg, upTnlInfo);
7786    }
7787    return ret;
7788 }
7789
7790 /*******************************************************************
7791  *
7792  * @brief Function to extract Rlc cfg To Add/Mod in CellGrp Info
7793  *
7794  * @details
7795  *
7796  *    Function : extractRlcCfgToAddMod
7797  *
7798  *    Functionality: Function to extract Rlc cfg To Add/Mod in CellGrp Info
7799  *
7800  * @params[in] CellGroupConfigRrc__rlc_BearerTo pointer
7801  *             DuUeCfg Pointer
7802  * @return ROK/RFAILED
7803  *
7804  * ****************************************************************/
7805
7806 uint8_t extractRlcCfgToAddMod(struct CellGroupConfigRrc__rlc_BearerToAddModList *lcCfg, DuUeCfg *ueCfgDb)
7807 {
7808   uint8_t idx, rbId, lcId, rlcMode, rbType;
7809   RLC_Config_t *f1RlcCfg = NULLP;
7810   LogicalChannelConfig_t *macUlLcCfg = NULLP;
7811
7812   for(idx = 0; idx < lcCfg->list.count; idx++)
7813   {
7814      lcId = lcCfg->list.array[idx]->logicalChannelIdentity;
7815      if(lcCfg->list.array[idx]->servedRadioBearer)
7816      {
7817         /* RadioBearer for SRB/DRB */
7818         if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7819         RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
7820         {
7821            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.srb_Identity;
7822            rbType = RB_TYPE_SRB;
7823         }
7824         else if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7825         RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
7826         {
7827            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.drb_Identity;
7828            rbType = RB_TYPE_DRB;
7829         }
7830         else
7831         {
7832            DU_LOG("\nERROR  -->  No components present in Bearer config to ADD/MOD");
7833            return RFAILED;
7834         }
7835         /* MAC UL LC Config */
7836         if(lcCfg->list.array[idx]->mac_LogicalChannelConfig)
7837         {
7838            macUlLcCfg = lcCfg->list.array[idx]->mac_LogicalChannelConfig;
7839         }
7840      }
7841      else
7842      {
7843         DU_LOG("\nERROR  -->  DUAPP: Received RadioBearer config is NULL");
7844         return RFAILED;
7845      }
7846      /* RLC Mode Config */
7847      if(lcCfg->list.array[idx]->rlc_Config)
7848      {
7849         rlcMode  = lcCfg->list.array[idx]->rlc_Config->present;
7850         f1RlcCfg = lcCfg->list.array[idx]->rlc_Config;
7851      }
7852
7853      /* Filling RLC/MAC Config*/
7854      memset(&ueCfgDb->macLcCfg[idx], 0, sizeof(LcCfg));
7855      memset(&ueCfgDb->rlcLcCfg[idx], 0, sizeof(RlcBearerCfg));
7856      procRlcLcCfg(rbId, lcId, rbType, rlcMode, CONFIG_UNKNOWN, f1RlcCfg, &(ueCfgDb->rlcLcCfg[idx]));
7857      if(procMacLcCfg(lcId, rbType, CONFIG_UNKNOWN, NULL, NULL, NULL, macUlLcCfg, &ueCfgDb->macLcCfg[idx], NULL) != ROK)
7858      {
7859         DU_LOG("\nERROR  -->  DU APP : Failed while filling MAC LC config at extractRlcCfgToAddMod()");
7860         return RFAILED;
7861      }
7862      (ueCfgDb->numRlcLcs)++;
7863      (ueCfgDb->numMacLcs)++;
7864          DU_LOG("\nDEBUG  -> DUAPP: extractRlcCfgToAddMod:RBType:%d, DrbID: %d,lcId:%d, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
7865                             rbType, rbId, lcId, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
7866   }
7867   //TODO: To send the failure cause in UeContextSetupRsp
7868   return ROK;
7869 }
7870
7871 /*******************************************************************
7872  *
7873  * @brief DeAlloc pdsch serv cell config info
7874  *
7875  * @details
7876  *
7877  *    Function : freeMacPdschServCellInfo
7878  *
7879  *    Functionality: DeAlloc pdsch serv cell config info
7880  *
7881  * @params[in] PdschServCellCfg pointer
7882  * @return void
7883  *
7884  * ****************************************************************/
7885
7886 void freeMacPdschServCellInfo(PdschServCellCfg *pdsch)
7887 {
7888    if(pdsch->xOverhead)
7889    {
7890       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->xOverhead, sizeof(PdschXOverhead));
7891    }
7892    if(pdsch->codeBlkGrpFlushInd)
7893    {
7894       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->codeBlkGrpFlushInd, sizeof(bool));
7895    }
7896    if(pdsch->maxCodeBlkGrpPerTb)
7897    {
7898       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
7899    }
7900    if(pdsch->maxMimoLayers)
7901    {
7902       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxMimoLayers, sizeof(uint8_t));
7903    }
7904 }
7905
7906 /*******************************************************************
7907  *
7908  * @brief Free Serving cell Info
7909  *
7910  * @details
7911  *
7912  *    Function : freeMacServingCellInfo
7913  *
7914  *    Functionality: Free Serving cell Info
7915  *
7916  * @params[in] ServCellCfgInfo *srvCellCfg
7917  * @return void
7918  *
7919  * ****************************************************************/
7920 void freeMacServingCellInfo(ServCellCfgInfo *srvCellCfg)
7921 {
7922    uint8_t timeDomRsrcIdx;
7923
7924    if(srvCellCfg->initDlBwp.pdschPresent)
7925    {
7926       for(timeDomRsrcIdx = 0; timeDomRsrcIdx < srvCellCfg->initDlBwp.pdschCfg.numTimeDomRsrcAlloc; timeDomRsrcIdx++)
7927       {
7928          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, \
7929             srvCellCfg->initDlBwp.pdschCfg.timeDomRsrcAllociList[timeDomRsrcIdx].k0, sizeof(uint8_t));
7930       }
7931    }
7932
7933    freeMacPdschServCellInfo(&srvCellCfg->pdschServCellCfg);
7934    if(srvCellCfg->bwpInactivityTmr)
7935    {
7936       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
7937    }
7938
7939    if(srvCellCfg->initUlBwp.pucchPresent)
7940    {
7941       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->initUlBwp.pucchCfg.dlDataToUlAck, sizeof(PucchDlDataToUlAck));
7942    }
7943 }
7944
7945 /*******************************************************************
7946  *
7947  * @brief Free cell Grp Cfg Info
7948  *
7949  * @details
7950  *
7951  *    Function : freeUeReCfgCellGrpInfo
7952  *
7953  *    Functionality: Free cell Grp Cfg Info
7954  *
7955  * @params[in] MacUeCfg*  duUeCfg
7956  * @return void
7957  *
7958  * ****************************************************************/
7959
7960 void freeUeReCfgCellGrpInfo(MacUeCfg *macUeCfg)
7961 {
7962    freeMacServingCellInfo(&macUeCfg->spCellCfg.servCellCfg);
7963 }
7964
7965 /*******************************************************************
7966  *
7967  * @brief Fills Reconfig SchReqReConfig
7968  *
7969  * @details
7970  *
7971  *    Function : extractSchReqReConfig
7972  *
7973  *    Functionality: Fills Reconfig SchReqReConfig
7974  *
7975  * @params[in] SchedulingRequestConfig_t *cuSchedReq
7976  *             SchedReqCfg*  macSchedReq
7977  * @return void
7978  *
7979  * ****************************************************************/
7980 void extractSchReqReConfig(SchedulingRequestConfig_t *cuSchedReq, SchedReqCfg *macSchedReq)
7981 {
7982    uint8_t schReqIdx = 0;
7983    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqListToAdd = NULLP;
7984    struct SchedulingRequestConfig__schedulingRequestToReleaseList *schReqListToRel = NULLP;
7985
7986    if(cuSchedReq->schedulingRequestToAddModList)
7987    {
7988       schReqListToAdd = cuSchedReq->schedulingRequestToAddModList;
7989       if(schReqListToAdd->list.count)
7990       {
7991          macSchedReq->addModListCount = schReqListToAdd->list.count;
7992          for(schReqIdx = 0; schReqIdx < schReqListToAdd->list.count; schReqIdx++)
7993          {
7994             macSchedReq->addModList[schReqIdx].schedReqId = \
7995                schReqListToAdd->list.array[schReqIdx]->schedulingRequestId;
7996             macSchedReq->addModList[schReqIdx].srProhibitTmr = \
7997                *(schReqListToAdd->list.array[schReqIdx]->sr_ProhibitTimer);
7998             macSchedReq->addModList[schReqIdx].srTransMax    =\
7999                schReqListToAdd->list.array[schReqIdx]->sr_TransMax;
8000          }
8001       }
8002    }
8003    /* Scheduling Req To release */
8004    if(cuSchedReq->schedulingRequestToReleaseList)
8005    {
8006       schReqListToRel = cuSchedReq->schedulingRequestToReleaseList;
8007       if(schReqListToRel->list.count)
8008       {
8009          macSchedReq->relListCount = schReqListToRel->list.count;
8010          for(schReqIdx = 0; schReqIdx < schReqListToRel->list.count; schReqIdx++)
8011          {
8012             macSchedReq->relList[schReqIdx] = \
8013                *schReqListToRel->list.array[schReqIdx];
8014          }
8015       }
8016    }
8017 }
8018
8019 /*******************************************************************
8020  *
8021  * @brief Fills TagReconfig
8022  *
8023  * @details
8024  *
8025  *    Function : extractTagReconfig
8026  *
8027  *    Functionality: Fills extractTagReconfig
8028  *
8029  * @params[in] TAG_Config_t *cuTagCfg
8030  *             TagCfg *macTagCfg
8031  * @return void
8032  *
8033  * ****************************************************************/
8034
8035 void extractTagReconfig(TAG_Config_t *cuTagCfg, TagCfg *macTagCfg)
8036 {
8037   uint8_t tagIdx = 0;
8038   struct TAG_Config__tag_ToAddModList  *tagListToAddMod = NULLP;
8039   struct TAG_Config__tag_ToReleaseList *tagListToRel = NULLP;
8040
8041   /* Tag config to AddMod */
8042   if(cuTagCfg->tag_ToAddModList)
8043   {
8044      tagListToAddMod = cuTagCfg->tag_ToAddModList;
8045      if(tagListToAddMod->list.count)
8046      {
8047         macTagCfg->addModListCount = tagListToAddMod->list.count;
8048         for(tagIdx = 0; tagIdx < tagListToAddMod->list.count; tagIdx++)
8049         {
8050            macTagCfg->addModList[tagIdx].tagId =\
8051               tagListToAddMod->list.array[tagIdx]->tag_Id;
8052            macTagCfg->addModList[tagIdx].timeAlignTimer = \
8053
8054               tagListToAddMod->list.array[tagIdx]->timeAlignmentTimer;
8055         }
8056      }
8057   }
8058   /* Tag config to release */
8059   if(cuTagCfg->tag_ToReleaseList)
8060   {
8061      tagListToRel = cuTagCfg->tag_ToReleaseList;
8062      if(tagListToRel->list.count)
8063      {
8064         macTagCfg->relListCount = tagListToRel->list.count;
8065         for(tagIdx = 0; tagIdx < tagListToRel->list.count; tagIdx++)
8066         {
8067            macTagCfg->relList[tagIdx] = *tagListToRel->list.array[tagIdx];
8068         }
8069      }
8070   }
8071 }
8072
8073 /*******************************************************************
8074  *
8075  * @brief Fills PdcchCfg received by CU
8076  *
8077  * @details
8078  *
8079  *    Function : extractPdcchCfg
8080  *
8081  *    Functionality: Fills PdcchCfg received  by CU
8082  *
8083  * @params[in] PDCCH_Config_t *cuPdcchCfg,
8084  *             PdcchConfig *duPdcchCfg
8085  * @return void
8086  *
8087  * ****************************************************************/
8088
8089 void extractPdcchCfg(PDCCH_Config_t *cuPdcchCfg, PdcchConfig *macPdcchCfg)
8090 {
8091    uint8_t cRsetIdx = 0;
8092    uint8_t srchSpcIdx = 0;
8093
8094    struct PDCCH_Config__controlResourceSetToAddModList *cRsetToAddModList = NULLP;
8095    struct PDCCH_Config__controlResourceSetToReleaseList *cRsetToRelList = NULLP;
8096    struct PDCCH_Config__searchSpacesToAddModList *srchSpcToAddModList = NULLP;
8097    struct PDCCH_Config__searchSpacesToReleaseList *srchSpcToRelList = NULLP;
8098
8099
8100    /* Control Resource Set To Add/Mod List */
8101    if(cuPdcchCfg->controlResourceSetToAddModList)
8102    {
8103       cRsetToAddModList = cuPdcchCfg->controlResourceSetToAddModList;
8104       if(cRsetToAddModList->list.count)
8105       {
8106          macPdcchCfg->numCRsetToAddMod = cRsetToAddModList->list.count;
8107          for(cRsetIdx = 0; cRsetIdx < cRsetToAddModList->list.count; cRsetIdx++)
8108          {
8109             macPdcchCfg->cRSetToAddModList[cRsetIdx].cRSetId = \
8110               cRsetToAddModList->list.array[cRsetIdx]->controlResourceSetId;
8111             bitStringToInt(&cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources,\
8112                macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc);
8113             macPdcchCfg->cRSetToAddModList[cRsetIdx].duration = \
8114               cRsetToAddModList->list.array[cRsetIdx]->duration;
8115
8116             macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType = \
8117               cRsetToAddModList->list.array[cRsetIdx]->cce_REG_MappingType.present;
8118             if(macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType == CCE_REG_MAPPINGTYPE_PR_INTERLEAVED)
8119             {
8120                //TODO: handle the case for Interleaved
8121             }
8122             macPdcchCfg->cRSetToAddModList[cRsetIdx].precoderGranularity = \
8123               cRsetToAddModList->list.array[cRsetIdx]->precoderGranularity;
8124             if(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID)
8125             {
8126                macPdcchCfg->cRSetToAddModList[cRsetIdx].dmrsScramblingId= \
8127                   *(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID);
8128             }
8129          }
8130       }
8131
8132    }
8133    /* Control Resource Set To Release List */
8134    if(cuPdcchCfg->controlResourceSetToReleaseList)
8135    {
8136       cRsetToRelList = cuPdcchCfg->controlResourceSetToReleaseList;
8137       if(cRsetToRelList->list.count)
8138       {
8139          macPdcchCfg->numCRsetToRel = cRsetToRelList->list.count;
8140          for(cRsetIdx = 0; cRsetIdx < cRsetToRelList->list.count; cRsetIdx++)
8141          {
8142             macPdcchCfg->cRSetToRelList[cRsetIdx] = *(cRsetToRelList->list.array[cRsetIdx]);
8143          }
8144       }
8145    }
8146
8147    /* Search space To Add/Mod List */
8148    if(cuPdcchCfg->searchSpacesToAddModList)
8149    {
8150       srchSpcToAddModList = cuPdcchCfg->searchSpacesToAddModList;
8151       if(srchSpcToAddModList->list.count)
8152       {
8153          macPdcchCfg->numSearchSpcToAddMod = srchSpcToAddModList->list.count;
8154          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToAddModList->list.count; srchSpcIdx++)
8155          {
8156             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceId =\
8157                srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceId;
8158             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].cRSetId =\
8159                *(srchSpcToAddModList->list.array[srchSpcIdx]->controlResourceSetId);
8160             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset)
8161             {
8162                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset =\
8163                   srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset->present;
8164             }
8165             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot)
8166             {
8167                bitStringToInt(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot,\
8168                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSymbolsWithinSlot);
8169             }
8170             if(srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates)
8171             {
8172               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel1 = \
8173                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel1;
8174               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel2 = \
8175                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel2;
8176               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel4 = \
8177                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel4;
8178
8179               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel8 = \
8180                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel8;
8181
8182               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel16 = \
8183                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel16;
8184             }
8185             if(srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType)
8186             {
8187                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType =\
8188                   srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->present;
8189                if(macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType == SEARCHSPACETYPE_PR_UE_SPECIFIC)
8190                {
8191                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].ueSpecificDciFormat =\
8192                      srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->choice.ue_Specific->dci_Formats;
8193                }
8194
8195             }
8196          }
8197       }
8198    }
8199    /* Search space To Rel List */
8200    if(cuPdcchCfg->searchSpacesToReleaseList)
8201    {
8202       srchSpcToRelList = cuPdcchCfg->searchSpacesToReleaseList;
8203       if(srchSpcToRelList->list.count)
8204       {
8205          macPdcchCfg->numSearchSpcToRel = srchSpcToRelList->list.count;
8206          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToRelList->list.count; srchSpcIdx++)
8207          {
8208             macPdcchCfg->searchSpcToRelList[srchSpcIdx] =\
8209                *(srchSpcToRelList->list.array[srchSpcIdx]);
8210          }
8211       }
8212    }
8213 }
8214
8215 /*******************************************************************
8216  *
8217  * @brief Fills PdschCfg received by CU
8218  *
8219  * @details
8220  *
8221  *    Function : extractPdschCfg
8222  *
8223  *    Functionality: Fills PdschCfg received  by CU
8224  *
8225  * @params[in] PDSCH_Config_t *cuPdschCfg = Information which is send by CU,
8226  *                   which we have stored in F1UeContextSetupDb,
8227  *             PdschConfig *macPdschCfg = Used to Store the information which
8228  *                   needs to send in other layer, as well as this can be the variable
8229  *                   which stores the information in DuCb,
8230  *             PdschConfig *storedPdschCfg =  Null in case of sending the
8231  *                   information to other layer else it will have stored pdsch
8232  *                   configuration in copyOfmacUeCfg.
8233  * @return void
8234  *
8235  * ****************************************************************/
8236
8237 void extractPdschCfg(PDSCH_Config_t *cuPdschCfg, PdschConfig *macPdschCfg, PdschConfig *storedPdschCfg)
8238 {
8239    uint8_t timeDomIdx;
8240    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAlloc = NULLP;
8241
8242    if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
8243    {
8244       if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->present == \
8245             PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup)
8246       {
8247          if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup)
8248          {
8249             macPdschCfg->dmrsDlCfgForPdschMapTypeA.addPos = \
8250                *(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_AdditionalPosition);
8251          }
8252       }
8253    }
8254    macPdschCfg->resourceAllocType = cuPdschCfg->resourceAllocation;
8255    if(cuPdschCfg->pdsch_TimeDomainAllocationList)
8256    {
8257       timeDomAlloc = cuPdschCfg->pdsch_TimeDomainAllocationList;
8258       if(timeDomAlloc->present ==\
8259             PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup)
8260       {
8261          if(timeDomAlloc->choice.setup)
8262          {
8263             macPdschCfg->numTimeDomRsrcAlloc  = timeDomAlloc->choice.setup->list.count;
8264             for(timeDomIdx = 0; timeDomIdx < timeDomAlloc->choice.setup->list.count; timeDomIdx++)
8265             {
8266                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 = NULLP;
8267                if(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0)
8268                {
8269                   if(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 == NULL)
8270                   {
8271                      if(storedPdschCfg)
8272                      {
8273                         if(storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
8274                         {
8275                            macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 =\
8276                            storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0;
8277                         }
8278                         else
8279                         {
8280                            DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
8281                         }
8282                      }
8283                      else
8284                      {
8285                         DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
8286                      }
8287                      if(!macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
8288                      {
8289                         DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for k0 at extractPdschCfg()");
8290                         return RFAILED;
8291                      }
8292                   }
8293                   *(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0) = \
8294                   *(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0);
8295                }
8296                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
8297                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
8298                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
8299                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8300             }
8301          }
8302       }
8303    }
8304    macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
8305    if(cuPdschCfg->maxNrofCodeWordsScheduledByDCI)
8306       macPdschCfg->numCodeWordsSchByDci = *(cuPdschCfg->maxNrofCodeWordsScheduledByDCI);
8307    if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_staticBundling)
8308    {
8309       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
8310       if(cuPdschCfg->prb_BundlingType.choice.staticBundling)
8311       {
8312          if(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize)
8313          {
8314             macPdschCfg->bundlingInfo.StaticBundling.size = \
8315                *(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize);
8316          }
8317       }
8318    }
8319    else if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_dynamicBundling)
8320    {
8321       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
8322    }
8323
8324 }
8325
8326 /*******************************************************************
8327  *
8328  * @brief Fills PdschServingCellCfg received by CU
8329  *
8330  * @details
8331  *
8332  *    Function : extractPdschServingCellCfg
8333  *
8334  *    Functionality: Fills PdschCfg received  by CU
8335  *
8336  * @params[in] PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg,
8337  *             PdschServCellCfg *macUePdschSrvCellCfg
8338  * @return ROK/RFAILED
8339  *
8340  * ****************************************************************/
8341
8342 uint8_t extractPdschServingCellCfg(PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg, PdschServCellCfg *macUePdschSrvCellCfg)
8343 {
8344    if(cuPdschSrvCellCfg->codeBlockGroupTransmission)
8345    {
8346       if(cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup)
8347       {
8348          if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
8349          {
8350             *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
8351                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
8352          }
8353          else
8354          {
8355             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
8356             if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
8357             {
8358                *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
8359                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
8360             }
8361             else
8362             {
8363                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
8364                return RFAILED;
8365             }
8366          }
8367          if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
8368          {
8369             *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
8370                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
8371          }
8372          else
8373          {
8374             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->codeBlkGrpFlushInd , sizeof(bool));
8375             if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
8376             {
8377                *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
8378                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
8379             }
8380             else
8381             {
8382                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
8383                return RFAILED;
8384             }
8385          }
8386       }
8387    }
8388    if(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH)
8389    {
8390       macUePdschSrvCellCfg->numHarqProcForPdsch = *(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH);
8391    }
8392    if(cuPdschSrvCellCfg->ext1)
8393    {
8394       if(cuPdschSrvCellCfg->ext1->maxMIMO_Layers)
8395       {
8396         if(macUePdschSrvCellCfg->maxMimoLayers)
8397         {
8398            *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
8399         }
8400         else
8401         {
8402            DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxMimoLayers, sizeof(uint8_t));
8403            if(macUePdschSrvCellCfg->maxMimoLayers)
8404            {
8405               *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
8406            }
8407            else
8408            {
8409               DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
8410               return RFAILED;
8411            }
8412         }
8413       }
8414    }
8415    if(cuPdschSrvCellCfg->xOverhead)
8416    {
8417       if(macUePdschSrvCellCfg->xOverhead)
8418       {
8419          *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
8420       }
8421       else
8422       {
8423          DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->xOverhead, sizeof(PdschXOverhead));
8424          if(macUePdschSrvCellCfg->xOverhead)
8425          {
8426             *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
8427          }
8428          else
8429          {
8430             DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
8431             return RFAILED;
8432          }
8433       }
8434    }
8435    return ROK;
8436 }
8437
8438 /*******************************************************************
8439  *
8440  * @brief Fills PuschCfg received by CU
8441  *
8442  * @details
8443  *
8444  *    Function : extractPuschCfg
8445  *
8446  *    Functionality: Fills PuschCfg received  by CU
8447  *
8448  * @params[in] BWP_UplinkDedicated__pusch_Config *cuPuschCfg,
8449  *             PuschCfg *macPuschCfg
8450  * @return void
8451  *
8452  * ****************************************************************/
8453
8454 void extractPuschCfg(struct BWP_UplinkDedicated__pusch_Config *cuPuschCfg, PuschCfg *macPuschCfg)
8455 {
8456    uint8_t timeDomIdx = 0;
8457    DMRS_UplinkConfig_t *dmrsUlCfg = NULLP;
8458    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList = NULLP;
8459
8460    if(cuPuschCfg->present == BWP_UplinkDedicated__pusch_Config_PR_setup)
8461    {
8462       if(cuPuschCfg->choice.setup)
8463       {
8464          if(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH)
8465          {
8466              macPuschCfg->dataScramblingId = \
8467                 *(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH);
8468          }
8469          if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA)
8470          {
8471             if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->present == PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup)
8472             {
8473                if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup)
8474                {
8475                   dmrsUlCfg = (cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup);
8476                   if(dmrsUlCfg->dmrs_AdditionalPosition)
8477                   {
8478                      macPuschCfg->dmrsUlCfgForPuschMapTypeA.addPos =\
8479                         *(dmrsUlCfg->dmrs_AdditionalPosition);
8480                   }
8481                   if(dmrsUlCfg->transformPrecodingDisabled)
8482                   {
8483                      if(dmrsUlCfg->transformPrecodingDisabled->scramblingID0)
8484                      {
8485                         macPuschCfg->dmrsUlCfgForPuschMapTypeA.transPrecodDisabled.scramblingId0 = \
8486                            *(dmrsUlCfg->transformPrecodingDisabled->scramblingID0);
8487                      }
8488                   }
8489                }
8490             }
8491          }
8492          /*Res Alloc Type for UL */
8493          if(cuPuschCfg->choice.setup->resourceAllocation)
8494          {
8495             macPuschCfg->resourceAllocType = \
8496                cuPuschCfg->choice.setup->resourceAllocation;
8497          }
8498          if(cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList)
8499          {
8500             timeDomAllocList = cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList;
8501             if(timeDomAllocList->present == PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup)
8502             {
8503                if(timeDomAllocList->choice.setup)
8504                {
8505                   macPuschCfg->numTimeDomRsrcAlloc = timeDomAllocList->choice.setup->list.count;
8506                   for(timeDomIdx = 0; timeDomIdx <timeDomAllocList->choice.setup->list.count; timeDomIdx++)
8507                   {
8508                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].k2 = \
8509                         *(timeDomAllocList->choice.setup->list.array[timeDomIdx]->k2);
8510                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].mappingType = \
8511                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->mappingType;
8512                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbolAndLength = \
8513                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8514                   }
8515                }
8516             }
8517          }
8518          if(cuPuschCfg->choice.setup->transformPrecoder)
8519             macPuschCfg->transformPrecoder = *(cuPuschCfg->choice.setup->transformPrecoder);
8520       }
8521    }
8522 }
8523
8524 /*******************************************************************
8525  *
8526  * @brief Function to fill pucch Power Control
8527  *
8528  * @details
8529  *
8530  *    Function : extractPucchPowerControl
8531  *
8532  *    Functionality: Function to fill pucch Power Control
8533  *
8534  * @params[in] PucchPowerControl *pwrCtrl,
8535  *             struct PUCCH_PowerControl *cuPwrCtrlCfg
8536  * @return void
8537  *
8538  * ****************************************************************/
8539
8540 void extractPucchPowerControl(PucchPowerControl *pwrCtrl, struct PUCCH_PowerControl *cuPwrCtrlCfg)
8541 {
8542    uint8_t arrIdx;
8543
8544    if(cuPwrCtrlCfg->deltaF_PUCCH_f0)
8545       pwrCtrl->deltaF_Format0 = *cuPwrCtrlCfg->deltaF_PUCCH_f0;
8546    if(cuPwrCtrlCfg->deltaF_PUCCH_f1)
8547       pwrCtrl->deltaF_Format1 = *cuPwrCtrlCfg->deltaF_PUCCH_f1;
8548    if(cuPwrCtrlCfg->deltaF_PUCCH_f2)
8549       pwrCtrl->deltaF_Format2 = *cuPwrCtrlCfg->deltaF_PUCCH_f2;
8550    if(cuPwrCtrlCfg->deltaF_PUCCH_f3)
8551       pwrCtrl->deltaF_Format3 = *cuPwrCtrlCfg->deltaF_PUCCH_f3;
8552    if(cuPwrCtrlCfg->deltaF_PUCCH_f4)
8553       pwrCtrl->deltaF_Format4 = *cuPwrCtrlCfg->deltaF_PUCCH_f4;
8554    if(cuPwrCtrlCfg->p0_Set)
8555    {
8556       pwrCtrl->p0SetCount = cuPwrCtrlCfg->p0_Set->list.count;
8557       for(arrIdx=0; arrIdx < pwrCtrl->p0SetCount; arrIdx++)
8558       {
8559          pwrCtrl->p0Set[arrIdx].p0PucchId =\
8560             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Id;
8561          pwrCtrl->p0Set[arrIdx].p0PucchVal =\
8562             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Value;
8563       }
8564    }
8565    if(cuPwrCtrlCfg->pathlossReferenceRSs)
8566    {
8567       pwrCtrl->pathLossRefRSListCount = cuPwrCtrlCfg->pathlossReferenceRSs->list.count;
8568       for(arrIdx = 0; arrIdx < pwrCtrl->pathLossRefRSListCount; arrIdx++)
8569       {
8570          pwrCtrl->pathLossRefRSList[arrIdx].pathLossRefRSId =\
8571             cuPwrCtrlCfg->pathlossReferenceRSs->list.array[arrIdx]->pucch_PathlossReferenceRS_Id;
8572       }
8573    }
8574 }
8575
8576  /*******************************************************************
8577  *
8578  * @brief Function to extractResrcSetToAddModList sent by CU
8579  *
8580  * @details
8581  *
8582  *    Function : extractResrcSetToAddModList
8583  *
8584  *    Functionality: Fucntion to extractResrcSetToAddModList
8585  *
8586  * @params[in] PucchResrcSetCfg pointer,
8587  *             struct PUCCH_Config__resourceSetToAddModList pointer
8588  * @return void
8589  *
8590  * ****************************************************************/
8591
8592 void extractResrcSetToAddModList(PucchResrcSetCfg *macRsrcSetList, struct PUCCH_Config__resourceSetToAddModList *cuRsrcSetList)
8593 {
8594    uint8_t arrIdx, rsrcListIdx;
8595
8596    macRsrcSetList->resrcSetToAddModListCount = cuRsrcSetList->list.count;
8597    for(arrIdx = 0; arrIdx < macRsrcSetList->resrcSetToAddModListCount; arrIdx++)
8598    {
8599       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcSetId     =\
8600          cuRsrcSetList->list.array[arrIdx]->pucch_ResourceSetId;
8601       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount =\
8602          cuRsrcSetList->list.array[arrIdx]->resourceList.list.count;
8603       for(rsrcListIdx = 0; rsrcListIdx < macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount; rsrcListIdx++)
8604       {
8605          macRsrcSetList->resrcSetToAddModList[arrIdx].resrcList[rsrcListIdx] =\
8606             *cuRsrcSetList->list.array[arrIdx]->resourceList.list.array[rsrcListIdx];
8607       }
8608       macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize =\
8609          *cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1;
8610    }
8611 }/* End of extractResrcSetToAddModList */
8612
8613 /*******************************************************************
8614  *
8615  * @brief Fills extractResrcToAddModList sent by CU
8616  *
8617  * @details
8618  *
8619  *    Function : extractResrcToAddModList
8620  *
8621  *    Functionality: Fills extractResrcToAddModList
8622  *
8623  * @params[in] PucchResrcCfg pointer,
8624  *             struct PUCCH_Config__resourceToAddModList pointer
8625  * @return ROk/RFAILED
8626  *
8627  * ****************************************************************/
8628
8629 uint8_t extractResrcToAddModList(PucchResrcCfg *macResrcList, struct PUCCH_Config__resourceToAddModList *cuResrcList)
8630 {
8631    uint8_t arrIdx;
8632
8633    macResrcList->resrcToAddModListCount = cuResrcList->list.count;
8634    for(arrIdx = 0; arrIdx < macResrcList->resrcToAddModListCount; arrIdx++)
8635    {
8636       macResrcList->resrcToAddModList[arrIdx].resrcId      =\
8637         cuResrcList->list.array[arrIdx]->pucch_ResourceId;
8638       macResrcList->resrcToAddModList[arrIdx].startPrb     =\
8639         cuResrcList->list.array[arrIdx]->startingPRB;
8640       if(cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping)
8641       {
8642          macResrcList->resrcToAddModList[arrIdx].intraFreqHop =\
8643            *cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping;
8644       }
8645       if(cuResrcList->list.array[arrIdx]->secondHopPRB)
8646       {
8647          macResrcList->resrcToAddModList[arrIdx].secondPrbHop =\
8648            *cuResrcList->list.array[arrIdx]->secondHopPRB;
8649       }
8650       /* PUCCH RSRC FORMAT */
8651       if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format0)
8652       {
8653          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_0;
8654          if(cuResrcList->list.array[arrIdx]->format.choice.format0)
8655          {
8656             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0, sizeof(PucchFormat0));
8657             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0 == NULLP)
8658             {
8659                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
8660                return RFAILED;
8661             }
8662             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->initialCyclicShift =\
8663                cuResrcList->list.array[arrIdx]->format.choice.format0->initialCyclicShift;
8664             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->numSymbols =\
8665                cuResrcList->list.array[arrIdx]->format.choice.format0->nrofSymbols;
8666             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->startSymbolIdx =\
8667                cuResrcList->list.array[arrIdx]->format.choice.format0->startingSymbolIndex;
8668          }
8669       }
8670       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format1)
8671       {
8672          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_1;
8673          if(cuResrcList->list.array[arrIdx]->format.choice.format1)
8674          {
8675             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1, sizeof(PucchFormat1));
8676             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1 == NULLP)
8677             {
8678                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
8679                return RFAILED;
8680             }
8681             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->initialCyclicShift =\
8682                 cuResrcList->list.array[arrIdx]->format.choice.format1->initialCyclicShift;
8683             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->numSymbols =\
8684                 cuResrcList->list.array[arrIdx]->format.choice.format1->nrofSymbols;
8685             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->startSymbolIdx =\
8686                 cuResrcList->list.array[arrIdx]->format.choice.format1->startingSymbolIndex;
8687             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->timeDomOCC =\
8688                 cuResrcList->list.array[arrIdx]->format.choice.format1->timeDomainOCC;
8689          }
8690       }
8691       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format2)
8692       {
8693          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_2;
8694          if(cuResrcList->list.array[arrIdx]->format.choice.format2)
8695          {
8696             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
8697             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2 == NULLP)
8698             {
8699                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
8700                return RFAILED;
8701             }
8702             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numPrbs =\
8703                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofPRBs;
8704             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numSymbols =\
8705                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofSymbols;
8706             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->startSymbolIdx =\
8707                 cuResrcList->list.array[arrIdx]->format.choice.format2->startingSymbolIndex;
8708          }
8709       }
8710       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format3)
8711       {
8712          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_3;
8713          if(cuResrcList->list.array[arrIdx]->format.choice.format3)
8714          {
8715             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
8716             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3 == NULLP)
8717             {
8718                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
8719                return RFAILED;
8720             }
8721             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numPrbs =\
8722                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofPRBs;
8723             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numSymbols =\
8724                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofSymbols;
8725             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->startSymbolIdx =\
8726                 cuResrcList->list.array[arrIdx]->format.choice.format3->startingSymbolIndex;
8727          }
8728       }
8729       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format4)
8730       {
8731          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_4;
8732          if(cuResrcList->list.array[arrIdx]->format.choice.format4)
8733          {
8734             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4, sizeof(PucchFormat4));
8735             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4 == NULLP)
8736             {
8737                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
8738                return RFAILED;
8739             }
8740             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->numSymbols =\
8741                 cuResrcList->list.array[arrIdx]->format.choice.format4->nrofSymbols;
8742             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occLen =\
8743                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Length;
8744             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occIdx =\
8745                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Index;
8746             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->startSymbolIdx =\
8747                 cuResrcList->list.array[arrIdx]->format.choice.format4->startingSymbolIndex;
8748          }
8749       }
8750    }
8751    return ROK;
8752
8753 }/* End of extractResrcToAddModList */
8754
8755 /*******************************************************************
8756  *
8757  * @brief Fills fillPucchSchedReqPeriodAndOffset sent by CU
8758  *
8759  * @details
8760  *
8761  *    Function : fillPucchSchedReqPeriodAndOffset
8762  *
8763  *    Functionality: To fillPucchSchedReqPeriodAndOffset
8764  *
8765  * @params[in] macPeriodicty,
8766  *     SchedulingRequestResourceConfig__periodicityAndOffset pointer
8767  * @return void
8768  *
8769  * ****************************************************************/
8770
8771 void fillPucchSchedReqPeriodAndOffset(uint8_t macPeriodicty, uint16_t  macOffset,\
8772    struct SchedulingRequestResourceConfig__periodicityAndOffset *cuPeriodicty)
8773 {
8774    macPeriodicty = cuPeriodicty->present;
8775    switch(macPeriodicty)
8776    {
8777       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
8778          {
8779             macOffset     = cuPeriodicty->choice.sym2;
8780             break;
8781          }
8782       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
8783          {
8784             macOffset     = cuPeriodicty->choice.sym6or7;
8785             break;
8786          }
8787       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
8788          {
8789             macOffset     = cuPeriodicty->choice.sl1;
8790             break;
8791          }
8792       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
8793          {
8794             macOffset = cuPeriodicty->choice.sl2;
8795             break;
8796          }
8797       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
8798          {
8799             macOffset = cuPeriodicty->choice.sl4;
8800             break;
8801          }
8802       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
8803          {
8804             macOffset = cuPeriodicty->choice.sl5;
8805             break;
8806          }
8807       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
8808          {
8809             macOffset = cuPeriodicty->choice.sl8;
8810             break;
8811          }
8812       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
8813          {
8814             macOffset = cuPeriodicty->choice.sl10;
8815             break;
8816          }
8817       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
8818          {
8819             macOffset = cuPeriodicty->choice.sl16;
8820             break;
8821          }
8822       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
8823          {
8824             macOffset = cuPeriodicty->choice.sl20;
8825             break;
8826          }
8827       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
8828          {
8829             macOffset = cuPeriodicty->choice.sl40;
8830             break;
8831          }
8832       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
8833          {
8834             macOffset = cuPeriodicty->choice.sl80;
8835             break;
8836          }
8837       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
8838          {
8839             macOffset = cuPeriodicty->choice.sl160;
8840             break;
8841          }
8842       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
8843          {
8844             macOffset = cuPeriodicty->choice.sl320;
8845             break;
8846          }
8847       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
8848          {
8849             macOffset = cuPeriodicty->choice.sl640;
8850             break;
8851          }
8852       default :
8853          DU_LOG("\nERROR  -->  F1AP : Invalid periodicity %d", macPeriodicty);
8854    }
8855 }
8856
8857 /*******************************************************************
8858  *
8859  * @brief Function to extractPucchFormatCfg sent by CU
8860  *
8861  * @details
8862  *
8863  *    Function : extractPucchFormatCfg
8864  *
8865  *    Functionality: Function to extractPucchFormatCfg
8866  *
8867  * @params[in] PucchFormatCfg pointer,
8868  *             PUCCH_FormatConfig_t pointer
8869  * @return void
8870  *
8871  * ****************************************************************/
8872
8873 void extractPucchFormatCfg(PucchFormatCfg *macFormatCfg, PUCCH_FormatConfig_t *cuFormatCfg)
8874  {
8875     if(cuFormatCfg->interslotFrequencyHopping)
8876        macFormatCfg->interSlotFreqHop = *cuFormatCfg->interslotFrequencyHopping;
8877     if(cuFormatCfg->additionalDMRS)
8878        macFormatCfg->addDmrs = *cuFormatCfg->additionalDMRS;
8879     if(cuFormatCfg->maxCodeRate)
8880        macFormatCfg->maxCodeRate = *cuFormatCfg->maxCodeRate;
8881     if(cuFormatCfg->nrofSlots)
8882        macFormatCfg->numSlots = *cuFormatCfg->nrofSlots;
8883     if(cuFormatCfg->pi2BPSK)
8884        macFormatCfg->pi2BPSK = *cuFormatCfg->pi2BPSK;
8885     if(cuFormatCfg->simultaneousHARQ_ACK_CSI)
8886        macFormatCfg->harqAckCSI = *cuFormatCfg->simultaneousHARQ_ACK_CSI;
8887  }/* End of extractPucchFormatCfg */
8888
8889 /*******************************************************************
8890  *
8891  * @brief Function to extractSchedReqCfgToAddMod sent by CU
8892  *
8893  * @details
8894  *
8895  *    Function : extractSchedReqCfgToAddMod
8896  *
8897  *    Functionality: Function to extractSchedReqCfgToAddMod
8898  *
8899  * @params[in] PucchSchedReqCfg pointer,
8900  *      PUCCH_Config__schedulingRequestResourceToAddModList pointer
8901  * @return void
8902  *
8903  * ****************************************************************/
8904
8905 void extractSchedReqCfgToAddMod(PucchSchedReqCfg *macSchedReqCfg, struct PUCCH_Config__schedulingRequestResourceToAddModList *cuSchedReqList)
8906 {
8907    uint8_t arrIdx;
8908
8909    macSchedReqCfg->schedAddModListCount = cuSchedReqList->list.count;
8910    for(arrIdx = 0; arrIdx <  macSchedReqCfg->schedAddModListCount; arrIdx++)
8911    {
8912       macSchedReqCfg->schedAddModList[arrIdx].resrcId =\
8913          cuSchedReqList->list.array[arrIdx]->schedulingRequestResourceId;
8914       macSchedReqCfg->schedAddModList[arrIdx].requestId =\
8915          cuSchedReqList->list.array[arrIdx]->schedulingRequestID;
8916       if(cuSchedReqList->list.array[arrIdx]->periodicityAndOffset)
8917       {
8918          fillPucchSchedReqPeriodAndOffset(macSchedReqCfg->schedAddModList[arrIdx].periodicity,\
8919             macSchedReqCfg->schedAddModList[arrIdx].offset, cuSchedReqList->list.array[arrIdx]->periodicityAndOffset);
8920       }
8921       if(cuSchedReqList->list.array[arrIdx]->resource)
8922       {
8923          macSchedReqCfg->schedAddModList[arrIdx].resrc =\
8924             *cuSchedReqList->list.array[arrIdx]->resource;
8925       }
8926    }
8927
8928 }/* End of extractSchedReqCfgToAddMod */
8929
8930  /*******************************************************************
8931  *
8932  * @brief Fills PucchCfg received by CU
8933  *
8934  * @details
8935  *
8936  *    Function : extractPucchCfg
8937  *
8938  *    Functionality: Fills PucchCfg received  by CU
8939  *
8940  * @params[in] BWP_UplinkDedicated__pucch_Config *cuPucchCfg = Information which
8941  *                is send by CU, which we have stored in F1UeContextSetupDb,
8942  *             PucchCfg *macPucchCfg = Used to Store the information which
8943  *                needs to send in other layer, as well as this can be the variable
8944  *                which stores the information in DuCb,
8945  *             PucchCfg *storedPucchCfg = Null in case of sending the
8946  *                information to other layer else it will have Pucch Cfg which
8947  *                we have stored in copyOfmacUeCfg.
8948  * @return ROK/RFAILED
8949  *
8950  * ****************************************************************/
8951
8952 uint8_t extractPucchCfg(struct BWP_UplinkDedicated__pucch_Config *cuPucchCfg, PucchCfg *macPucchCfg,\
8953 PucchCfg *storedPucchCfg)
8954 {
8955    uint8_t arrIdx;
8956
8957    if(cuPucchCfg->present == BWP_UplinkDedicated__pucch_Config_PR_setup)
8958    {
8959       if(cuPucchCfg->choice.setup)
8960       {
8961          /* Resource Set Cfg */
8962          if(cuPucchCfg->choice.setup->resourceSetToAddModList)
8963          {
8964             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrcSet, sizeof(PucchResrcSetCfg));
8965             if(macPucchCfg->resrcSet == NULLP)
8966             {
8967                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
8968                return RFAILED;
8969             }
8970             memset(macPucchCfg->resrcSet, 0, sizeof(PucchResrcSetCfg));
8971             extractResrcSetToAddModList(macPucchCfg->resrcSet, cuPucchCfg->choice.setup->resourceSetToAddModList);
8972          }
8973
8974          /* Resource Cfg */
8975          if(cuPucchCfg->choice.setup->resourceToAddModList)
8976          {
8977             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrc, sizeof(PucchResrcCfg));
8978             if(macPucchCfg->resrc == NULLP)
8979             {
8980                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
8981                return RFAILED;
8982             }
8983             memset(macPucchCfg->resrc, 0, sizeof(PucchResrcCfg));
8984             extractResrcToAddModList(macPucchCfg->resrc, cuPucchCfg->choice.setup->resourceToAddModList);
8985          }
8986
8987          /* Format 1 Cfg */
8988          if(cuPucchCfg->choice.setup->format1)
8989          {
8990             DU_ALLOC_SHRABL_BUF(macPucchCfg->format1, sizeof(PucchFormatCfg));
8991             if(macPucchCfg->format1 == NULLP)
8992             {
8993                DU_LOG("\nERROR --> F1AP : Failed to extract format 1 Cfg in  extractPucchCfg()");
8994                return RFAILED;
8995             }
8996             memset(macPucchCfg->format1, 0, sizeof(PucchFormatCfg));
8997             extractPucchFormatCfg(macPucchCfg->format1,\
8998                cuPucchCfg->choice.setup->format1->choice.setup);
8999          }
9000
9001          /* Format 2 Cfg */
9002          if(cuPucchCfg->choice.setup->format2)
9003          {
9004             DU_ALLOC_SHRABL_BUF(macPucchCfg->format2, sizeof(PucchFormatCfg));
9005             if(macPucchCfg->format2 == NULLP)
9006             {
9007                DU_LOG("\nERROR --> F1AP : Failed to extract format 2 Cfg in  extractPucchCfg()");
9008                return RFAILED;
9009             }
9010             memset(macPucchCfg->format2, 0, sizeof(PucchFormatCfg));
9011             extractPucchFormatCfg(macPucchCfg->format2,\
9012                cuPucchCfg->choice.setup->format2->choice.setup);
9013          }
9014
9015          /* Format 3 Cfg */
9016          if(cuPucchCfg->choice.setup->format3)
9017          {
9018             DU_ALLOC_SHRABL_BUF(macPucchCfg->format3, sizeof(PucchFormatCfg));
9019             if(macPucchCfg->format3 == NULLP)
9020             {
9021                DU_LOG("\nERROR --> F1AP : Failed to extract format 3 Cfg in  extractPucchCfg()");
9022                return RFAILED;
9023             }
9024             memset(macPucchCfg->format3, 0, sizeof(PucchFormatCfg));
9025             extractPucchFormatCfg(macPucchCfg->format3,\
9026                cuPucchCfg->choice.setup->format3->choice.setup);
9027          }
9028
9029          /* Format 4 Cfg */
9030          if(cuPucchCfg->choice.setup->format4)
9031          {
9032             DU_ALLOC_SHRABL_BUF(macPucchCfg->format4, sizeof(PucchFormatCfg));
9033             if(macPucchCfg->format4 == NULLP)
9034             {
9035                DU_LOG("\nERROR --> F1AP : Failed to extract format 4 Cfg in  extractPucchCfg()");
9036                return RFAILED;
9037             }
9038             memset(macPucchCfg->format4, 0, sizeof(PucchFormatCfg));
9039             extractPucchFormatCfg(macPucchCfg->format4,\
9040                cuPucchCfg->choice.setup->format4->choice.setup);
9041          }
9042
9043          /* Sched Req List */
9044          if(cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList)
9045          {
9046             DU_ALLOC_SHRABL_BUF(macPucchCfg->schedReq, sizeof(PucchSchedReqCfg));
9047             if(macPucchCfg->schedReq == NULLP)
9048             {
9049                DU_LOG("\nERROR --> F1AP : Failed to extract schedReqCfg in  extractPucchCfg()");
9050                return RFAILED;
9051             }
9052             memset(macPucchCfg->schedReq, 0, sizeof(PucchSchedReqCfg));
9053             extractSchedReqCfgToAddMod(macPucchCfg->schedReq,\
9054             cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList);
9055          }
9056
9057          /*TODO: Add support for  Spatial Info */
9058
9059          /* MultiCsiCfg */
9060          if(cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList)
9061          {
9062             DU_ALLOC_SHRABL_BUF(macPucchCfg->multiCsiCfg, sizeof(PucchMultiCsiCfg));
9063             if(macPucchCfg->multiCsiCfg == NULLP)
9064             {
9065                DU_LOG("\nERROR --> F1AP : Failed to extract multiCsiCfg in  extractPucchCfg()");
9066                return RFAILED;
9067             }
9068             memset(macPucchCfg->multiCsiCfg, 0, sizeof(PucchMultiCsiCfg));
9069             macPucchCfg->multiCsiCfg->multiCsiResrcListCount = cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.count;
9070             for(arrIdx =0; arrIdx < macPucchCfg->multiCsiCfg->multiCsiResrcListCount; arrIdx++)
9071             {
9072                macPucchCfg->multiCsiCfg->multiCsiResrcList[arrIdx] =\
9073                  *cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.array[arrIdx];
9074             }
9075          }
9076
9077          /* Dl_DataToUL_ACK */
9078          if(cuPucchCfg->choice.setup->dl_DataToUL_ACK)
9079     {
9080        if(storedPucchCfg)
9081        {
9082           if(storedPucchCfg->dlDataToUlAck)
9083           {
9084              macPucchCfg->dlDataToUlAck = storedPucchCfg->dlDataToUlAck;
9085           }
9086           else
9087           {
9088             DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
9089           }
9090        }
9091        else
9092        {
9093           DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
9094        }
9095        if(macPucchCfg->dlDataToUlAck == NULLP)
9096        {
9097           DU_LOG("\nERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
9098           return RFAILED;
9099        }
9100        memset(macPucchCfg->dlDataToUlAck, 0, sizeof(PucchDlDataToUlAck));
9101        macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount = cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.count;
9102        for(arrIdx = 0; arrIdx < macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount; arrIdx++)
9103        {
9104           macPucchCfg->dlDataToUlAck->dlDataToUlAckList[arrIdx] =\
9105           *cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.array[arrIdx];
9106        }
9107          }
9108
9109          /* Power Control */
9110          if(cuPucchCfg->choice.setup->pucch_PowerControl)
9111          {
9112             DU_ALLOC_SHRABL_BUF(macPucchCfg->powerControl, sizeof(PucchPowerControl));
9113             if(macPucchCfg->powerControl == NULLP)
9114             {
9115                DU_LOG("\nERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
9116                return RFAILED;
9117             }
9118             extractPucchPowerControl(macPucchCfg->powerControl,\
9119                cuPucchCfg->choice.setup->pucch_PowerControl);
9120          }
9121       }
9122    }
9123    return ROK;
9124 }
9125
9126 /*******************************************************************
9127  *
9128  * @brief Fills ServingCellReconfig received by CU
9129  *
9130  * @details
9131  *
9132  *    Function : extractSpCellDedicatedCfg
9133  *
9134  *    Functionality: Fills ServingCellReconfig received  by CU
9135  *
9136  * @params[in] ServingCellConfig_t *cuSrvCellCfg = Information which is send by
9137  *                  CU, which we have stored in F1UeContextSetupDb,
9138  *             ServCellCfgInfo *macSrvCellCfg = Used to Store the information
9139  *                  which  needs to send in other layer, as well as this can be the
9140  *                  variable which stores the information in DuCb,
9141  *             ServCellCfgInfo *storedSrvCellCfg = Null in case of sending the
9142  *                  information to other layer else it will have ServCellCfgInfo which
9143  *                  we have stored in copyOfmacUeCfg.
9144  * @return ROK/RFAILD
9145  *
9146  * ****************************************************************/
9147 uint8_t extractSpCellDedicatedCfg(ServingCellConfig_t *cuSrvCellCfg, ServCellCfgInfo *macSrvCellCfg,\
9148 ServCellCfgInfo *storedSrvCellCfg)
9149 {
9150    uint8_t ret = ROK;
9151    BWP_DownlinkDedicated_t *dlBwp = NULLP;
9152    BWP_UplinkDedicated_t   *ulBwp = NULLP;
9153
9154    if(cuSrvCellCfg->initialDownlinkBWP)
9155    {
9156       dlBwp = ((BWP_DownlinkDedicated_t *)(cuSrvCellCfg->initialDownlinkBWP));
9157       if(dlBwp->pdcch_Config)
9158       {
9159          if(dlBwp->pdcch_Config->choice.setup)
9160          {
9161             macSrvCellCfg->initDlBwp.pdcchPresent = true;
9162             extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
9163          }
9164       }
9165       if(dlBwp->pdsch_Config)
9166       {
9167          if(dlBwp->pdsch_Config->choice.setup)
9168          {
9169             macSrvCellCfg->initDlBwp.pdschPresent = true;
9170
9171             if(storedSrvCellCfg)
9172             {
9173                if(!storedSrvCellCfg->initDlBwp.pdschPresent)
9174                {
9175                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
9176                }
9177                else
9178                {
9179                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg,\
9180                         &storedSrvCellCfg->initDlBwp.pdschCfg);
9181                }
9182             }
9183             else
9184             {
9185                extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
9186             }
9187          }
9188       }
9189    }
9190    if(cuSrvCellCfg->firstActiveDownlinkBWP_Id)
9191       macSrvCellCfg->firstActvDlBwpId = *(cuSrvCellCfg->firstActiveDownlinkBWP_Id);
9192    if(cuSrvCellCfg->defaultDownlinkBWP_Id)
9193       macSrvCellCfg->defaultDlBwpId = *(cuSrvCellCfg->defaultDownlinkBWP_Id);
9194    if(cuSrvCellCfg->bwp_InactivityTimer)
9195    {
9196       if(macSrvCellCfg->bwpInactivityTmr)
9197       {
9198          memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
9199       }
9200       else
9201       {
9202          macSrvCellCfg->bwpInactivityTmr = NULLP;
9203          DU_ALLOC_SHRABL_BUF(macSrvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
9204          if(macSrvCellCfg->bwpInactivityTmr)
9205          {
9206             memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
9207          }
9208          else
9209          {
9210             DU_LOG("\nERROR  --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
9211             return RFAILED;
9212          }
9213       }
9214    }
9215    if(cuSrvCellCfg->pdsch_ServingCellConfig)
9216    {
9217       if(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup)
9218       {
9219          ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
9220          if(ret == RFAILED)
9221          {
9222             DU_LOG("\nERROR --> F1AP : Failed at extractPdschServingCellCfg()");
9223             return RFAILED;
9224          }
9225       }
9226    }
9227    if(cuSrvCellCfg->uplinkConfig)
9228    {
9229       if(cuSrvCellCfg->uplinkConfig->initialUplinkBWP)
9230       {
9231          ulBwp = ((BWP_UplinkDedicated_t *)(cuSrvCellCfg->uplinkConfig->initialUplinkBWP));
9232          if(ulBwp->pusch_Config)
9233          {
9234             macSrvCellCfg->initUlBwp.puschPresent = true;
9235             extractPuschCfg(ulBwp->pusch_Config, &macSrvCellCfg->initUlBwp.puschCfg);
9236          }
9237          if(ulBwp->pucch_Config)
9238          {
9239             macSrvCellCfg->initUlBwp.pucchPresent = true;
9240             memset(&macSrvCellCfg->initUlBwp.pucchCfg, 0, sizeof(PucchCfg));
9241             if(storedSrvCellCfg)
9242             {
9243                if(!storedSrvCellCfg->initUlBwp.pucchPresent)
9244                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
9245                else
9246                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg,\
9247                   &storedSrvCellCfg->initUlBwp.pucchCfg);
9248             }
9249             else
9250             {
9251                extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
9252             }
9253          }
9254       }
9255       if(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id)
9256          macSrvCellCfg->firstActvUlBwpId = *(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id);
9257    }
9258    return ret;
9259 }
9260 /*******************************************************************
9261  *
9262  * @brief Fills Reconfig Cell group Info received by CU
9263  *
9264  * @details
9265  *
9266  *    Function : extractUeReCfgCellInfo
9267  *
9268  *    Functionality: Fills Reconfig Cell group Info received by CU
9269  *
9270  * @params[in] CellGroupConfigRrc_t *cellGrp = CellGroupConfigRrc_t information which
9271  *                       is send by CU, which we have stored in F1UeContextSetupDb
9272  *             MacUeCfg *MacUeCfg = Used to Store the information,
9273  *                      which needs to send in other layer, as well as this can be
9274  *                      the variable which stores the information in DuCb,
9275  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
9276  *                      information to other layer else it will have copyOfmacUeCfg
9277  *                      which we have stored in F1UeContextSetupDb.
9278  *
9279  * @return ROK/RFAILED
9280  *
9281  * ****************************************************************/
9282 uint8_t extractUeReCfgCellInfo(CellGroupConfigRrc_t *cellGrp, MacUeCfg *macUeCfg, MacUeCfg *storedMacUeCfg)
9283 {
9284    uint8_t ret = ROK;
9285    MAC_CellGroupConfig_t     *macCellGroup = NULLP;
9286    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
9287    SpCellConfig_t            *spcellCfg = NULLP;
9288    ServingCellConfig_t       *servCellCfg = NULLP;
9289
9290    if(cellGrp)
9291    {
9292       /* Fill MacCell Group Reconfig  */
9293       if(cellGrp->mac_CellGroupConfig)
9294       {
9295          macUeCfg->macCellGrpCfgPres = true;
9296          macCellGroup = ((MAC_CellGroupConfig_t *)(cellGrp->mac_CellGroupConfig));
9297          if(macCellGroup->schedulingRequestConfig)
9298          {
9299             extractSchReqReConfig(macCellGroup->schedulingRequestConfig, &macUeCfg->macCellGrpCfg.schReqCfg);
9300          }
9301          if(macCellGroup->tag_Config)
9302          {
9303             extractTagReconfig(macCellGroup->tag_Config, &macUeCfg->macCellGrpCfg.tagCfg);
9304          }
9305          if(macCellGroup->bsr_Config)
9306          {
9307             macUeCfg->macCellGrpCfg.bsrTmrCfg.periodicTimer = macCellGroup->bsr_Config->periodicBSR_Timer;
9308             macUeCfg->macCellGrpCfg.bsrTmrCfg.retxTimer     = macCellGroup->bsr_Config->retxBSR_Timer;
9309             if(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer)
9310             {
9311                macUeCfg->macCellGrpCfg.bsrTmrCfg.srDelayTimer  =\
9312                *(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer);
9313             }
9314          }
9315          if(macCellGroup->phr_Config)
9316          {
9317             if(macCellGroup->phr_Config->present == MAC_CellGroupConfig__phr_Config_PR_setup)
9318             {
9319                macUeCfg->macCellGrpCfg.phrCfgSetupPres = true;
9320                if(macCellGroup->phr_Config->choice.setup)
9321                {
9322                   macUeCfg->macCellGrpCfg.phrCfg.periodicTimer     = \
9323                   macCellGroup->phr_Config->choice.setup->phr_PeriodicTimer;
9324                   macUeCfg->macCellGrpCfg.phrCfg.prohibitTimer     = \
9325                   macCellGroup->phr_Config->choice.setup->phr_ProhibitTimer;
9326                   macUeCfg->macCellGrpCfg.phrCfg.txPowerFactor     = \
9327                   macCellGroup->phr_Config->choice.setup->phr_Tx_PowerFactorChange;
9328                   macUeCfg->macCellGrpCfg.phrCfg.multiplePHR       = \
9329                   macCellGroup->phr_Config->choice.setup->multiplePHR;
9330                   macUeCfg->macCellGrpCfg.phrCfg.dummy             = \
9331                   macCellGroup->phr_Config->choice.setup->dummy;
9332                   macUeCfg->macCellGrpCfg.phrCfg.phrType2OtherCell = \
9333                   macCellGroup->phr_Config->choice.setup->phr_Type2OtherCell;
9334                   macUeCfg->macCellGrpCfg.phrCfg.phrOtherCG        = \
9335                   macCellGroup->phr_Config->choice.setup->phr_ModeOtherCG;
9336                }
9337             }
9338          }
9339       }
9340       /* Fill Physical Cell Group Reconfig */
9341       if(cellGrp->physicalCellGroupConfig)
9342       {
9343          macUeCfg->phyCellGrpCfgPres = true;
9344          phyCellGrpCfg = ((PhysicalCellGroupConfig_t *)(cellGrp->physicalCellGroupConfig));
9345          if(phyCellGrpCfg->p_NR_FR1)
9346          {
9347             if(*(phyCellGrpCfg->p_NR_FR1) != macUeCfg->phyCellGrpCfg.pNrFr1)
9348                macUeCfg->phyCellGrpCfg.pNrFr1 = *(phyCellGrpCfg->p_NR_FR1);
9349          }
9350          macUeCfg->phyCellGrpCfg.pdschHarqAckCodebook = phyCellGrpCfg->pdsch_HARQ_ACK_Codebook;
9351       }
9352       /* Fill SpCell Reconfig */
9353       if(cellGrp->spCellConfig)
9354       {
9355          macUeCfg->spCellCfgPres = true;
9356          spcellCfg = ((SpCellConfig_t *)(cellGrp->spCellConfig));
9357          if(spcellCfg->servCellIndex)
9358          {
9359             macUeCfg->spCellCfg.servCellIdx = *(spcellCfg->servCellIndex);
9360          }
9361          /* Fill Serving cell Reconfig info */
9362          if(cellGrp->spCellConfig->spCellConfigDedicated)
9363          {
9364             servCellCfg = ((ServingCellConfig_t *)(cellGrp->spCellConfig->spCellConfigDedicated));
9365             if(storedMacUeCfg)
9366             {
9367                if(!storedMacUeCfg->spCellCfgPres)
9368                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
9369                else
9370                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg,\
9371                         &storedMacUeCfg->spCellCfg.servCellCfg);
9372             }
9373             else
9374             {
9375                ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
9376             }
9377             if(ret == RFAILED)
9378             {
9379                DU_LOG("\nERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
9380             }
9381          }
9382       }
9383    }
9384    return ret;
9385 }
9386 /*******************************************************************
9387 *
9388 * @brief free the memory allocated by decoder
9389 *
9390 * @details
9391 *
9392 *    Function : freeAperDecodeNrcgi
9393 *
9394 *    Functionality: Free Nrcgi values
9395 *
9396 * @params[in] NRCGI_t *nrcgi
9397 * @return void
9398 *
9399 * ****************************************************************/
9400
9401
9402 void freeAperDecodeNrcgi(NRCGI_t *nrcgi)
9403 {
9404     if(nrcgi->pLMN_Identity.buf != NULLP)
9405     {
9406        free(nrcgi->pLMN_Identity.buf);
9407     }
9408     if(nrcgi->nRCellIdentity.buf != NULLP)
9409     {
9410        free(nrcgi->nRCellIdentity.buf);
9411     }
9412 }
9413 /*******************************************************************
9414 *
9415 * @brief free the memory allocated by decoder
9416 *
9417 * @details
9418 *
9419 *    Function : freeAperDecodeCuToDuInfo
9420 *
9421 *    Functionality:  Free Cu To Du Information
9422 *
9423 * @params[in] CUtoDURRCInformation_t *rrcMsg
9424 * @return void
9425 *
9426 * ****************************************************************/
9427
9428
9429 void freeAperDecodeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
9430 {
9431    uint8_t ieIdx =0;
9432    uint8_t arrIdx =0;
9433
9434    if(rrcMsg->uE_CapabilityRAT_ContainerList)
9435    {
9436       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
9437          free(rrcMsg->uE_CapabilityRAT_ContainerList->buf);
9438       free(rrcMsg->uE_CapabilityRAT_ContainerList);
9439    }
9440
9441    if(rrcMsg->iE_Extensions)
9442    {
9443       if(rrcMsg->iE_Extensions->list.array)
9444       {
9445          for(ieIdx= 0; ieIdx < rrcMsg->iE_Extensions->list.count; ieIdx++)
9446          {
9447             if(rrcMsg->iE_Extensions->list.array[ieIdx])
9448             {
9449                switch(rrcMsg->iE_Extensions->list.array[ieIdx]->id)
9450                {
9451                   case ProtocolIE_ID_id_CellGroupConfig:
9452                      if(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
9453                      {
9454                         free(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf);
9455                      }
9456                      break;
9457                   default:
9458                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
9459                            rrcMsg->iE_Extensions->list.array[ieIdx]->id);
9460                      break;
9461                }
9462             }
9463          }
9464          for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
9465          {
9466             free(rrcMsg->iE_Extensions->list.array[arrIdx]);
9467          }
9468          free(rrcMsg->iE_Extensions->list.array);
9469
9470       }
9471
9472       free(rrcMsg->iE_Extensions);
9473    }
9474 }
9475 /*******************************************************************
9476 *
9477 * @brief free the memory allocated by decoder
9478 *
9479 * @details
9480 *
9481 *    Function : freeAperDecodeSplCellList
9482 *
9483 *    Functionality: Free Spl Cell List
9484                     where memory allocated by aper_decoder
9485 *
9486 * @params[in]  SCell_ToBeSetup_List_t *spCellLst
9487 * @return void
9488 *
9489 * ****************************************************************/
9490
9491
9492 void freeAperDecodeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
9493 {
9494     uint8_t  cellIdx =0;
9495
9496     if(spCellLst->list.array != NULLP)
9497     {
9498        for(cellIdx=0; cellIdx<spCellLst->list.count; cellIdx++)
9499        {
9500           if(cellIdx==0&&spCellLst->list.array[cellIdx]!=NULLP)
9501           {
9502              freeAperDecodeNrcgi(&spCellLst->list.array[cellIdx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
9503           }
9504           if(spCellLst->list.array[cellIdx]!=NULLP)
9505           {
9506              free(spCellLst->list.array[cellIdx]);
9507           }
9508        }
9509        free(spCellLst->list.array);
9510     }
9511 }
9512 /*******************************************************************
9513 *
9514 * @brief free the memory allocated by decoder
9515 *
9516 * @details
9517 *
9518 *    Function : freeAperDecodeSRBSetup
9519 *
9520 *    Functionality: added free part for the memory allocated by aper_decoder
9521 *
9522 * @params[in] SRBs_ToBeSetup_List_t *srbSet
9523 * @return void
9524 *
9525 ****************************************************************/
9526
9527
9528 void freeAperDecodeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
9529 {
9530     uint8_t srbIdx =0;
9531     if(srbSet->list.array != NULLP)
9532     {
9533        for(srbIdx=0; srbIdx<srbSet->list.count; srbIdx++)
9534        {
9535           if(srbSet->list.array[srbIdx]!=NULLP)
9536           {
9537              free(srbSet->list.array[srbIdx]);
9538           }
9539        }
9540        free(srbSet->list.array);
9541     }
9542 }
9543
9544 /*******************************************************************
9545 *
9546 * @brief free the memory allocated by decoder
9547 *
9548 * @details
9549 *
9550 *    Function : freeAperDecodeULTnlInfo
9551 *
9552 *    Functionality: added free part for the memory allocated by aper_decoder
9553 *
9554 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
9555 * @return void
9556 *
9557 * ****************************************************************/
9558
9559
9560 void freeAperDecodeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
9561 {
9562    uint8_t ulIdx=0;
9563    if(ulInfo->list.array != NULLP)
9564    {
9565       for(ulIdx=0; ulIdx<ulInfo->list.count; ulIdx++)
9566       {
9567          if(ulIdx==0&&ulInfo->list.array[ulIdx]!=NULLP)
9568          {
9569             if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
9570             {
9571                if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9572                      transportLayerAddress.buf != NULLP)
9573                {
9574                   if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
9575                         !=NULLP)
9576                   {
9577                      free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf);
9578                   }
9579                   free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9580                         transportLayerAddress.buf);
9581                }
9582                free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel);
9583             }
9584          }
9585          if(ulInfo->list.array[ulIdx]!=NULLP)
9586          {
9587             free(ulInfo->list.array[ulIdx]);
9588          }
9589       }
9590       free(ulInfo->list.array);
9591    }
9592 }
9593 /*******************************************************************
9594 *
9595 * @brief free the memory allocated by decoder
9596 *
9597 * @details
9598 *
9599 *    Function : freeAperDecodeDRBSetup
9600 *
9601 *    Functionality: free DRBSetup which is allocated by decoder
9602 *
9603 * @params[in]  DRBs_ToBeSetup_List_t *drbSet
9604 * @return void
9605 *
9606 * ****************************************************************/
9607
9608 void freeAperDecodeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
9609 {
9610    DRBs_ToBeSetup_Item_t *drbSetItem = NULLP;
9611    uint8_t  flowIdx =0;
9612    uint8_t  drbIdx =0;
9613
9614    if(drbSet->list.array != NULLP)
9615    {
9616       for(drbIdx=0; drbIdx<drbSet->list.count; drbIdx++)
9617       {
9618          if(drbIdx==0&&drbSet->list.array[drbIdx] != NULLP)
9619          {
9620             drbSetItem =&drbSet->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
9621             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
9622             {
9623                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9624                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
9625                {
9626                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9627                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9628                   {
9629                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9630                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9631                      {
9632
9633                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
9634                         {
9635
9636                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
9637                            {
9638
9639                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->\
9640                                     buf!=NULLP)
9641                               {
9642
9643                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
9644                                        flows_Mapped_To_DRB_List.list.array != NULLP)
9645                                  {
9646
9647                                     for(flowIdx=0;flowIdx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9648                                           DRB_Information.flows_Mapped_To_DRB_List.list.count; flowIdx++)
9649                                     {
9650
9651                                        if(flowIdx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9652                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9653                                        {
9654                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9655                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9656                                                 qoSFlowLevelQoSParameters.\
9657                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
9658                                           {
9659                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9660                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9661                                                    qoSFlowLevelQoSParameters.\
9662                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9663                                              {
9664
9665                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9666                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9667                                                       qoSFlowLevelQoSParameters.\
9668                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9669                                                 {
9670
9671
9672                                                    free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9673                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9674                                                          qoSFlowLevelQoSParameters.\
9675                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9676                                                 }
9677
9678                                                 free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9679                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9680                                                       qoSFlowLevelQoSParameters.\
9681                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9682                                              }
9683
9684                                              free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9685
9686                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9687                                                    qoSFlowLevelQoSParameters.\
9688                                                    qoS_Characteristics.choice.non_Dynamic_5QI);
9689                                           }
9690                                        }
9691                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9692                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9693                                        {
9694
9695                                           free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9696                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]);
9697                                        }
9698                                     }
9699
9700                                     free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9701                                           DRB_Information.flows_Mapped_To_DRB_List.list.array);
9702                                  }
9703
9704                                  free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9705                                        DRB_Information.sNSSAI.sD->buf);
9706                               }
9707
9708                               free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD);
9709                            }
9710
9711                            free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf);
9712
9713                         }
9714
9715                         free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9716
9717                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9718                      }
9719
9720                      free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9721                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9722                   }
9723
9724                   free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9725                         qoS_Characteristics.choice.non_Dynamic_5QI);
9726                }
9727                free(drbSetItem->qoSInformation.choice.choice_extension);
9728             }
9729             freeAperDecodeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
9730             if(drbSetItem->uLConfiguration)
9731             {
9732                free(drbSetItem->uLConfiguration);
9733             }
9734          }
9735          if(drbSet->list.array[drbIdx]!=NULLP)
9736          {
9737             free(drbSet->list.array[drbIdx]);
9738          }
9739       }
9740       free(drbSet->list.array);
9741    }
9742 }
9743
9744
9745 /*******************************************************************
9746  *
9747  * @brief builds Mac Cell Cfg
9748  *
9749  * @details
9750  *
9751  *    Function : procUeReCfgCellInfo
9752  *
9753  *    Functionality: builds Mac Cell Cfg
9754  *
9755  * @params[in] MacUeCfg *macUeCfgToSend = Used to Store the information which
9756  *                       needs to send in other layer, as well as this can be
9757  *                       the variable which stores the information in DuCb.
9758  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
9759  *                       information to other layer else it will have copyOfmacUeCfg
9760  *                       which we have stored in F1UeContextSetupDb
9761  *             void *cellInfo = CellGroupConfigRrc_t information which is send
9762  *                        by CU, which we have stored in F1UeContextSetupDb
9763  *
9764  * @return void
9765  *
9766  * ****************************************************************/
9767 uint8_t procUeReCfgCellInfo(MacUeCfg *macUeCfgToSend,MacUeCfg *storedMacUeCfg, void *cellInfo)
9768 {
9769    uint8_t ret = ROK;
9770    CellGroupConfigRrc_t *cellGrp = NULLP;
9771
9772    if(cellInfo)
9773    {
9774       cellGrp = (CellGroupConfigRrc_t *)cellInfo;
9775       ret = extractUeReCfgCellInfo(cellGrp, macUeCfgToSend, storedMacUeCfg);
9776       if(ret == RFAILED)
9777          DU_LOG("\nERROR  -->  F1AP : Failed at procUeReCfgCellInfo()");
9778    }
9779    if(ret == RFAILED)
9780    {
9781       freeUeReCfgCellGrpInfo(macUeCfgToSend);
9782    }
9783    return ret;
9784 }
9785
9786 /*******************************************************************
9787  *
9788  * @brief Filling modulation info in mac ue cfg
9789  *
9790  * @details
9791  *
9792  *    Function : duFillModulationDetails
9793  *
9794  *    Functionality: Filling modulation info in mac ue cfg
9795  *
9796  * @params[in] MAC UE Config to be updated
9797  *             Current UE configuration
9798  *             UE NR capability from CU
9799  * @return ROK     - success
9800  *         RFAILED - failure
9801  *
9802  * ****************************************************************/
9803 void duFillModulationDetails(MacUeCfg *ueCfg, MacUeCfg *oldUeCfg, void *ueCap)
9804 {
9805    UE_NR_Capability_t *ueNrCap=NULLP;
9806
9807    if(!ueCap)
9808    {
9809       memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9810       memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9811    }
9812    else
9813    {
9814       ueNrCap = (UE_NR_Capability_t *)ueCap;
9815
9816       /* Filling DL modulation info */
9817       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsDownlinkPerCC && \
9818          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0] && \
9819          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL)
9820       {
9821          switch(*(ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL))
9822          {
9823             case ModulationOrder_qpsk:
9824                {
9825                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
9826                   break;
9827                }
9828             case ModulationOrder_qam16:
9829                {
9830                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM16;
9831                   break;
9832                }
9833             case ModulationOrder_qam64:
9834                {
9835                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM64;
9836                   ueCfg->dlModInfo.mcsIndex = PDSCH_MCS_INDEX;
9837                   ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64;
9838                   break;
9839                }
9840             case ModulationOrder_qam256:
9841                {
9842                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM256;
9843                   break;
9844                }
9845             default:
9846                {
9847                   DU_LOG("\nERROR  -->  DU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
9848                   memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9849                   break;
9850                }
9851          }
9852       }
9853       else
9854       {
9855          memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9856       }
9857
9858       /* Filling UL modulation info */
9859       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsUplinkPerCC && \
9860          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0] && \
9861          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL)
9862       {
9863          switch(*(ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL))
9864          {
9865             case ModulationOrder_qpsk:
9866                {
9867                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
9868                   break;
9869                }
9870             case ModulationOrder_qam16:
9871                {
9872                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM16;
9873                   ueCfg->ulModInfo.mcsIndex = PUSCH_MCS_INDEX;
9874                   ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64;
9875                   break;
9876                }
9877             case ModulationOrder_qam64:
9878                {
9879                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM64;
9880                   break;
9881                }
9882             case ModulationOrder_qam256:
9883                {
9884                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM256;
9885                   break;
9886                }
9887             default:
9888                {
9889                   DU_LOG("\nERROR  -->  DU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
9890                   memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9891                   break;
9892                }
9893          }
9894       }
9895       else
9896       {
9897          memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9898       }
9899    }
9900 }
9901
9902 /*******************************************************************
9903  *
9904  * @brief Function to extract cellGrp Info present in cutoDu cont
9905  *
9906  * @details
9907  *
9908  *    Function : extractCellGrpInfo
9909  *
9910  *    Functionality: Function to extract cellGrp Info present
9911  *                   in cutoDu cont
9912  *
9913  * @params[in] ProtocolExtensionContainer_4624P16_t pointer
9914  *
9915  * @return CellGroupConfigRrc_t *
9916  *
9917  * ****************************************************************/
9918
9919 CellGroupConfigRrc_t *extractCellGrpInfo(ProtocolExtensionContainer_4624P16_t *protocolIeExtn,\
9920       DuUeCfg *ueCfgDb)
9921 {
9922    uint8_t idx2 =0;
9923    uint16_t id =0;
9924    uint16_t recvBufLen =0;
9925    CellGroupConfigRrc_t *cellGrpCfg = NULLP;
9926    CUtoDURRCInformation_ExtIEs_t *extIeInfo = NULLP;
9927    asn_dec_rval_t rval; /* Decoder return value */
9928    memset(&rval, 0, sizeof(asn_dec_rval_t));
9929
9930    if(protocolIeExtn)
9931    {
9932       for(idx2 = 0; idx2 < protocolIeExtn->list.count; idx2++)
9933       {
9934          extIeInfo = ((CUtoDURRCInformation_ExtIEs_t *)(protocolIeExtn->list.array[idx2]));
9935          id = extIeInfo->id;
9936          switch(id)
9937          {
9938             case ProtocolIE_ID_id_CellGroupConfig:
9939             {
9940                recvBufLen = extIeInfo->extensionValue.choice.CellGroupConfig.size;
9941                /* decoding the CellGroup Buf received */
9942                DU_ALLOC(cellGrpCfg, sizeof(CellGroupConfigRrc_t));
9943                if(cellGrpCfg)
9944                {
9945                   memset(cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
9946                   rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfg,
9947                      extIeInfo->extensionValue.choice.CellGroupConfig.buf, recvBufLen, 0, 0);
9948                   if(rval.code == RC_FAIL || rval.code == RC_WMORE)
9949                   {
9950                      DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
9951                      return NULLP;
9952                   }
9953                   xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfg);
9954                   if(extractRlcCfgToAddMod(cellGrpCfg->rlc_BearerToAddModList, ueCfgDb))
9955                      return NULLP;
9956                }
9957                break;
9958             }
9959             default:
9960                DU_LOG("\nERROR  -->  F1AP : Invalid IE received CUtoDURRCInformation:%d at decodeCellGrpCfg()", id);
9961                break;
9962          }
9963       }
9964    }
9965    return cellGrpCfg;
9966 }
9967
9968 /*******************************************************************
9969  *
9970  * @brief Fills Srb List received by CU
9971  *
9972  * @details
9973  *
9974  *    Function : procSrbListToSetup
9975  *
9976  *    Functionality: Fills Srb List received  by CU
9977  *
9978  * @params[in] SRBs_ToBeSetup_Item_t *cuSrbItem
9979  *             LcCfg pointer
9980  *             RlcBearerCfg pointer
9981  * @return void
9982  *
9983  * ****************************************************************/
9984 uint8_t procSrbListToSetup(SRBs_ToBeSetup_Item_t * srbItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd)
9985 {
9986    uint8_t ret = ROK;
9987
9988    /* Filling RLC INFO */
9989    procRlcLcCfg(srbItem->sRBID, srbItem->sRBID, RB_TYPE_SRB, RLC_AM, CONFIG_ADD, NULL, rlcLcToAdd);
9990
9991    /* Filling MAC INFO */
9992    ret = procMacLcCfg(srbItem->sRBID, RB_TYPE_SRB, CONFIG_ADD, NULL,NULL, NULL, NULL, macLcToAdd, NULL);
9993    if(ret == RFAILED)
9994    {
9995       DU_LOG("\nERROR  -->  F1AP : Failed at MAC LC Cfg in procSrbListToSetup()");
9996       return ret;
9997    }
9998    return ret;
9999 }
10000
10001
10002
10003 /*******************************************************************
10004  *
10005  * @brief extract Srb List received by CU
10006  *
10007  * @details
10008  *
10009  *    Function : extractSrbListToSetup
10010  *
10011  *    Functionality: extract Srb List received by CU
10012  *                   for both MAC and RLC
10013  *
10014  * @params[in] SRBs_ToBeSetup_Item_t pointer
10015  *             DuUeCfg pointer
10016  * @return ROK/RFAIED
10017  *
10018  * ****************************************************************/
10019
10020 uint8_t extractSrbListToSetup(SRBs_ToBeSetup_List_t *srbCfg, DuUeCfg *ueCfgDb)
10021 {
10022    uint8_t ret, srbIdx;
10023    SRBs_ToBeSetup_Item_t *srbItem = NULLP;
10024
10025    if(srbCfg)
10026    {
10027       for(srbIdx = 0; srbIdx < srbCfg->list.count; srbIdx++)
10028       {
10029          srbItem = &srbCfg->list.array[srbIdx]->value.choice.SRBs_ToBeSetup_Item;
10030          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
10031          {
10032             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in MAC");
10033             ret = RFAILED;
10034             break;
10035          }
10036          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
10037          {
10038             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in RLC");
10039             ret = RFAILED;
10040             break;
10041          }
10042          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
10043          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
10044          ret = procSrbListToSetup(srbItem, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
10045             &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs]);
10046          ueCfgDb->numRlcLcs++;
10047          ueCfgDb->numMacLcs++;
10048          DU_LOG("\nDEBUG --> DUAPP: extractSrbListToSetup: SRBID: %d [RLC,MAC,NumDrb]:[%x,%x,%x]",\
10049                             srbItem->sRBID, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
10050          if(ret == RFAILED)
10051          {
10052             DU_LOG("\nERROR  -->  F1AP:  Failed at extractSrbListToSetup()");
10053             break;
10054          }
10055       }
10056    }
10057    else
10058       ret = RFAILED;
10059
10060    return ret;
10061 }
10062
10063 /*******************************************************************
10064  *
10065  * @brief Fills Drb List received by CU
10066  *
10067  * @details
10068  *
10069  *    Function : procDrbListToSetupMod
10070  *
10071  *    Functionality: Fills Drb List received by CU
10072  *                   for both MAC and RLC
10073  *
10074  * @params[in] SRBs_ToBeSetup_Item_t pointer
10075  *             LcCfg pointer,
10076  *             RlcBearerCfg pointer
10077  * @return void
10078  *
10079  * ****************************************************************/
10080
10081 uint8_t procDrbListToSetupMod(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbItem,\
10082 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd, UpTnlCfg *upTnlInfo)
10083 {
10084
10085    if(drbItem != NULLP)
10086    {
10087       /* Filling RLC INFO */
10088       procRlcLcCfg(drbItem->dRBID, lcId, RB_TYPE_DRB, drbItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd);
10089
10090       /* Filling MAC INFO */
10091       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, drbItem, NULL, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
10092       {
10093          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
10094          return RFAILED;
10095       }
10096    }
10097    else if(drbSetupModItem != NULLP)
10098    {
10099       procRlcLcCfg(drbSetupModItem->dRBID, lcId, RB_TYPE_DRB, drbSetupModItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd);
10100
10101       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, NULL, drbSetupModItem, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
10102       {
10103          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
10104          return RFAILED;
10105       }
10106    }
10107    else if(drbModItem != NULLP)
10108    {
10109       /* Drb to Mod IEs doesnot have rlcMode to be modified
10110        * in ASN. Hence no change in RLC configurations */
10111       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_MOD, NULL, NULL, drbModItem, NULL, macLcToAdd, upTnlInfo) != ROK)
10112       {
10113          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
10114          return RFAILED;
10115       }
10116    }
10117    return ROK;
10118 }
10119
10120 /*******************************************************************
10121  *
10122  * @brief extract Drb List received by CU
10123  *
10124  * @details
10125  *
10126  *    Function : extractDrbListToSetupMod
10127  *
10128  *    Functionality: extract Drb List received by CU
10129  *                   for both MAC and RLC
10130  *
10131  * @params[in] DRBs_ToBeSetup_Item_t pointer
10132  *             DuUeCfg pointer
10133  * @return ROK/RFAIED
10134  *
10135  * ****************************************************************/
10136
10137 uint8_t extractDrbListToSetupMod(DRBs_ToBeSetup_List_t *drbCfg, DRBs_ToBeSetupMod_List_t *drbSetupModCfg,\
10138  DRBs_ToBeModified_List_t *drbModCfg, uint8_t drbCount, DuUeCfg *ueCfgDb, uint32_t *drbBitMap)
10139 {
10140    uint8_t ret, drbIdx, lcId = 0;
10141    DRBs_ToBeSetup_Item_t *drbItem = NULLP;
10142    DRBs_ToBeSetupMod_ItemIEs_t *drbSetupModItem = NULLP;
10143    DRBs_ToBeModified_ItemIEs_t *drbModItem = NULLP;
10144
10145    ret = ROK;
10146    if(drbCount > 0)
10147    {
10148       for(drbIdx = 0; drbIdx < drbCount; drbIdx++)
10149       {
10150          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
10151          {
10152             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in MAC at extractDrbListToSetupMod()");
10153             ret = RFAILED;
10154             break;
10155          }
10156          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
10157          {
10158             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in RLC at extractDrbListToSetupMod()");
10159             ret = RFAILED;
10160             break;
10161          }
10162          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
10163          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
10164
10165          if(drbModCfg != NULLP)
10166          {
10167             drbModItem = (DRBs_ToBeModified_ItemIEs_t *) drbModCfg->list.array[drbIdx];
10168             lcId = fetchLcId(drbModItem->value.choice.DRBs_ToBeModified_Item.dRBID);
10169             if(lcId < MIN_DRB_LCID)
10170             {
10171                DU_LOG("\nERROR  --> F1AP : Failed fetching LCID %d in extractDrbListToSetupMod() for Modified List", lcId);
10172                break;
10173             }
10174             ret = procDrbListToSetupMod(lcId, NULL, NULL, &(drbModItem->value.choice.DRBs_ToBeModified_Item),\
10175             &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs],\
10176             &ueCfgDb->upTnlInfo[ueCfgDb->numDrb]);
10177             if(ret == RFAILED)
10178             {
10179                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for Modified List");
10180                break;
10181             }
10182
10183          }
10184          else
10185          {
10186             lcId = getDrbLcId(drbBitMap);
10187             if(lcId == RFAILED)
10188             {
10189                DU_LOG("\nERROR  -->  F1AP :  InCorrect LCID extractDrbListToSetupMod()");
10190                ret = RFAILED;
10191                break;
10192             }
10193             if(drbCfg != NULL)
10194             {
10195                drbItem = &drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
10196                ret = procDrbListToSetupMod(lcId, drbItem, NULL, NULL, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
10197                      &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], &ueCfgDb->upTnlInfo[ueCfgDb->numDrb]);
10198                if(ret == RFAILED)
10199                {
10200                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetup List");
10201                   break;
10202                }
10203             }
10204             else if(drbSetupModCfg != NULL)
10205             {
10206                drbSetupModItem = (DRBs_ToBeSetupMod_ItemIEs_t *) drbSetupModCfg->list.array[drbIdx];
10207                ret = procDrbListToSetupMod(lcId, NULL, &(drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item), NULL,\
10208                      &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs],\
10209                      &ueCfgDb->upTnlInfo[ueCfgDb->numDrb]);
10210                if(ret == RFAILED)
10211                {
10212                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetupMod List");
10213                   break;
10214                }
10215             }
10216             ueCfgDb->numRlcLcs++;
10217          }
10218          ueCfgDb->numMacLcs++;
10219          ueCfgDb->numDrb++;
10220
10221          DU_LOG("\nDEBUG --> DUAPP: extractDrbListToSetupMod:lcId:%x ,BitMap:%x, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
10222                             lcId,*drbBitMap, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
10223          if(ret == RFAILED)
10224          {
10225             DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod()");
10226             break;
10227          }
10228       }
10229    }
10230    else
10231       ret = RFAILED;
10232
10233    return ret;
10234 }
10235
10236 /*******************************************************************
10237  *
10238  * @brief Function to extract Dl RRC Msg received from CU
10239  *
10240  * @details
10241  *
10242  *    Function : extractDlRrcMsg
10243  *
10244  *    Functionality: Function to extract Dl RRC Msg received from CU
10245  *
10246  * @params[in] F1AP message
10247  * @return ROK     - success
10248  *         RFAILED - failure
10249  *
10250  * ****************************************************************/
10251
10252 uint8_t extractDlRrcMsg(uint32_t gnbDuUeF1apId, uint32_t gnbCuUeF1apId, \
10253    F1DlRrcMsg *dlRrcMsg, RRCContainer_t *rrcContainer)
10254 {
10255    uint8_t ret = ROK;
10256    dlRrcMsg->rrcMsgSize = rrcContainer->size;
10257    if(dlRrcMsg->rrcMsgSize > 0)
10258    {
10259       DU_ALLOC_SHRABL_BUF(dlRrcMsg->rrcMsgPdu, dlRrcMsg->rrcMsgSize);
10260       if(!dlRrcMsg->rrcMsgPdu)
10261       {
10262          DU_LOG("\nERROR  --> DU APP : Memory allocation failed for RRC Msg in extractDlRrcMsg()");
10263          ret = RFAILED;
10264       }
10265       else
10266       {
10267          dlRrcMsg->gnbDuUeF1apId = gnbDuUeF1apId;
10268          dlRrcMsg->gnbCuUeF1apId = gnbCuUeF1apId;
10269          dlRrcMsg->srbId = SRB1_LCID;
10270          memcpy(dlRrcMsg->rrcMsgPdu, rrcContainer->buf, dlRrcMsg->rrcMsgSize);
10271       }
10272    }
10273    return ret;
10274 }
10275
10276 /*******************************************************************
10277  *
10278  * @brief Extract UE capability info
10279  *
10280  * @details
10281  *
10282  *    Function : extractUeCapability
10283  *
10284  *    Functionality: Extract UE capability info and stores in ue Cb
10285  *
10286  * @params[in] Octet string of UE capability RAT container list
10287  * @return ROK     - success
10288  *         RFAILED - failure
10289  *
10290  * ****************************************************************/
10291 UE_NR_Capability_t *extractUeCapability(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf, DuUeCb *ueCb)
10292 {
10293    uint8_t  idx;
10294    uint16_t recvBufLen;
10295    asn_dec_rval_t rval;
10296    UE_NR_Capability_t  *ueNrCap = NULLP;
10297    UE_CapabilityRAT_ContainerListRRC_t  *ueCapRatContList = NULLP;
10298
10299    /* Decoding UE Capability RAT Container List */
10300    recvBufLen = ueCapablityListBuf->size;
10301    DU_ALLOC(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10302    if(!ueCapRatContList)
10303    {
10304       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
10305       return NULLP;
10306    }
10307    memset(ueCapRatContList, 0, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10308    memset(&rval, 0, sizeof(asn_dec_rval_t));
10309    rval = aper_decode(0, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, (void **)&ueCapRatContList,
10310           ueCapablityListBuf->buf, recvBufLen, 0, 0);
10311    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10312    {
10313       DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
10314       return NULLP;
10315    }
10316    xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, ueCapRatContList);
10317
10318    /* Free encoded buffer after decoding */
10319
10320    for(idx = 0; idx < ueCapRatContList->list.count; idx++)
10321    {
10322       if(ueCapRatContList->list.array[idx]->rat_Type == RAT_Type_nr)
10323       {
10324          /* Decoding UE NR Capability */
10325           recvBufLen = ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.size;
10326           DU_ALLOC(ueNrCap, sizeof(UE_NR_Capability_t));
10327           if(!ueNrCap)
10328           {
10329              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
10330              DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10331              return NULLP;
10332           }
10333           memset(ueNrCap, 0, sizeof(UE_NR_Capability_t));
10334           memset(&rval, 0, sizeof(asn_dec_rval_t));
10335           rval = aper_decode(0, &asn_DEF_UE_NR_Capability, (void **)&ueNrCap,
10336                  ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf, recvBufLen, 0, 0);
10337           if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10338           {
10339              DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
10340              return NULLP;
10341           }
10342           xer_fprint(stdout, &asn_DEF_UE_NR_Capability, ueNrCap);
10343
10344           /* Free encoded buffer after decoding */
10345           free(ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf);
10346       }
10347       free(ueCapRatContList->list.array[idx]);
10348    }
10349
10350    /* Free Memory*/
10351    free(ueCapRatContList->list.array);
10352    DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10353    return ueNrCap;
10354 }
10355
10356 /*******************************************************************
10357 *
10358 * @brief free UE context setup request from CU
10359 *
10360 * @details
10361 *
10362 *    Function : freeAperDecodeF1UeContextSetupReq
10363 *
10364 *    Functionality: freeing part for the memory allocated by aper_decoder
10365 *
10366 * @params[in] F1AP message
10367 * @return ROK     - success
10368 *         RFAILED - failure
10369 *
10370 * ****************************************************************/
10371 void freeAperDecodeF1UeContextSetupReq(UEContextSetupRequest_t   *ueSetReq)
10372 {
10373    uint8_t ieIdx = 0;
10374
10375    if(ueSetReq->protocolIEs.list.array != NULLP)
10376    {
10377       for(ieIdx = 0; ieIdx < ueSetReq->protocolIEs.list.count; ieIdx++)
10378       {
10379          if(ueSetReq->protocolIEs.list.array[ieIdx])
10380          {
10381             switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
10382             {
10383                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10384                   break;
10385                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10386                   break;
10387                case ProtocolIE_ID_id_SpCell_ID:
10388                   freeAperDecodeNrcgi(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
10389                   break;
10390                case ProtocolIE_ID_id_ServCellIndex:
10391                   break;
10392                case ProtocolIE_ID_id_SpCellULConfigured:
10393                   break;
10394                case ProtocolIE_ID_id_CUtoDURRCInformation:
10395
10396                   freeAperDecodeCuToDuInfo(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation);
10397                   break;
10398                case ProtocolIE_ID_id_SCell_ToBeSetup_List:
10399
10400                   freeAperDecodeSplCellList(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SCell_ToBeSetup_List);
10401                   break;
10402                case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
10403
10404                   freeAperDecodeSRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List);
10405                   break;
10406                case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
10407
10408                   freeAperDecodeDRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List);
10409                   break;
10410                case ProtocolIE_ID_id_RRCContainer:
10411                   {
10412
10413                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf != NULLP)
10414                      {
10415
10416                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
10417                      }
10418                      break;
10419                   }
10420                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10421                   break;
10422                case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
10423                   {
10424                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf)
10425                      {
10426                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf);
10427                      }
10428                      break;
10429                   }
10430                default:
10431                   DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld " ,ueSetReq->protocolIEs.list.array[ieIdx]->id);
10432             }
10433             free(ueSetReq->protocolIEs.list.array[ieIdx]);
10434          }
10435       }
10436       free(ueSetReq->protocolIEs.list.array);
10437    }
10438 }
10439 /*******************************************************************
10440  *
10441  * @brief Process UE context setup request from CU
10442  *
10443  * @details
10444  *
10445  *    Function : procF1UeContextSetupReq
10446  *
10447  *    Functionality: Process UE context setup request from CU
10448  *
10449  * @params[in] F1AP message
10450  * @return ROK     - success
10451  *         RFAILED - failure
10452  *
10453  * ****************************************************************/
10454 uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
10455 {
10456    uint8_t  ret=0, ieIdx=0, ueIdx=0, cellIdx=0;
10457    bool ueCbFound = false;
10458    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0, bitRateSize=0;
10459    DuUeCb   *duUeCb = NULL;
10460    UEContextSetupRequest_t   *ueSetReq = NULL;
10461    DRBs_ToBeSetup_List_t *drbCfg = NULL;
10462
10463    ret = ROK;
10464
10465    ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
10466    for(ieIdx=0; (ieIdx < ueSetReq->protocolIEs.list.count && ret == ROK); ieIdx++)
10467    {
10468       switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
10469       {
10470          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10471             {
10472                gnbCuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
10473                break;
10474             }
10475          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10476             {
10477                gnbDuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
10478                break;
10479             }
10480          case ProtocolIE_ID_id_ServCellIndex:
10481             {
10482                cellIdx = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.ServCellIndex;
10483                for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
10484                {
10485                   if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
10486                         (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
10487                   {
10488                      ueCbFound = true;
10489                      duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
10490                      DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
10491                      if(duUeCb->f1UeDb)
10492                      {
10493                         memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
10494                         duUeCb->f1UeDb->actionType = UE_CTXT_SETUP;
10495                         duUeCb->f1UeDb->cellIdx = cellIdx;
10496                      }
10497                      else
10498                      {
10499                         DU_LOG("\nERROR  -->  F1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
10500                         ret = RFAILED;
10501                      }
10502                      break;
10503                   }
10504                   else
10505                      ueCbFound = false;
10506
10507                }
10508                if(!ueCbFound)
10509                {
10510                   DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
10511                   ret = RFAILED;
10512                }
10513                break;
10514             }
10515          case ProtocolIE_ID_id_SpCellULConfigured:
10516             /* Indicates whether the gNB-CU requests the gNB-DU to configure the uplink as no UL,
10517                UL, SUL or UL+SUL for the indicated cell for the UE */
10518             break;
10519          case ProtocolIE_ID_id_CUtoDURRCInformation:
10520             {
10521                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.uE_CapabilityRAT_ContainerList)
10522                {
10523                   duUeCb->f1UeDb->duUeCfg.ueNrCapability = \
10524                   extractUeCapability(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.\
10525                   uE_CapabilityRAT_ContainerList, duUeCb);
10526                }
10527                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.iE_Extensions)
10528                {
10529                   duUeCb->f1UeDb->duUeCfg.cellGrpCfg = extractCellGrpInfo(ueSetReq->protocolIEs.list.array[ieIdx]->\
10530                         value.choice.CUtoDURRCInformation.iE_Extensions, &duUeCb->f1UeDb->duUeCfg);
10531                   if(!duUeCb->f1UeDb->duUeCfg.cellGrpCfg)
10532                   {
10533                      DU_LOG("\nERROR  -->  F1AP: Failed to extract cell Grp Info");
10534                      //TODO: Update the failure cause in ue context Setup Response
10535                      ret = RFAILED;
10536                   }
10537                }
10538                break;
10539             }
10540          case ProtocolIE_ID_id_SCell_ToBeSetup_List:
10541             {
10542                DU_LOG("\nINFO   -->  DU_APP: Received SCell_ToBeSetup_List but  Not processing the list");
10543                break;
10544             }
10545          case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
10546             {
10547                if(extractSrbListToSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List,\
10548                &duUeCb->f1UeDb->duUeCfg))
10549                {
10550                   DU_LOG("\nERROR  -->  DU APP : Failed at extractSrbListToSetup()");
10551                   //TODO: Update the failure cause in ue context Setup Response
10552                   ret = RFAILED;
10553                }
10554                break;
10555             }
10556          case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
10557             {
10558                   drbCfg = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List;
10559
10560                   if(extractDrbListToSetupMod(drbCfg, NULL, NULL, drbCfg->list.count, &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap))
10561                   {
10562                      DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod()");
10563                      //TODO: Update the failure cause in ue context Setup Response
10564                      ret = RFAILED;
10565                   }
10566                break;
10567             }
10568          case ProtocolIE_ID_id_RRCContainer:
10569             {
10570                /* Filling Dl RRC Msg Info */
10571                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
10572                if(!duUeCb->f1UeDb->dlRrcMsg)
10573                {
10574                   DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
10575                   ret = RFAILED;
10576                }
10577                else
10578                {
10579                   duUeCb->f1UeDb->dlRrcMsgPres = true;
10580                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
10581                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
10582                         &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer);
10583                }
10584                break;
10585             }
10586          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10587             {
10588                if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
10589                {
10590                   duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
10591                }
10592                else
10593                {
10594                   DU_LOG("\nERROR  -->  Ignoring delivery report, since rrcContainer is not present");
10595                }
10596                break;
10597             }
10598          case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
10599             {
10600                /* MaximumBitRate Uplink */
10601                bitRateSize = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.size;
10602                if(bitRateSize > 0)
10603                {
10604                   DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.ambrCfg, bitRateSize);
10605                   if(!duUeCb->f1UeDb->duUeCfg.ambrCfg)
10606                   {
10607                      DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
10608                      ret = RFAILED;
10609                   }
10610                   else
10611                   {
10612                      memset(duUeCb->f1UeDb->duUeCfg.ambrCfg, 0, sizeof(AmbrCfg));
10613                      memcpy(&duUeCb->f1UeDb->duUeCfg.ambrCfg->ulBr,
10614                            ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf, bitRateSize);
10615                   }
10616                }
10617                else
10618                   ret = RFAILED;
10619                break;
10620             }
10621          default:
10622             {
10623                break;
10624             }
10625       }
10626    }
10627    if(ret == RFAILED)
10628    {
10629       /*TODO : Negative case*/
10630       // BuildAndSendUeContextSetupRsp(cellId,ueIdx);
10631       DU_LOG("\nERROR  -->  F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
10632    }
10633    else
10634       ret = duProcUeContextSetupRequest(duUeCb);
10635
10636    freeAperDecodeF1UeContextSetupReq(ueSetReq);
10637    return ret;
10638
10639 }
10640 /*******************************************************************
10641  * @brief Free the memory allocated for Dl Tunnel Info
10642  *
10643  * @details
10644  *
10645  *    Function : freeDlTnlInfo
10646  *
10647  *    Functionality:
10648  *       Free the memory allocated for Dl Tunnel Info
10649  *
10650  * @params[in] DLUPTNLInformation_ToBeSetup_List_t *
10651  * @return void
10652  *
10653  * ****************************************************************/
10654
10655 void freeDlTnlInfo(DLUPTNLInformation_ToBeSetup_List_t *tnlInfo)
10656 {
10657    uint8_t arrIdx = 0;
10658
10659    if(tnlInfo)
10660    {
10661       for(arrIdx=0; arrIdx < tnlInfo->list.count; arrIdx++)
10662       {
10663          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf,\
10664                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
10665          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf,\
10666                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
10667          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
10668          DU_FREE(tnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
10669       }
10670       DU_FREE(tnlInfo->list.array, tnlInfo->list.size);
10671    }
10672 }
10673
10674 /*******************************************************************
10675  * @brief Free the memory allocated for DRB setup List
10676  *
10677  * @details
10678  *
10679  *    Function : freeDrbSetupList
10680  *
10681  *    Functionality:
10682  *       Free the memory allocated for DRB setup list
10683  *
10684  * @params[in] DRBs_Setup_List_t *
10685  * @return void
10686  *
10687  * ****************************************************************/
10688 void freeDrbSetupList(DRBs_Setup_List_t *drbSetupList)
10689 {
10690    uint8_t arrIdx = 0;
10691    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
10692
10693    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
10694    {
10695       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
10696       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
10697       DU_FREE(drbSetupList->list.array[arrIdx],  sizeof(DRBs_Setup_Item_t));
10698    }
10699    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
10700 }
10701
10702 /*******************************************************************
10703  * @brief Free the memory allocated for UE Setup response
10704  *
10705  * @details
10706  *
10707  *    Function : FreeUeContextSetupRsp
10708  *
10709  *    Functionality:
10710  *       Free the memory allocated for UE Setup response
10711  *
10712  * @params[in] F1AP PDU for UE setup response
10713  * @return ROK     - success
10714  *         RFAILED - failure
10715  *
10716  * ****************************************************************/
10717 void FreeUeContextSetupRsp(F1AP_PDU_t *f1apMsg)
10718 {
10719    uint8_t idx;
10720    UEContextSetupResponse_t *ueSetRsp = NULLP;
10721
10722    if(f1apMsg)
10723    {
10724       if(f1apMsg->choice.successfulOutcome)
10725       {
10726          ueSetRsp = &f1apMsg->choice.successfulOutcome->value.choice.\
10727                     UEContextSetupResponse;
10728          if(ueSetRsp->protocolIEs.list.array)
10729          {
10730             for(idx = 0; idx < ueSetRsp->protocolIEs.list.count; idx++)
10731             {
10732                if(ueSetRsp->protocolIEs.list.array[idx])
10733                {
10734                   switch(ueSetRsp->protocolIEs.list.array[idx]->id)
10735                   {
10736                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10737                         break;
10738                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10739                         break;
10740                      case ProtocolIE_ID_id_DUtoCURRCInformation:
10741                         {
10742                            CellGroupConfig_t *cellGrpCfg = NULLP;
10743                            cellGrpCfg  = &ueSetRsp->protocolIEs.list.array[idx]->value.choice.\
10744                                          DUtoCURRCInformation.cellGroupConfig;
10745                            if(cellGrpCfg->buf != NULLP)
10746                            {
10747                               DU_FREE(cellGrpCfg->buf, cellGrpCfg->size);
10748                               cellGrpCfg = NULLP;
10749                            }
10750                            break;
10751                         }
10752                     case ProtocolIE_ID_id_DRBs_Setup_List:
10753                         {
10754                            freeDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
10755                            break;
10756                         }
10757                      default:
10758                         DU_LOG("\nERROR  -->  DUAPP: Invalid Id %ld at FreeUeContextSetupRsp()",\
10759                         ueSetRsp->protocolIEs.list.array[idx]->id);
10760                         break;
10761                   }
10762                   DU_FREE(ueSetRsp->protocolIEs.list.array[idx],\
10763                         sizeof(UEContextSetupResponseIEs_t));
10764                }
10765             }
10766             DU_FREE(ueSetRsp->protocolIEs.list.array, \
10767                   ueSetRsp->protocolIEs.list.size);
10768          }
10769          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
10770       }
10771       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10772    }
10773 }
10774
10775 /*******************************************************************
10776  *
10777  * @brief Builds Ue context Setup Rsp DU To CU Info
10778  *
10779  * @details
10780  *
10781  *    Function : EncodeUeCntxtDuToCuInfo
10782  *
10783  *    Functionality: Builds Ue context Setup Rsp DU To CU Info
10784  *
10785  * @params[in] CellGroupConfig_t *, CellGroupConfigRrc_t *
10786  *
10787  * @return ROK     - success
10788  *         RFAILED - failure
10789  *
10790  ******************************************************************/
10791
10792 uint8_t EncodeUeCntxtDuToCuInfo(CellGroupConfig_t *duToCuCellGrp, CellGroupConfigRrc_t *duCellGrpCfg)
10793 {
10794    asn_enc_rval_t        encRetVal;
10795
10796    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, duCellGrpCfg);
10797    memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
10798    encBufSize = 0;
10799    encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, duCellGrpCfg, PrepFinalEncBuf, encBuf);
10800    /* Encode results */
10801    if(encRetVal.encoded == ENCODE_FAIL)
10802    {
10803       DU_LOG( "\nERROR  -->  F1AP : Could not encode UeCntxtDuToCuInfo (at %s)\n",\
10804             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10805       return RFAILED;
10806    }
10807    else
10808    {
10809       DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
10810       for(int i=0; i< encBufSize; i++)
10811       {
10812          printf("%x",encBuf[i]);
10813       }
10814    }
10815    duToCuCellGrp->size = encBufSize;
10816    DU_ALLOC(duToCuCellGrp->buf, duToCuCellGrp->size);
10817    if(!duToCuCellGrp->buf)
10818    {
10819       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in UeCntxtDuToCuInfo");
10820    }
10821    memcpy(duToCuCellGrp->buf, encBuf, duToCuCellGrp->size);
10822    return ROK;
10823 }
10824
10825 /*******************************************************************
10826  *
10827  * @brief Fills Dl Gtp tunnel Info
10828  *
10829  * @details
10830  *
10831  *    Function : fillGtpTunnelforDl
10832  *
10833  *    Functionality: Fills Dl Gtp tunnel Info
10834  *
10835  * @params[in]
10836  *
10837  * @return ROK     - success
10838  *         RFAILED - failure
10839  *
10840  * ****************************************************************/
10841
10842 uint8_t fillGtpTunnelforDl(GTPTunnel_t *gtpDl, GtpTnlCfg *gtpUeCfg)
10843 {
10844    uint8_t bufSize = 0;
10845
10846    gtpDl->transportLayerAddress.size    = 4*sizeof(uint8_t);
10847    DU_ALLOC(gtpDl->transportLayerAddress.buf, gtpDl->transportLayerAddress.size);
10848    if(gtpDl->transportLayerAddress.buf == NULLP)
10849    {
10850       return RFAILED;
10851    }
10852    memcpy(gtpDl->transportLayerAddress.buf, &gtpUeCfg->dlTnlAddress, gtpDl->transportLayerAddress.size);
10853
10854    /*GTP TEID*/
10855    gtpDl->gTP_TEID.size = 4 * sizeof(uint8_t);
10856    DU_ALLOC(gtpDl->gTP_TEID.buf, gtpDl->gTP_TEID.size);
10857    if(gtpDl->gTP_TEID.buf == NULLP)
10858    {
10859       return RFAILED;
10860    }
10861    bufSize = 3; /*forming an Octect String*/
10862    fillTeIdString(bufSize, gtpUeCfg->teId, gtpDl->gTP_TEID.buf);
10863
10864    return ROK;
10865 }
10866
10867 /*******************************************************************
10868  *
10869  * @brief Fills DL Tunnel Setup List
10870  *
10871  * @details
10872  *
10873  *    Function : fillDlTnlSetupList
10874  *
10875  *    Functionality: Fills the DL Tunnel Setup List
10876  *
10877  * @params[in]
10878  *
10879  * @return ROK     - success
10880  *         RFAILED - failure
10881  *
10882  * ****************************************************************/
10883
10884 uint8_t fillDlTnlSetupList(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo, UpTnlCfg *tnlCfg)
10885 {
10886    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
10887
10888    eleCount = 1;
10889    dlTnlInfo->list.count = eleCount;
10890    dlTnlInfo->list.size = (eleCount * sizeof(DLUPTNLInformation_ToBeSetup_Item_t *));
10891
10892    /* Initialize the DL Tnl Setup List Members */
10893    DU_ALLOC(dlTnlInfo->list.array, dlTnlInfo->list.size);
10894    if(dlTnlInfo->list.array == NULLP)
10895    {
10896       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL Tnl Setup List in fillDlTnlSetupList()");
10897       ret = RFAILED;
10898    }
10899    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
10900    {
10901       DU_ALLOC(dlTnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
10902       if(dlTnlInfo->list.array[arrIdx] == NULLP)
10903       {
10904          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDlTnlSetupList()", arrIdx);
10905          return RFAILED;
10906       }
10907       dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
10908       DU_ALLOC(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
10909       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel == NULLP)
10910       {
10911          DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL tunnel info in fillDlTnlSetupList()");
10912          return RFAILED;
10913       }
10914       ret = fillGtpTunnelforDl(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel,\
10915                tnlCfg->tnlCfg1);
10916       if(ret != ROK)
10917          break;
10918    }
10919    return ret;
10920 }
10921
10922 /*******************************************************************
10923  *
10924  * @brief Fills the Drb Setup List for Ue Context Setup Response
10925  *
10926  * @details
10927  *
10928  *    Function : fillDrbSetupList
10929  *
10930  *    Functionality: Fills the Drb Setup List for Ue Context Setup Response
10931  *
10932  * @params[in]
10933  *
10934  * @return ROK     - success
10935  *         RFAILED - failure
10936  *
10937  * ****************************************************************/
10938 uint8_t fillDrbSetupList(DRBs_Setup_List_t *drbSetupList, DuUeCfg *ueCfg)
10939 {
10940    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
10941    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
10942
10943    eleCount = ueCfg->numDrb;
10944    drbSetupList->list.count = eleCount;
10945    drbSetupList->list.size = \
10946         (eleCount * sizeof(DRBs_Setup_Item_t *));
10947
10948    /* Initialize the Drb Setup List Members */
10949    DU_ALLOC(drbSetupList->list.array, drbSetupList->list.size);
10950    if(drbSetupList->list.array == NULLP)
10951    {
10952       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DRB Setup List in fillDrbSetupList()");
10953       ret = RFAILED;
10954    }
10955
10956    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
10957    {
10958       DU_ALLOC(drbSetupList->list.array[arrIdx], sizeof(DRBs_Setup_Item_t));
10959       if(drbSetupList->list.array[arrIdx] == NULLP)
10960       {
10961          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDrbSetupList()", arrIdx);
10962          return RFAILED;
10963       }
10964       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
10965       drbItemIe->id = ProtocolIE_ID_id_DRBs_Setup_Item;
10966       drbItemIe->criticality = Criticality_reject;
10967       drbItemIe->value.present = DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item;
10968       drbItemIe->value.choice.DRBs_Setup_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
10969       ret = fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List,\
10970           &ueCfg->upTnlInfo[arrIdx]);
10971       if(ret != ROK)
10972          break;
10973    }
10974    return ret;
10975 }
10976
10977 /*******************************************************************
10978  *
10979  * @brief Builds and sends the UE Setup Response
10980  *
10981  * @details
10982  *
10983  *    Function : BuildAndSendUeContextSetupRsp
10984  *
10985  *    Functionality: Constructs the UE Setup Response and sends
10986  *                   it to the DU through SCTP.
10987  *
10988  * @params[in] uint8_t cellId,uint8_t ueIdx
10989  *
10990  * @return ROK     - success
10991  *         RFAILED - failure
10992  *
10993  * ****************************************************************/
10994 uint8_t BuildAndSendUeContextSetupRsp(uint8_t cellId,uint8_t ueIdx)
10995 {
10996    uint8_t   idx, ret, cellIdx, elementCnt;
10997    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
10998    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
10999    asn_enc_rval_t  encRetVal;        /* Encoder return value */
11000    F1AP_PDU_t               *f1apMsg = NULLP;
11001    UEContextSetupResponse_t *ueSetRsp = NULLP;
11002    CellGroupConfigRrc_t     *cellGrpCfg = NULLP;
11003    DuUeCb                   *ueCb = NULLP;
11004
11005    DU_LOG("\n INFO   -->  F1AP : Building UE Context Setup Response for cellId %d, ueIdx %d\n", cellId, ueIdx);
11006
11007    while(true)
11008    {
11009       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11010       if(f1apMsg == NULLP)
11011       {
11012          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11013          ret = RFAILED;
11014          break;
11015       }
11016
11017       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
11018       DU_ALLOC(f1apMsg->choice.successfulOutcome,
11019             sizeof(SuccessfulOutcome_t));
11020       if(f1apMsg->choice.successfulOutcome == NULLP)
11021       {
11022          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
11023          ret = RFAILED;
11024          break;
11025       }
11026
11027       f1apMsg->choice.successfulOutcome->procedureCode = \
11028                                                          ProcedureCode_id_UEContextSetup;
11029       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
11030       f1apMsg->choice.successfulOutcome->value.present = \
11031                                                          SuccessfulOutcome__value_PR_UEContextSetupResponse;
11032
11033       ueSetRsp =
11034          &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
11035       elementCnt = 4;
11036       ueSetRsp->protocolIEs.list.count = elementCnt;
11037       ueSetRsp->protocolIEs.list.size = \
11038                                         elementCnt * sizeof(UEContextSetupResponse_t *);
11039
11040       /* Initialize the UESetup members */
11041       DU_ALLOC(ueSetRsp->protocolIEs.list.array, \
11042             ueSetRsp->protocolIEs.list.size);
11043       if(ueSetRsp->protocolIEs.list.array == NULLP)
11044       {
11045          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
11046          ret = RFAILED;
11047          break;
11048       }
11049
11050       for(idx=0; idx<elementCnt; idx++)
11051       {
11052          DU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
11053                sizeof(UEContextSetupResponseIEs_t));
11054          if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
11055          {
11056             DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
11057             ret = RFAILED;
11058             break;
11059          }
11060       }
11061       /* Fetching Ue Cb Info*/
11062       GET_CELL_IDX(cellId, cellIdx);
11063       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
11064       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
11065       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
11066
11067       idx = 0;
11068       /*GNB CU UE F1AP ID*/
11069       ueSetRsp->protocolIEs.list.array[idx]->id = \
11070                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11071       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11072       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
11073                                                              UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
11074       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
11075
11076       /*GNB DU UE F1AP ID*/
11077       idx++;
11078       ueSetRsp->protocolIEs.list.array[idx]->id = \
11079                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11080       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11081       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
11082                                                              UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
11083       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
11084
11085
11086       /*DUtoCURRC Information */
11087       idx++;
11088       ueSetRsp->protocolIEs.list.array[idx]->id  = \
11089                                                    ProtocolIE_ID_id_DUtoCURRCInformation;
11090       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11091       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
11092                                                             UEContextSetupResponseIEs__value_PR_DUtoCURRCInformation;
11093       if(ueCb->f1UeDb)
11094       {
11095          if(ueCb->f1UeDb->duUeCfg.cellGrpCfg)
11096          {
11097             cellGrpCfg = (CellGroupConfigRrc_t*)ueCb->f1UeDb->duUeCfg.cellGrpCfg;
11098             ret = EncodeUeCntxtDuToCuInfo(&ueSetRsp->protocolIEs.list.array[idx]->value.\
11099                      choice.DUtoCURRCInformation.cellGroupConfig, cellGrpCfg);
11100             if(ret == RFAILED)
11101             {
11102                DU_LOG("\nERROR  -->  F1AP : Failed to EncodeUeCntxtDuToCuInfo in BuildAndSendUeContextSetupRsp()");
11103                freeF1UeDb(ueCb->f1UeDb);
11104                ueCb->f1UeDb = NULLP;
11105                break;
11106             }
11107          }
11108       }
11109       else
11110       {
11111          DU_LOG("\nERROR  -->  F1AP : Failed to form DUtoCU RRCInfo at BuildAndSendUeContextSetupRsp()");
11112          ret = RFAILED;
11113          break;
11114       }
11115
11116       /* Drb Setup List */
11117       idx++;
11118       ueSetRsp->protocolIEs.list.array[idx]->id  = \
11119                                  ProtocolIE_ID_id_DRBs_Setup_List;
11120       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11121       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
11122                                  UEContextSetupResponseIEs__value_PR_DRBs_Setup_List;
11123       ret = fillDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List,\
11124                &ueCb->f1UeDb->duUeCfg);
11125       if(ret == RFAILED)
11126       {
11127          DU_LOG("\nERROR  -->  F1AP : Failed to fillDrbSetupList in BuildAndSendUeContextSetupRsp()");
11128          freeF1UeDb(ueCb->f1UeDb);
11129          ueCb->f1UeDb = NULLP;
11130          break;
11131       }
11132
11133        /* Free UeContext Db created during Ue context Req */
11134        freeF1UeDb(ueCb->f1UeDb);
11135        ueCb->f1UeDb = NULLP;
11136
11137       /* TODO: To send Drb list */
11138       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11139
11140       /* Encode the UE context setup response type as APER */
11141       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
11142       encBufSize = 0;
11143       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11144             encBuf);
11145       /* Encode results */
11146       if(encRetVal.encoded == ENCODE_FAIL)
11147       {
11148          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Response structure (at %s)\n",\
11149                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11150          ret = RFAILED;
11151          break;
11152       }
11153       else
11154       {
11155          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Setup Response\n");
11156          for(int i=0; i< encBufSize; i++)
11157          {
11158             printf("%x",encBuf[i]);
11159          }
11160       }
11161
11162       /* Sending  msg  */
11163       if(sendF1APMsg()  != ROK)
11164       {
11165          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Response failed");
11166          ret = RFAILED;
11167          break;
11168       }
11169       break;
11170    }
11171    FreeUeContextSetupRsp(f1apMsg);
11172    return ret;
11173 }/* End of BuildAndSendUeContextSetupRsp */
11174 /*******************************************************************
11175 *
11176 * @brief  Build And Send Ue Context Rsp
11177 *
11178 * @details
11179 *
11180 *    Function : BuildAndSendUeCtxtRsp
11181 *
11182 *    Functionality : Build And Send Ue Context Rsp
11183
11184 * @params[in]
11185 * @return sucess = ROK
11186 *         failure = RFAILED
11187 *
11188 * ****************************************************************/
11189 uint8_t BuildAndSendUeCtxtRsp(uint8_t cellId, uint8_t ueIdx)
11190 {
11191    uint8_t cellIdx = 0, actionType = 0;
11192
11193    GET_CELL_IDX(cellId, cellIdx);
11194    actionType = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].f1UeDb->actionType;
11195
11196    switch(actionType)
11197    {
11198       case UE_CTXT_SETUP:
11199          {
11200             BuildAndSendUeContextSetupRsp(cellId,ueIdx);
11201             break;
11202          }
11203       case UE_CTXT_MOD:
11204          {
11205             BuildAndSendUeContextModRsp(cellId, ueIdx);
11206             break;
11207          }
11208       default:
11209          DU_LOG("ERROR  -->  F1AP: Invalid Action Type %d at BuildAndSendUeCtxtRsp()", actionType);
11210          break;
11211
11212    }
11213    return ROK;
11214 }
11215
11216 /*******************************************************************
11217  *
11218  * @brief deallocating the memory of  F1reset msg
11219  *
11220  * @details
11221  *
11222  *    Function : FreeF1ResetReq
11223  *
11224  *    Functionality :
11225  *         - freeing memory of F1reset request msg
11226  *
11227  * @params[in]
11228  * @return void
11229  *
11230  *
11231  * ****************************************************************/
11232 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
11233 {
11234    uint8_t idx =0 ;
11235    Reset_t *f1ResetMsg;
11236
11237    if(f1apMsg)
11238    {
11239       if(f1apMsg->choice.initiatingMessage)
11240       {
11241          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11242
11243          if(f1ResetMsg->protocolIEs.list.array)
11244          {
11245             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
11246             {
11247                if(f1ResetMsg->protocolIEs.list.array[idx])
11248                {
11249                   DU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
11250                }
11251             }
11252             DU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
11253          }
11254          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11255       }
11256       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11257    }
11258 }
11259 /*******************************************************************
11260  *
11261  * @brief Build and Send F1reset request
11262  *
11263  * @details
11264  *
11265  *    Function : BuildAndSendF1ResetReq
11266  *
11267  *    Functionality:
11268  *         - Build and Send F1reset request msg
11269  *
11270  * @params[in]
11271  * @return ROK     - success
11272  *         RFAILED - failure
11273  *
11274  * ****************************************************************/
11275 uint8_t BuildAndSendF1ResetReq()
11276 {
11277    uint8_t          elementCnt=0;
11278    uint8_t          idx=0;
11279    uint8_t          ret= RFAILED;
11280    Reset_t          *f1ResetMsg = NULLP;
11281    F1AP_PDU_t       *f1apMsg = NULLP;
11282    asn_enc_rval_t   encRetVal;
11283    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset request \n");
11284    do
11285    {
11286       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11287       if(f1apMsg == NULLP)
11288       {
11289          break;
11290       }
11291       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
11292       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11293       if(f1apMsg->choice.initiatingMessage == NULLP)
11294       {
11295          break;
11296       }
11297       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
11298       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
11299       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
11300
11301       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11302
11303       elementCnt = 3;
11304       f1ResetMsg->protocolIEs.list.count = elementCnt;
11305       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
11306
11307       /* Initialize the F1Setup members */
11308       DU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
11309       if(f1ResetMsg->protocolIEs.list.array == NULLP)
11310       {
11311          break;
11312       }
11313       for(idx=0; idx<elementCnt; idx++)
11314       {
11315          DU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
11316          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
11317          {
11318             break;
11319          }
11320       }
11321
11322       /*TransactionID*/
11323       idx=0;
11324       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
11325       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11326       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
11327       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
11328
11329       /*Cause*/
11330       idx++;
11331       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
11332       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
11333       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
11334       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
11335       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
11336
11337       /*Reset Type*/
11338       idx++;
11339       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
11340       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11341       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
11342       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
11343       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
11344
11345       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11346
11347       /* Encode the F1SetupRequest type as APER */
11348       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11349       encBufSize = 0;
11350       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11351             encBuf);
11352
11353       /* Encode results */
11354       if(encRetVal.encoded == ENCODE_FAIL)
11355       {
11356          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
11357                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11358          break;
11359       }
11360       else
11361       {
11362          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1Reset\n");
11363          for(idx=0; idx< encBufSize; idx++)
11364          {
11365             printf("%x",encBuf[idx]);
11366          }
11367       }
11368
11369       if(sendF1APMsg() != ROK)
11370       {
11371          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
11372          break;
11373       }
11374
11375       ret = ROK;
11376       break;
11377    }while(true);
11378
11379    FreeF1ResetReq(f1apMsg);
11380    return ret;
11381 }
11382 /*******************************************************************
11383  *
11384  * @brief Build And Send F1ResetAck
11385  *
11386  * @details
11387  *
11388  *    Function : BuildAndSendF1ResetAck
11389  *
11390  *    Functionality:
11391  *         - Build And Send  F1ResetRSP
11392  *
11393  * @return ROK     - success
11394  *         RFAILED - failure
11395  *
11396  * ****************************************************************/
11397 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
11398 {
11399    uint8_t idx;
11400    ResetAcknowledge_t *f1ResetAck;
11401
11402    if(f1apMsg)
11403    {
11404       if(f1apMsg->choice.successfulOutcome)
11405       {
11406          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
11407
11408          if(f1ResetAck->protocolIEs.list.array)
11409          {
11410             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
11411             {
11412                if(f1ResetAck->protocolIEs.list.array[idx])
11413                {
11414                   DU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
11415                }
11416             }
11417             DU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
11418          }
11419          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11420       }
11421       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11422    }
11423 }
11424
11425 /*******************************************************************
11426  *
11427  * @brief Build And Send F1ResetAck
11428  *
11429  * @details
11430  *
11431  *    Function : BuildAndSendF1ResetAck
11432  *
11433  *    Functionality:
11434  *         - Build And Send  F1ResetRSP
11435  *
11436  *  @params[in]
11437  * @return ROK     - success
11438  *         RFAILED - failure
11439  *
11440  * ****************************************************************/
11441 uint8_t BuildAndSendF1ResetAck()
11442 {
11443    uint8_t                idx = 0;
11444    uint8_t                elementCnt = 0;
11445    uint8_t                ret = RFAILED;
11446    F1AP_PDU_t             *f1apMsg = NULL;
11447    ResetAcknowledge_t     *f1ResetAck = NULLP;
11448    asn_enc_rval_t         encRetVal;
11449    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset Acknowledgment \n");
11450
11451    do{
11452       /* Allocate the memory for F1ResetRequest_t */
11453       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11454       if(f1apMsg == NULLP)
11455       {
11456          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11457          break;
11458       }
11459
11460       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
11461
11462       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11463       if(f1apMsg->choice.successfulOutcome == NULLP)
11464       {
11465          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11466          break;
11467       }
11468       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
11469       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
11470       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
11471
11472       elementCnt = 1;
11473
11474       f1ResetAck->protocolIEs.list.count = elementCnt;
11475       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
11476
11477       DU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
11478       if(f1ResetAck->protocolIEs.list.array == NULLP)
11479       {
11480          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
11481          break;
11482       }
11483
11484       for(idx=0; idx<elementCnt; idx++)
11485       {
11486          DU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
11487          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
11488          {
11489             break;
11490          }
11491       }
11492       /*TransactionID*/
11493       idx = 0;
11494       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
11495       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11496       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
11497       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
11498
11499       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11500
11501       /* Encode the F1SetupRequest type as UPER */
11502       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11503       encBufSize = 0;
11504       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
11505
11506       /* Check encode results */
11507       if(encRetVal.encoded == ENCODE_FAIL)
11508       {
11509          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
11510                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11511          break;
11512       }
11513       else
11514       {
11515          DU_LOG("\nDUBUG   -->  F1AP : Created APER encoded buffer for F1ResetAck\n");
11516          for(int i=0; i< encBufSize; i++)
11517          {
11518             printf("%x",encBuf[i]);
11519          }
11520       }
11521       /* Sending msg */
11522       if(sendF1APMsg() != ROK)
11523       {
11524          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Acknowledgement failed");
11525          break;
11526       }
11527
11528       ret = ROK;
11529       break;
11530    }while(true);
11531
11532    FreeF1ResetAck(f1apMsg);
11533    return ret;
11534 }
11535 /******************************************************************
11536 *
11537 * @brief free F1 reset msg allocated by aper_decoder
11538 *
11539 * @details
11540 *
11541 *    Function : freeAperDecodeF1ResetMsg
11542 *
11543 *    Functionality: free F1 reset msg allocated by aper_decoder
11544 *
11545 * @params[in] Reset_t *f1ResetMsg
11546 * @return void
11547 *
11548 * ****************************************************************/
11549
11550 void freeAperDecodeF1ResetMsg(Reset_t *f1ResetMsg)
11551 {
11552    uint8_t ieIdx =0;
11553    if(f1ResetMsg->protocolIEs.list.array)
11554    {
11555       for(ieIdx=0 ;ieIdx < f1ResetMsg->protocolIEs.list.count ; ieIdx++)
11556       {
11557          if(f1ResetMsg->protocolIEs.list.array[ieIdx])
11558          {
11559             free(f1ResetMsg->protocolIEs.list.array[ieIdx]);
11560          }
11561       }
11562       free(f1ResetMsg->protocolIEs.list.array);
11563    }
11564 }
11565
11566 /******************************************************************
11567  *
11568  * @brief Processes DL RRC Message Transfer  sent by CU
11569  *
11570  * @details
11571  *
11572  *    Function : procF1ResetReq
11573  *
11574  *    Functionality: Processes DL RRC Message Transfer sent by CU
11575  *
11576  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11577  * @return ROK     - success
11578  *         RFAILED - failure
11579  *
11580  * ****************************************************************/
11581 uint8_t procF1ResetReq(F1AP_PDU_t *f1apMsg)
11582 {
11583    /* we are currently not supporting Ue release. right now we are supporting only init case of fireset */
11584    uint8_t       ieIdx = 0;
11585    uint8_t        ret = ROK;
11586    Reset_t       *f1ResetMsg = NULLP;
11587
11588    DU_LOG("\nINFO   -->  Processing F1 reset request");
11589    f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11590
11591    for(ieIdx=0; ieIdx<f1ResetMsg->protocolIEs.list.count; ieIdx++)
11592    {
11593       switch(f1ResetMsg->protocolIEs.list.array[ieIdx]->id)
11594       {
11595          case ProtocolIE_ID_id_TransactionID:
11596             break;
11597
11598          case ProtocolIE_ID_id_Cause:
11599             break;
11600
11601          case ProtocolIE_ID_id_ResetType:
11602             {
11603                break;
11604             }
11605
11606          default:
11607             break;
11608       }
11609    }
11610    ret = BuildAndSendF1ResetAck();
11611    DU_LOG("\nINFO   -->  UE release is not supported for now");
11612
11613    freeAperDecodeF1ResetMsg(f1ResetMsg);
11614
11615    return ret;
11616 }
11617
11618 /*******************************************************************
11619  *
11620  * @brief free the RRC delivery report
11621  *
11622  * @details
11623  *
11624  *    Function : freeRrcDeliveryReport
11625  *
11626  *    Functionality: free the RRC delivery report
11627  *
11628  * @params[in]
11629  * @return ROK     - success
11630  *         RFAILED - failure
11631  *
11632  * ****************************************************************/
11633 void freeRrcDeliveryReport(F1AP_PDU_t  *f1apMsg )
11634 {
11635    uint8_t idx=0;
11636    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11637
11638    if(f1apMsg)
11639    {
11640       if(f1apMsg->choice.initiatingMessage)
11641       {
11642          rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11643          if(rrcDeliveryReport->protocolIEs.list.array)
11644          {
11645             for(idx =0 ;idx <rrcDeliveryReport->protocolIEs.list.count ;
11646                   idx++)
11647             {
11648                if(rrcDeliveryReport->protocolIEs.list.array[idx])
11649                {
11650                   DU_FREE(rrcDeliveryReport->protocolIEs.list.array[idx],
11651                         sizeof(RRCDeliveryReportIEs_t));
11652                }
11653             }
11654             DU_FREE(rrcDeliveryReport->protocolIEs.list.array,
11655                   rrcDeliveryReport->protocolIEs.list.size);
11656          }
11657          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11658       }
11659       DU_FREE(f1apMsg,
11660             sizeof(F1AP_PDU_t));
11661    }
11662 }
11663
11664 /*******************************************************************
11665 *
11666 * @brief Builds and sends the RRC delivery report
11667 *
11668 * @details
11669 *
11670 *    Function : BuildAndSendRrcDeliveryReport
11671 *
11672 *    Functionality: Builds and sends the RRC delivery report
11673 *
11674 * @params[in]
11675 *
11676 * @return ROK     - success
11677 *         RFAILED - failure
11678 *
11679 * ****************************************************************/
11680 uint8_t BuildAndSendRrcDeliveryReport(uint32_t gnbCuUeF1apId, \
11681    uint32_t gnbDuUeF1apId, RrcDeliveryReport *rrcDelivery)
11682 {
11683    uint8_t             ret = RFAILED;
11684    uint8_t             idx    = 0;
11685    uint8_t             idx1   = 0;
11686    uint8_t             elementCnt = 0;
11687    F1AP_PDU_t          *f1apMsg = NULLP;
11688    asn_enc_rval_t      encRetVal;
11689    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11690
11691    do{
11692
11693       DU_LOG("\nINFO   -->  F1AP : Building RRC delivery Message Transfer Message\n");
11694       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11695       if(f1apMsg == NULLP)
11696       {
11697          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11698          break;
11699       }
11700       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
11701       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11702       if(f1apMsg->choice.initiatingMessage == NULLP)
11703       {
11704          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU  failed");
11705          break;
11706       }
11707       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_RRCDeliveryReport;
11708       f1apMsg->choice.initiatingMessage->criticality   = Criticality_ignore;
11709       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RRCDeliveryReport;
11710
11711       rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11712       elementCnt = 4;
11713       rrcDeliveryReport->protocolIEs.list.count = elementCnt;
11714       rrcDeliveryReport->protocolIEs.list.size = elementCnt * sizeof(RRCDeliveryReportIEs_t *);
11715
11716       /* Initialize the F1Setup members */
11717       DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array, rrcDeliveryReport->protocolIEs.list.size);
11718       if(rrcDeliveryReport->protocolIEs.list.array == NULLP)
11719       {
11720          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRC Delivery  failed");
11721          break;
11722       }
11723       for(idx =0 ;idx <elementCnt; idx++)
11724       {
11725          DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array[idx], sizeof(RRCDeliveryReportIEs_t));
11726          if(rrcDeliveryReport->protocolIEs.list.array[idx] == NULLP)
11727          {
11728             break;
11729          }
11730       }
11731
11732       idx1 = 0;
11733
11734       /*GNB CU UE F1AP ID*/
11735       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11736       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
11737       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_CU_UE_F1AP_ID;
11738       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
11739
11740       /*GNB DU UE F1AP ID*/
11741       idx1++;
11742       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11743       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
11744       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_DU_UE_F1AP_ID;
11745       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
11746
11747       /*RRC delivery status*/
11748       idx1++;
11749       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_RRCDeliveryStatus;
11750       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
11751       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_RRCDeliveryStatus;
11752       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.delivery_status =\
11753       rrcDelivery->rrcDeliveryStatus.deliveryStatus;
11754       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.triggering_message =\
11755       rrcDelivery->rrcDeliveryStatus.triggeringMessage;
11756
11757       /* SRB ID */
11758       idx1++;
11759       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
11760       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
11761       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_SRBID;
11762       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.SRBID =  rrcDelivery->srbId;
11763
11764       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11765
11766       /* Encode the RRC DELIVERY REPORT type as APER */
11767       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11768       encBufSize = 0;
11769       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11770             encBuf);
11771
11772       /* Encode results */
11773       if(encRetVal.encoded == ENCODE_FAIL)
11774       {
11775          DU_LOG("\nERROR  -->  F1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
11776                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11777          break;
11778       }
11779       else
11780       {
11781          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for RRC Delivery Msg \n");
11782          for(idx=0; idx< encBufSize; idx++)
11783          {
11784             printf("%x",encBuf[idx]);
11785          }
11786       }
11787
11788       /* Sending msg */
11789       if(sendF1APMsg() != ROK)
11790       {
11791          DU_LOG("\nERROR  -->  F1AP : Sending RRC delivery  msg request failed");
11792          break;
11793       }
11794       ret = ROK;
11795       break;
11796
11797    }while(true);
11798
11799    freeRrcDeliveryReport(f1apMsg);
11800    return ret;
11801 }
11802
11803 /*******************************************************************
11804  *
11805  * @brief Processes cells to be activated
11806  *
11807  * @details
11808  *
11809  *    Function : extractCellsToBeActivated
11810  *
11811  *    Functionality:
11812  *      - Processes cells to be activated list received in F1SetupRsp
11813  *
11814  * @params[in] void
11815  * @return ROK     - success
11816  *         RFAILED - failure
11817  *
11818  * ****************************************************************/
11819
11820 uint8_t extractCellsToBeActivated(Cells_to_be_Activated_List_t cellsToActivate)
11821 {
11822    uint8_t  ret = ROK;
11823    uint16_t idx, nci, pci = 0;
11824    Cells_to_be_Activated_List_Item_t cell;
11825
11826    for(idx=0; idx<cellsToActivate.list.count; idx++)
11827    {
11828       nci = 0;
11829       cell = cellsToActivate.list.array[idx]->value.choice.Cells_to_be_Activated_List_Item;
11830       bitStringToInt(&cell.nRCGI.nRCellIdentity, &nci);
11831
11832       if(cell.nRPCI)
11833       {
11834          pci = *cell.nRPCI;
11835       }
11836       ret = duProcCellsToBeActivated(cell.nRCGI.pLMN_Identity.buf, nci, pci);
11837    }
11838    return ret;
11839 }
11840 /******************************************************************
11841 *
11842 * @brief Processes F1 Setup Response allocated by aper_decoder
11843 *
11844 * @details
11845 *
11846 *    Function : freeF1SetupRsp
11847 *
11848 *    Functionality: free F1 Setup Response allocated by aper_decoder
11849 *
11850 * @params[in] F1SetupResponse_t *f1SetRspMsg
11851 * @return void
11852 *
11853 * ****************************************************************/
11854
11855 void freeAperDecodeF1SetupRsp(F1SetupResponse_t *f1SetRspMsg)
11856 {
11857    uint8_t ieIdx =0;
11858    uint8_t arrIdx =0;
11859    Cells_to_be_Activated_List_t *cellToActivate =NULLP;
11860    RRC_Version_t      *rrcVer =NULLP;
11861
11862    if(f1SetRspMsg->protocolIEs.list.array)
11863    {
11864       for(ieIdx=0; ieIdx<f1SetRspMsg->protocolIEs.list.count; ieIdx++)
11865       {
11866          if(f1SetRspMsg->protocolIEs.list.array[ieIdx])
11867          {
11868             switch(f1SetRspMsg->protocolIEs.list.array[ieIdx]->id)
11869             {
11870                case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11871                   {
11872                      cellToActivate =
11873                         &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.Cells_to_be_Activated_List;
11874                      if(cellToActivate->list.array)
11875                      {
11876                         for(arrIdx=0; arrIdx<cellToActivate->list.count ; arrIdx++)
11877                         {
11878                            if(cellToActivate->list.array[arrIdx])
11879                            {
11880
11881                               if(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.\
11882                               pLMN_Identity.buf)
11883                               {
11884                                  if(cellToActivate->list.array[0]->value.choice.\
11885                                        Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf)
11886                                  {
11887                                     free(cellToActivate->list.array[0]->value.choice.\
11888                                           Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf);
11889                                  }
11890
11891                                  free(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
11892                                        nRCGI.pLMN_Identity.buf);
11893                               }
11894                               free(cellToActivate->list.array[arrIdx]);
11895                            }
11896                         }
11897                         free(cellToActivate->list.array);
11898                      }
11899                      break;
11900                   }
11901                case ProtocolIE_ID_id_TransactionID:
11902                   {
11903                      break;
11904                   }
11905                case ProtocolIE_ID_id_gNB_CU_Name:
11906                   {
11907                      free(f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_Name.buf);
11908                      break;
11909                   }
11910                case ProtocolIE_ID_id_GNB_CU_RRC_Version:
11911                   {
11912                      rrcVer = &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
11913                      if(rrcVer->latest_RRC_Version.buf)
11914                      {
11915                         if(rrcVer->iE_Extensions)
11916                         {
11917                            if(rrcVer->iE_Extensions->list.array)
11918                            {
11919                               if(rrcVer->iE_Extensions->list.array[0])
11920                               {
11921                                  if(rrcVer->iE_Extensions->list.\
11922                                        array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf)
11923                                  {
11924                                     free(rrcVer->iE_Extensions->list.\
11925                                           array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf);
11926                                  }
11927                                  free(rrcVer->iE_Extensions->list.array[0]);
11928                               }
11929                               free(rrcVer->iE_Extensions->list.array);
11930                            }
11931                            free(rrcVer->iE_Extensions);
11932                         }
11933                         free(rrcVer->latest_RRC_Version.buf);
11934                      }
11935                      break;
11936
11937                   }
11938                default:
11939                   {
11940                      DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
11941                            f1SetRspMsg->protocolIEs.list.array[ieIdx]->id);
11942                   }
11943             }
11944             free(f1SetRspMsg->protocolIEs.list.array[ieIdx]);
11945          }
11946       }
11947       free(f1SetRspMsg->protocolIEs.list.array);
11948    }
11949 }
11950 /******************************************************************
11951  *
11952  * @brief Processes F1 Setup Response sent by CU
11953  *
11954  * @details
11955  *
11956  *    Function : procF1SetupRsp
11957  *
11958  *    Functionality: Processes F1 Setup Response sent by CU
11959  *
11960  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11961  * @return ROK     - success
11962  *         RFAILED - failure
11963  *
11964  * ****************************************************************/
11965 uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg)
11966 {
11967    uint8_t ret = ROK;
11968    uint16_t idx =0;
11969    F1SetupResponse_t *f1SetRspMsg = NULLP;
11970    GNB_CU_Name_t     *cuName = NULLP;
11971    F1SetupRsp  f1SetRspDb;
11972    RRC_Version_t      *rrcVer =NULLP;
11973
11974    memset(&f1SetRspDb, 0, sizeof(F1SetupRsp));
11975
11976    DU_LOG("\nINFO   -->  F1AP : F1 Setup Response received");
11977    f1SetRspMsg = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
11978
11979    for(idx=0; idx<f1SetRspMsg->protocolIEs.list.count; idx++)
11980    {
11981       switch(f1SetRspMsg->protocolIEs.list.array[idx]->id)
11982       {
11983          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11984             {
11985                extractCellsToBeActivated(f1SetRspMsg->protocolIEs.list.array[idx]->\
11986                      value.choice.Cells_to_be_Activated_List);
11987                break;
11988             }
11989          case ProtocolIE_ID_id_TransactionID:
11990             {
11991                f1SetRspDb.transId = f1SetRspMsg->protocolIEs.list.array[idx]->\
11992                                     value.choice.TransactionID;
11993                break;
11994             }
11995          case ProtocolIE_ID_id_gNB_CU_Name:
11996             {
11997                cuName = &f1SetRspMsg->protocolIEs.list.array[idx]->\
11998                         value.choice.GNB_CU_Name;
11999                strcpy(f1SetRspDb.cuName, (const char*)cuName->buf);
12000                break;
12001             }
12002          case ProtocolIE_ID_id_GNB_CU_RRC_Version:
12003             {
12004                rrcVer = &f1SetRspMsg->protocolIEs.list.array[idx]->value.choice.RRC_Version;
12005                strcpy(f1SetRspDb.rrcVersion.rrcVer,
12006                      (const char*)rrcVer->latest_RRC_Version.buf);
12007                break;
12008             }
12009          default:
12010             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
12011                   f1SetRspMsg->protocolIEs.list.array[idx]->id);
12012       }
12013       duProcF1SetupRsp();
12014    }
12015
12016    freeAperDecodeF1SetupRsp(f1SetRspMsg);
12017    return ret;
12018 }
12019 /*******************************************************************
12020 *
12021 * @brief free GNB DU config update ack
12022 *
12023 * @details
12024 *
12025 *    Function : freeAperDecodeGnbDuAck
12026 *
12027 *    Functionality: Processes GNB DU config update ack And
12028 *                     added free part for the memory allocated by aper_decoder
12029 *
12030 * @params[in] F1AP_PDU_t ASN decoded F1AP message
12031 * @return ROK     - success
12032 *         RFAILED - failure
12033 *
12034 * ****************************************************************/
12035
12036 void freeAperDecodeGnbDuAck(GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck)
12037 {
12038    uint8_t ieIdx = 0;
12039
12040    if(gnbDuAck->protocolIEs.list.array)
12041    {
12042       for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
12043       {
12044          if(gnbDuAck->protocolIEs.list.array[ieIdx])
12045          {
12046             free(gnbDuAck->protocolIEs.list.array[ieIdx]);
12047          }
12048       }
12049       free(gnbDuAck->protocolIEs.list.array);
12050    }
12051 }
12052
12053 /*******************************************************************
12054 *
12055 * @brief Building  result of gnb-du config update ack output
12056 *
12057 * @details
12058 *
12059 *    Function : duProcGnbDuCfgUpdAckMsg
12060 *
12061 *    Functionality:
12062 *        Building output of gnb-du config update ack
12063 *
12064 * @params[in] transId
12065 * @return void
12066 *
12067 * ****************************************************************/
12068
12069 uint8_t duProcGnbDuCfgUpdAckMsg(uint8_t transId)
12070 {
12071    uint8_t  ieIdx=0, arrIdx=0,ret=ROK;
12072    uint8_t  ueId =0 , ueIdx =0;
12073    uint16_t cellId =0, cellIdx =0, crnti=0;
12074    CmLList *f1apPduNode = NULLP;
12075    ReservedF1apPduInfo *f1apPduInfo =NULLP;
12076    F1AP_PDU_t *f1apMsgPdu = NULLP;
12077    GNBDUConfigurationUpdate_t *gnbDuConfigUpdate = NULLP;
12078    BIT_STRING_t *cellIdentity=NULLP;
12079    struct Served_Cells_To_Delete_ItemIEs *deleteItemIe=NULLP;
12080    Served_Cells_To_Delete_List_t *cellsToDelete=NULLP;
12081    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
12082
12083    DU_LOG("\nINFO   -->  DU APP: GNB-DU config update Ack received ");
12084    f1apPduNode = searchFromReservedF1apPduList(transId);
12085    f1apPduInfo = (ReservedF1apPduInfo *)f1apPduNode->node;
12086    f1apMsgPdu = (F1AP_PDU_t *)f1apPduInfo->f1apMsg;
12087
12088    if(f1apMsgPdu)
12089    {
12090       if(f1apMsgPdu->choice.initiatingMessage)
12091       {
12092          gnbDuConfigUpdate = &f1apMsgPdu->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
12093          for(ieIdx=0; ieIdx < gnbDuConfigUpdate->protocolIEs.list.count; ieIdx++)
12094          {
12095             switch(gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->id)
12096             {
12097                case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
12098                   {
12099                      cellsToDelete = &gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
12100                                      Served_Cells_To_Delete_List;
12101                      if(cellsToDelete->list.array)
12102                      {
12103                         if(cellsToDelete->list.array[arrIdx])
12104                         {
12105                            deleteItemIe = (Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx];
12106                            deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
12107                            if(deleteItem->oldNRCGI.nRCellIdentity.buf)
12108                            {
12109                               cellIdentity = &deleteItem->oldNRCGI.nRCellIdentity;
12110                               bitStringToInt(cellIdentity, &cellId);
12111                            }
12112                         }
12113                      }
12114
12115                      GET_CELL_IDX(cellId, cellIdx);
12116                      if(duCb.actvCellLst[cellIdx] != NULLP)
12117                      {
12118                         if(duCb.actvCellLst[cellIdx]->numActvUes == 0)
12119                         {
12120                            duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
12121                            ret = duSendCellDeletReq(cellId);
12122                            if(ret == RFAILED)
12123                            {
12124                               DU_LOG("ERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to send cell delete\
12125                               request for cellId[%d]", cellId);
12126                            }
12127                         }
12128                         else
12129                         {
12130                            for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
12131                            {
12132                               crnti = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].crnti;
12133                               GET_UE_IDX(crnti,ueId);
12134                               ret = BuildAndSendUeContextReleaseReq(cellId, ueId);
12135                               if(ret == RFAILED)
12136                               {
12137                                  DU_LOG("ERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to build and send UE delete\
12138                                  request for cellId[%d]", cellId);
12139                               }
12140                            }
12141                         }
12142                      }
12143                      else
12144                      {
12145                         DU_LOG("ERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): CellId [%d] not found", cellId);
12146                         ret = RFAILED;
12147                      }
12148                      break;
12149                   }
12150
12151                default:
12152                   break;
12153             }
12154          }
12155       }
12156    }
12157
12158    FreeDUConfigUpdate(f1apMsgPdu);
12159    deleteFromReservedF1apPduList(f1apPduNode);
12160    return ret;
12161 }
12162
12163 /*******************************************************************
12164 *
12165 * @brief Processes GNB DU config update ack
12166 *
12167 * @details
12168 *
12169 *    Function : procF1GNBDUCfgUpdAck
12170 *
12171 *    Functionality: added free part for the memory allocated by aper_decoder
12172 *
12173 * @params[in] F1AP_PDU_t *f1apMsg
12174 * @return void
12175 *
12176 * ****************************************************************/
12177 uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
12178 {
12179    uint8_t ieIdx=0,transId=0;
12180    GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
12181
12182    DU_LOG("\nINFO   -->  F1AP : GNB-DU config update acknowledgment");
12183    gnbDuAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
12184
12185    for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
12186    {
12187       switch(gnbDuAck->protocolIEs.list.array[ieIdx]->id)
12188       {
12189          case ProtocolIE_ID_id_TransactionID:
12190             {
12191                transId = gnbDuAck->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
12192                break;
12193             }
12194          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
12195             {
12196                break;
12197             }
12198          default :
12199             {
12200                DU_LOG("\nERROR  -->  F1AP: procF1GNBDUCfgUpdAck(): Invalid IE Received: %ld", \
12201                      gnbDuAck->protocolIEs.list.array[ieIdx]->id);
12202                break;
12203             }
12204       }
12205    }
12206
12207    duProcGnbDuCfgUpdAckMsg(transId);
12208
12209 #if 0
12210    /* presently we are not supporting F1 Reset from DU to CU , we are only
12211     * supporting F1 Reset from CU to DU */
12212
12213    if(BuildAndSendF1ResetReq() != ROK)
12214    {
12215       return RFAILED;
12216    }
12217 #endif
12218
12219    freeAperDecodeGnbDuAck(gnbDuAck);
12220    return ROK;
12221 }
12222 /******************************************************************
12223 *
12224 * @brief free DL RRC Message Transfer allocated by aper_decoder
12225 *
12226 * @details
12227 *
12228 *    Function : freeAperDecodef1DlRrcMsg
12229 *
12230 *    Functionality: free DL RRC Message Transfer allocated by aper_decoder
12231 *
12232 * @params[in] DLRRCMessageTransfer_t *f1DlRrcMsg
12233 * @return ROK     - success
12234 *         RFAILED - failure
12235 *
12236 * ****************************************************************/
12237
12238 void freeAperDecodef1DlRrcMsg(DLRRCMessageTransfer_t *f1DlRrcMsg)
12239 {
12240    uint8_t ieIdx =0;
12241    RRCContainer_t *rrcContainer = NULLP;
12242
12243    if(f1DlRrcMsg->protocolIEs.list.array)
12244    {
12245       for(ieIdx=0; ieIdx<f1DlRrcMsg->protocolIEs.list.count; ieIdx++)
12246       {
12247          if(f1DlRrcMsg->protocolIEs.list.array[ieIdx])
12248          {
12249             switch(f1DlRrcMsg->protocolIEs.list.array[ieIdx]->id)
12250             {
12251                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12252                   break;
12253                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12254                   break;
12255                case ProtocolIE_ID_id_SRBID:
12256                   break;
12257                case ProtocolIE_ID_id_RRCContainer:
12258                   {
12259                      rrcContainer =&f1DlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
12260                      free(rrcContainer->buf);
12261                   }
12262                case ProtocolIE_ID_id_ExecuteDuplication:
12263                   break;
12264                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
12265                   break;
12266                   break;
12267             }
12268             free(f1DlRrcMsg->protocolIEs.list.array[ieIdx]);
12269          }
12270       }
12271       free(f1DlRrcMsg->protocolIEs.list.array);
12272    }
12273 }
12274 /******************************************************************
12275  *
12276  * @brief Processes DL RRC Message Transfer  sent by CU
12277  *
12278  * @details
12279  *
12280  *    Function : procF1DlRrcMsgTrans
12281  *
12282  *    Functionality: Processes DL RRC Message Transfer sent by CU
12283  *
12284  * @params[in] F1AP_PDU_t ASN decoded F1AP message
12285  * @return ROK     - success
12286  *         RFAILED - failure
12287  *
12288  * ****************************************************************/
12289 uint8_t procF1DlRrcMsgTrans(F1AP_PDU_t *f1apMsg)
12290 {
12291    uint8_t  idx, ret;
12292    DLRRCMessageTransfer_t *f1DlRrcMsg = NULLP;
12293    F1DlRrcMsg dlMsg;
12294    memset(&dlMsg, 0, sizeof(F1DlRrcMsg));
12295
12296    DU_LOG("\nINFO   -->  DU_APP : DL RRC message transfer Recevied");
12297    f1DlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
12298
12299    ret = ROK;
12300
12301    for(idx=0; idx<f1DlRrcMsg->protocolIEs.list.count; idx++)
12302    {
12303       switch(f1DlRrcMsg->protocolIEs.list.array[idx]->id)
12304       {
12305          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12306             {
12307                dlMsg.gnbCuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
12308                break;
12309             }
12310          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12311             {
12312                dlMsg.gnbDuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
12313                break;
12314             }
12315          case ProtocolIE_ID_id_SRBID:
12316             {
12317                dlMsg.srbId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
12318                break;
12319             }
12320          case ProtocolIE_ID_id_ExecuteDuplication:
12321             dlMsg.execDup = true;
12322             break;
12323
12324          case ProtocolIE_ID_id_RRCContainer:
12325             {
12326                if(f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0)
12327                {
12328                   dlMsg.rrcMsgSize = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
12329                   DU_ALLOC_SHRABL_BUF(dlMsg.rrcMsgPdu, dlMsg.rrcMsgSize);
12330                   if(dlMsg.rrcMsgPdu)
12331                   {
12332                      memcpy(dlMsg.rrcMsgPdu, f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
12333                         dlMsg.rrcMsgSize);
12334                   }
12335                   else
12336                   {
12337                      DU_LOG("\nERROR  -->  DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
12338                      return RFAILED;
12339                   }
12340                }
12341                else
12342                {
12343                   DU_LOG("\nERROR  -->  DU_APP : RRC Container Size is invalid:%ld",\
12344                   f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
12345                   return RFAILED;
12346                }
12347                break;
12348             }
12349          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
12350             {
12351                dlMsg.deliveryStatRpt = true;
12352                break;
12353             }
12354          default:
12355             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
12356                   f1DlRrcMsg->protocolIEs.list.array[idx]->id);
12357       }
12358    }
12359
12360    ret = duProcDlRrcMsg(&dlMsg);
12361
12362    freeAperDecodef1DlRrcMsg(f1DlRrcMsg);
12363    return ret;
12364 }
12365 /*******************************************************************
12366  *
12367 * @brief Builds the DRB to be Setup Mod list
12368 *
12369 * @details
12370 *
12371 *    Function :
12372 *
12373 *    Functionality: Constructs the DRB to be Setup Mod list
12374 *
12375 * @params[in] DRBs_SetupMod_List_t *drbSet
12376 *
12377 * @return ROK     - success
12378 *         RFAILED - failure
12379 *
12380 * ****************************************************************/
12381
12382 uint8_t BuildDrbSetupModList(DRBs_SetupMod_List_t *drbSet , DuUeCfg *ueCfg)
12383 {
12384    uint8_t arrIdx =0;
12385    uint8_t drbCnt =0;
12386    struct DRBs_SetupMod_ItemIEs *drbItemIe;
12387
12388    drbCnt = 1;
12389    drbSet->list.count = drbCnt;
12390    drbSet->list.size = drbCnt * sizeof(DRBs_SetupMod_ItemIEs_t *);
12391    DU_ALLOC(drbSet->list.array, drbSet->list.size);
12392    if(drbSet->list.array == NULLP)
12393    {
12394       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
12395       return  RFAILED;
12396    }
12397    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
12398    {
12399       DU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
12400       if(drbSet->list.array[arrIdx] == NULLP)
12401       {
12402               DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
12403               return  RFAILED;
12404       }
12405
12406       drbItemIe = (struct DRBs_SetupMod_ItemIEs *)drbSet->list.array[arrIdx];
12407       drbItemIe->id = ProtocolIE_ID_id_DRBs_SetupMod_Item;
12408       drbItemIe->criticality = Criticality_reject;
12409       drbItemIe->value.present = DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item;
12410       drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
12411       if(fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List,\
12412       &ueCfg->upTnlInfo[arrIdx])!= ROK)
12413       {
12414          DU_LOG("\nERROR  -->  F1AP : Failed to fill DlTnl SetupList in BuildDrbToBeSetupModList");
12415          return RFAILED;
12416       }
12417
12418    }
12419
12420    return ROK;
12421 }
12422 /*******************************************************************
12423 * @brief Free the memory allocated for DRB setup List
12424 *
12425 * @details
12426 *
12427 *    Function : FreeDrbSetupModList
12428 *
12429 *    Functionality:
12430 *       Free the memory allocated for DRB setup list
12431 *
12432 * @params[in] DRBs_Setup_List_t *
12433 * @return void
12434 *
12435 * ****************************************************************/
12436 void FreeDrbSetupModList(DRBs_SetupMod_List_t *drbSetupList)
12437 {
12438    uint8_t arrIdx = 0;
12439    DRBs_SetupMod_ItemIEs_t *drbItemIe = NULLP;
12440
12441    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
12442    {
12443       drbItemIe = ((DRBs_SetupMod_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
12444       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
12445       DU_FREE(drbSetupList->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
12446    }
12447    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
12448 }
12449 /*******************************************************************
12450 * @brief Free the memory allocated for UE Context Mod Response
12451 *
12452 * @details
12453 *
12454 *    Function : FreeUeContextModResp
12455 *
12456 *    Functionality:
12457 *       Free the memory allocated for UE Context Mod Response
12458 *
12459 * @params[in] F1AP_PDU_t *f1apMsg
12460 * @return void
12461 *
12462 * ****************************************************************/
12463
12464 void FreeUeContextModResp(F1AP_PDU_t *f1apMsg)
12465 {
12466    uint8_t ieIdx;
12467    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
12468    if(f1apMsg)
12469    {
12470       if(f1apMsg->choice.successfulOutcome)
12471       {
12472          ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
12473          if(ueContextModifyRes->protocolIEs.list.array)
12474          {
12475             for(ieIdx=0 ; ieIdx<ueContextModifyRes->protocolIEs.list.count; ieIdx++)
12476             {
12477                if(ueContextModifyRes->protocolIEs.list.array[ieIdx])
12478                {
12479                   switch(ueContextModifyRes->protocolIEs.list.array[ieIdx]->id)
12480                   {
12481                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12482                         break;
12483                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12484                         break;
12485                      case ProtocolIE_ID_id_DRBs_SetupMod_List:
12486                         {
12487                             FreeDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
12488                             value.choice.DRBs_SetupMod_List));
12489                             break;
12490                         }
12491                   }
12492                   DU_FREE(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
12493                }
12494
12495             }
12496             DU_FREE(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
12497          }
12498          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12499       }
12500       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12501    }
12502 }
12503
12504 /*****************************************************************i
12505 *
12506 * @brief Creating the ue context modifcation response and sending
12507 *
12508 * @details
12509 *
12510 *    Function : BuildAndSendUeContextModRsp
12511 *
12512 *    Functionality:
12513 *         - Creating the ue context modifcation response
12514 *
12515 * @params[in] uint8_t cellId,uint8_t ueIdx
12516 * @return ROK     - success
12517 *         RFAILED - failure
12518 *
12519 * ****************************************************************/
12520 uint8_t BuildAndSendUeContextModRsp(uint8_t cellId,uint8_t ueIdx)
12521 {
12522    uint8_t   ieIdx = 0;
12523    uint8_t   cellIdx =0;
12524    uint8_t   elementCnt = 0;
12525    uint8_t   ret = RFAILED;
12526    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
12527    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
12528    F1AP_PDU_t *f1apMsg = NULLP;
12529    asn_enc_rval_t         encRetVal;
12530    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
12531    DuUeCb                   *ueCb = NULLP;
12532
12533    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification response\n");
12534
12535    while(1)
12536    {
12537       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12538       if(f1apMsg == NULLP)
12539       {
12540          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
12541          break;
12542       }
12543
12544       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
12545
12546       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12547       if(f1apMsg->choice.successfulOutcome == NULLP)
12548       {
12549          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
12550          break;
12551       }
12552       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextModification;
12553       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
12554       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_UEContextModificationResponse;
12555
12556       ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
12557
12558       elementCnt = 3;
12559       ueContextModifyRes->protocolIEs.list.count = elementCnt;
12560       ueContextModifyRes->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationResponse_t*);
12561
12562       /* Initialize the UE context modification members */
12563       DU_ALLOC(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
12564       if(ueContextModifyRes->protocolIEs.list.array == NULLP)
12565       {
12566          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
12567          break;
12568       }
12569
12570       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
12571       {
12572          DU_ALLOC(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
12573          if(ueContextModifyRes->protocolIEs.list.array[ieIdx] == NULLP)
12574          {
12575             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
12576             break;
12577          }
12578       }
12579
12580       /* Fetching Ue Cb Info*/
12581       GET_CELL_IDX(cellId, cellIdx);
12582       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
12583       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
12584       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
12585
12586       ieIdx=0;
12587       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
12588       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12589       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
12590       UEContextModificationResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
12591       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
12592
12593       ieIdx++;
12594       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
12595       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12596       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present=\
12597       UEContextModificationResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
12598       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
12599
12600       ieIdx++;
12601       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_SetupMod_List;
12602       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12603       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
12604       UEContextModificationResponseIEs__value_PR_DRBs_SetupMod_List;
12605       if(ueCb->f1UeDb)
12606       {
12607          ret = BuildDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
12608                   value.choice.DRBs_SetupMod_List) , &ueCb->f1UeDb->duUeCfg);
12609          if(ret != ROK)
12610          {
12611             DU_LOG( "\nERROR  -->  F1AP : Failed to build drb setupmod List ");
12612             break;
12613          }
12614          freeF1UeDb(ueCb->f1UeDb);
12615          ueCb->f1UeDb = NULLP;
12616       }
12617       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12618
12619       /* Encode the F1SetupRequest type as APER */
12620       memset(encBuf, 0, ENC_BUF_MAX_LEN);
12621       encBufSize = 0;
12622       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,encBuf);
12623
12624       /* Encode results */
12625       if(encRetVal.encoded == ENCODE_FAIL)
12626       {
12627          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
12628                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12629          ret = RFAILED;
12630          break;
12631       }
12632       else
12633       {
12634          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Modification Response\n");
12635          for(int i=0; i< encBufSize; i++)
12636          {
12637             printf("%x",encBuf[i]);
12638          }
12639       }
12640
12641       /* Sending  msg  */
12642       if(sendF1APMsg() != ROK)
12643       {
12644          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Res Failed");
12645          ret = RFAILED;
12646          break;
12647       }
12648       break;
12649    }
12650    FreeUeContextModResp(f1apMsg);
12651    return ret;
12652 }
12653 /*******************************************************************
12654  *
12655  * @brief Deallocating the memory allocated by the aper decoder
12656  *          for QOSInfo
12657  *
12658  * @details
12659  *
12660  *    Function : freeAperDecodeQosInfo
12661  *
12662  *    Functionality:  Deallocating the memory allocated for QOSInfo
12663  *
12664  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
12665  *
12666  * @return void
12667  *
12668  * ****************************************************************/
12669
12670 void freeAperDecodeQosInfo(QoSFlowLevelQoSParameters_t *drbQos)
12671 {
12672    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
12673    {
12674       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
12675       {
12676          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
12677          {
12678             free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
12679          }
12680          free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
12681       }
12682       free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI);
12683    }
12684 }
12685 /*******************************************************************
12686  *
12687  * @brief Deallocating the memory allocated by the aper decoder
12688  *          for UlTnlInfoforDrb
12689  *
12690  * @details
12691  *
12692  *    Function : freeAperDecodeUlTnlInfoforDrbSetupMod
12693  *
12694  *    Functionality:  Deallocating memory allocated for UlTnlInfoforDrb
12695  *
12696  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
12697  *
12698  * @return void
12699  *
12700  * ****************************************************************/
12701 void freeAperDecodeUlTnlInfoforDrbSetupMod(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
12702 {
12703    uint8_t arrIdx =0;
12704
12705    if(ulInfo->list.array)
12706    {
12707       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
12708       {
12709          if(ulInfo->list.array[arrIdx])
12710          {
12711             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
12712             {
12713                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
12714                {
12715                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
12716                   {
12717                      free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12718                            gTP_TEID.buf);
12719                   }
12720                   free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12721                         transportLayerAddress.buf);
12722                }
12723                free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel);
12724             }
12725             free(ulInfo->list.array[arrIdx]);
12726          }
12727       }
12728       free(ulInfo->list.array);
12729    }
12730 }
12731 /*******************************************************************
12732  *
12733  * @brief Deallocating the memory allocated by the aper decoder
12734  *          for DrbSetupModItem
12735  *
12736  * @details
12737  *
12738  *    Function : freeAperDecodeDrbSetupModItem
12739  *
12740  *    Functionality:  Deallocating memory allocated for DrbSetupModItem
12741  *
12742  * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
12743  *
12744  * @return void
12745  *
12746  * ****************************************************************/
12747
12748 void freeAperDecodeDrbSetupModItem(DRBs_ToBeSetupMod_Item_t *drbItem)
12749 {
12750    uint8_t arrIdx =0;
12751    SNSSAI_t *snssai =NULLP;
12752    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
12753
12754    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
12755    switch(drbItem->qoSInformation.present)
12756    {
12757       case QoSInformation_PR_NOTHING:
12758          break;
12759       case QoSInformation_PR_eUTRANQoS:
12760          {
12761             if(drbItem->qoSInformation.choice.eUTRANQoS)
12762             {
12763                free(drbItem->qoSInformation.choice.eUTRANQoS);
12764             }
12765             break;
12766          }
12767       case QoSInformation_PR_choice_extension:
12768          {
12769             if(drbItem->qoSInformation.choice.choice_extension)
12770             {
12771                freeAperDecodeQosInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.\
12772                      DRB_Information.dRB_QoS);
12773                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
12774                if(snssai->sST.buf)
12775                {
12776                   free(snssai->sST.buf);
12777                }
12778                if(snssai->sD)
12779                {
12780                   if(snssai->sD->buf)
12781                   {
12782                      free(snssai->sD->buf);
12783                   }
12784                   free(snssai->sD);
12785                }
12786
12787                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.\
12788                          DRB_Information.flows_Mapped_To_DRB_List;
12789                if(flowMap->list.array)
12790                {
12791                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
12792                   {
12793                      if(flowMap->list.array[arrIdx] )
12794                      {
12795                         freeAperDecodeQosInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
12796                         free(flowMap->list.array[arrIdx]);
12797                      }
12798                   }
12799                   free(flowMap->list.array);
12800                }
12801
12802                free(drbItem->qoSInformation.choice.choice_extension);
12803             }
12804             break;
12805          }
12806
12807    }
12808    freeAperDecodeUlTnlInfoforDrbSetupMod(&drbItem->uLUPTNLInformation_ToBeSetup_List);
12809    if(drbItem->uLConfiguration)
12810    {
12811       free(drbItem->uLConfiguration);
12812    }
12813 }
12814
12815 /*******************************************************************
12816  *
12817  * @brief Deallocating the memory allocated by the aper decoder
12818  *          for DrbToBeSetupModList
12819  *
12820  * @details
12821  *
12822  *    Function : freeAperDecodeDrbToBeSetupModList
12823  *
12824  *    Functionality:  Deallocating memory allocated for DrbToBeSetupModList
12825  *
12826  * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
12827  *
12828  * @return void
12829  *
12830  * ****************************************************************/
12831
12832 void freeAperDecodeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
12833 {
12834    uint8_t arrIdx =0;
12835    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
12836
12837    if(drbSet->list.array)
12838    {
12839       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
12840       {
12841          if(drbSet->list.array[arrIdx] != NULLP)
12842          {
12843             if(arrIdx == 0)
12844             {
12845                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
12846                freeAperDecodeDrbSetupModItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
12847             }
12848             free(drbSet->list.array[arrIdx]);
12849          }
12850       }
12851       free(drbSet->list.array);
12852    }
12853
12854 }
12855 /*******************************************************************
12856  *
12857  * @brief Deallocating the memory allocated by the aper decoder
12858  *          for UeContextModificationReqMsg
12859  *
12860  * @details
12861  *
12862  *    Function : freeAperDecodeUeContextModificationReqMsg
12863  *
12864  *    Functionality:  Deallocating memory allocated for
12865  *                  UeContextModificationReqMsg
12866  *
12867  * @params[in] UEContextModificationRequest_t *UeContextModifyReq
12868  *
12869  * @return void
12870  *
12871  * ****************************************************************/
12872 void freeAperDecodeUeContextModificationReqMsg(UEContextModificationRequest_t *UeContextModifyReq )
12873 {
12874    uint8_t arrIdx, ieId;
12875
12876    if(UeContextModifyReq->protocolIEs.list.array)
12877    {
12878       for( arrIdx = 0 ; arrIdx<UeContextModifyReq->protocolIEs.list.count ; arrIdx++)
12879       {
12880          if(UeContextModifyReq->protocolIEs.list.array[arrIdx])
12881          {
12882             ieId = UeContextModifyReq->protocolIEs.list.array[arrIdx]->id;
12883             switch(ieId)
12884             {
12885                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12886                   break;
12887                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12888                   break;
12889                case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
12890                   {
12891                      freeAperDecodeDrbToBeSetupModList(&UeContextModifyReq->protocolIEs.list.array[arrIdx]->\
12892                            value.choice.DRBs_ToBeSetupMod_List);
12893                      break;
12894                   }
12895             }
12896             free(UeContextModifyReq->protocolIEs.list.array[arrIdx]);
12897          }
12898       }
12899       free(UeContextModifyReq->protocolIEs.list.array);
12900    }
12901 }
12902 /*******************************************************************
12903  *
12904  * @brief processing the F1 UeContextModificationReq
12905  *
12906  * @details
12907  *
12908  *    Function : procF1UeContextModificationReq
12909  *
12910  *    Functionality:  processing the F1 UeContextModificationReq
12911  *
12912  * @params[in] F1AP_PDU_t *f1apMsg
12913  *
12914  * @return
12915  * ****************************************************************/
12916 uint8_t procF1UeContextModificationReq(F1AP_PDU_t *f1apMsg)
12917 {
12918    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
12919    uint8_t  ret = ROK, ieIdx = 0, cellIdx=0, ueIdx=0;
12920    DuUeCb   *duUeCb = NULLP;
12921    DRBs_ToBeSetupMod_List_t *drbSetupModCfg;
12922    DRBs_ToBeModified_List_t *drbModifiedCfg;
12923    uint32_t gnbCuUeF1apId, gnbDuUeF1apId;
12924
12925    ueContextModifyReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
12926    for(ieIdx=0; (ieIdx < ueContextModifyReq->protocolIEs.list.count && ret == ROK); ieIdx++)
12927    {
12928       switch(ueContextModifyReq->protocolIEs.list.array[ieIdx]->id)
12929       {
12930          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12931             {
12932                gnbCuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
12933                break;
12934             }
12935          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12936             {
12937                gnbDuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
12938                break;
12939             }
12940          case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
12941          case ProtocolIE_ID_id_DRBs_ToBeModified_List:
12942             {
12943                for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
12944                {
12945                   for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
12946                   {
12947                      if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
12948                            (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
12949                      {
12950
12951                         duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
12952                         if(duUeCb->f1UeDb == NULLP)
12953                         {
12954                            DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
12955                         }
12956                         if(duUeCb->f1UeDb)
12957                         {
12958                            duUeCb->f1UeDb->actionType = UE_CTXT_MOD;
12959                            if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present ==\
12960                                  UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List)
12961                            {
12962                               drbSetupModCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
12963                               choice.DRBs_ToBeSetupMod_List;
12964
12965                               if(extractDrbListToSetupMod(NULL, drbSetupModCfg, NULL, drbSetupModCfg->list.count,\
12966                                     &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap))
12967                               {
12968                                  DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbSetupModList");
12969                                  ret = RFAILED;
12970                               }
12971                            }
12972
12973                            if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present == \
12974                                   UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List)
12975
12976                            {
12977                               drbModifiedCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
12978                               choice.DRBs_ToBeModified_List;
12979                               if(extractDrbListToSetupMod(NULL, NULL, drbModifiedCfg, drbSetupModCfg->list.count,\
12980                                  &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap))
12981                               {
12982                                  DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbModifiedList");
12983                                  ret = RFAILED;
12984                               }
12985                            }
12986                         }
12987                         break;
12988                      }
12989                   }
12990                   if(ueIdx >= duCb.actvCellLst[cellIdx]->numActvUes)
12991                   {
12992                      DU_LOG("\nERROR  -->  DU APP : wrong values of gnbCuUeF1apId and gnbDuUeF1apId ");
12993                      ret = RFAILED;
12994                   }
12995                }
12996                break;
12997             }
12998       }
12999    }
13000    if(ret != RFAILED)
13001    {
13002       ret = duProcUeContextModReq(duUeCb);
13003    }
13004    freeAperDecodeUeContextModificationReqMsg(ueContextModifyReq);
13005    return ret;
13006 }
13007 /*****************************************************************i
13008 *
13009 * @brief Free memory allocated for UE Context Release Request
13010 *
13011 * @details
13012 *
13013 *    Function : FreeUeContextReleaseReq
13014 *
13015 *    Functionality:
13016 *         - Free memory allocated for UE Context Release Request
13017 *
13018 * @params[in] F1AP_PDU_t *f1apMsg
13019 * @return void
13020 *
13021 * *************************************************************/
13022 void FreeUeContextReleaseReq(F1AP_PDU_t *f1apMsg)
13023 {
13024    uint8_t ieIdx;
13025    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
13026
13027    if(f1apMsg)
13028    {
13029       if(f1apMsg->choice.initiatingMessage)
13030       {
13031          ueReleaseReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
13032          if(ueReleaseReq->protocolIEs.list.array)
13033          {
13034             for(ieIdx=0 ; ieIdx<ueReleaseReq->protocolIEs.list.count; ieIdx++)
13035             {
13036                DU_FREE(ueReleaseReq->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseRequest_t));
13037             }
13038             DU_FREE(ueReleaseReq->protocolIEs.list.array, ueReleaseReq->protocolIEs.list.size);
13039          }
13040          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
13041       }
13042       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
13043    }
13044
13045 }
13046 /*****************************************************************i
13047 *
13048 * @brief Build and Send UE Context Release Request
13049 *
13050 * @details
13051 *
13052 *    Function : BuildAndSendUeContextReleaseReq
13053 *
13054 *    Functionality:
13055 *         - Build and Send UE Context Release Request
13056 *
13057 * @params[in]
13058 * @return ROK     - success
13059 *         RFAILED - failure
13060 *
13061 * *************************************************************/
13062 uint8_t BuildAndSendUeContextReleaseReq(uint16_t cellId, uint8_t ueIdx)
13063 {
13064    bool memAllocFail = false;
13065    uint8_t ieIdx =0;
13066    uint8_t ret = RFAILED;
13067    uint16_t cellIdx =0;
13068    uint16_t crnti = 0;
13069    uint8_t  elementCnt = 0;
13070    uint32_t  gnbCuUeF1apId =0;   /* gNB-CU UE F1AP Id */
13071    uint32_t  gnbDuUeF1apId =0;   /* gNB-DU UE F1AP Id */
13072    asn_enc_rval_t encRetVal;
13073    F1AP_PDU_t *f1apMsg = NULLP;
13074    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
13075
13076    DU_LOG("\nINFO  --> Building the UE Context Release Request");
13077    do
13078    {
13079       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
13080       if(f1apMsg == NULLP)
13081       {
13082          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for f1apMsg");
13083          break;
13084       }
13085
13086       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
13087       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
13088       if(f1apMsg->choice.initiatingMessage == NULLP)
13089       {
13090          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for\
13091          initiatingMessage");
13092          break;
13093       }
13094       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextReleaseRequest;
13095       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
13096       f1apMsg->choice.initiatingMessage->value.present = \
13097       InitiatingMessage__value_PR_UEContextReleaseRequest;
13098
13099       ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
13100
13101       elementCnt = 2;
13102
13103       ueReleaseReq->protocolIEs.list.count = elementCnt;
13104       ueReleaseReq->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseRequest_t *);
13105
13106       /* Initialize the F1Setup members */
13107       DU_ALLOC(ueReleaseReq->protocolIEs.list.array,ueReleaseReq->protocolIEs.list.size);
13108       if(ueReleaseReq->protocolIEs.list.array == NULLP)
13109       {
13110          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE array");
13111          break;
13112       }
13113       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
13114       {
13115          DU_ALLOC(ueReleaseReq->protocolIEs.list.array[ieIdx],\
13116                sizeof(UEContextReleaseRequest_t));
13117          if(ueReleaseReq->protocolIEs.list.array[ieIdx] == NULLP)
13118          {
13119             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE elements");
13120             memAllocFail = true;
13121             break;
13122          }
13123       }
13124       if(memAllocFail == true)
13125          break;
13126
13127       /* Fetching Ue Cb Info*/
13128       GET_CELL_IDX(cellId, cellIdx);
13129       if(duCb.actvCellLst[cellIdx] == NULLP)
13130       {
13131          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): CellId[%d] does not exist", cellId);
13132          break;
13133       }
13134       else
13135       {
13136          GET_CRNTI(crnti, ueIdx);
13137          if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].crnti != crnti)
13138          {
13139             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): crnti[%d] does not exist", crnti);
13140             break;
13141          }
13142          gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
13143          gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
13144       }
13145
13146       ieIdx=0;
13147       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
13148       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13149       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present = \
13150       UEContextReleaseRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
13151       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
13152
13153       ieIdx++;
13154       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
13155       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13156       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present =\
13157       UEContextReleaseRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
13158       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
13159
13160       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13161
13162       /* Encode the F1SetupRequest type as APER */
13163       memset(encBuf, 0, ENC_BUF_MAX_LEN);
13164       encBufSize = 0;
13165       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
13166       /* Encode results */
13167       if(encRetVal.encoded == ENCODE_FAIL)
13168       {
13169          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseRequest structure (at %s)\n",\
13170                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13171          break;
13172       }
13173       else
13174       {
13175          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseRequest\n");
13176          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
13177          {
13178             printf("%x",encBuf[ieIdx]);
13179          }
13180       }
13181
13182       /* Sending msg */
13183       if(sendF1APMsg() != ROK)
13184       {
13185          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Request failed");
13186          break;
13187       }
13188       ret = ROK;
13189       break;
13190    }while(true);
13191
13192    FreeUeContextReleaseReq(f1apMsg);
13193    return ret;
13194 }
13195 /*****************************************************************i
13196  *
13197  * @brief Free memory allocated for UE Context Release Complete
13198  *
13199  * @details
13200  *
13201  *    Function : FreeUeContextReleaseComplete
13202  *
13203  *    Functionality:
13204  *         - Free memory allocated for UE Context Release Complete
13205  *
13206  * @params[in] F1AP_PDU_t *f1apMsg
13207  * @return void
13208  *
13209  * *************************************************************/
13210 void FreeUeContextReleaseComplete(F1AP_PDU_t *f1apMsg)
13211 {
13212    uint8_t ieIdx;
13213    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
13214
13215    if(f1apMsg)
13216    {
13217       if(f1apMsg->choice.successfulOutcome)
13218       {
13219          ueReleaseComplete =&f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
13220          if(ueReleaseComplete->protocolIEs.list.array)
13221          {
13222             for(ieIdx=0 ; ieIdx<ueReleaseComplete->protocolIEs.list.count; ieIdx++)
13223             {
13224                DU_FREE(ueReleaseComplete->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseComplete_t));
13225             }
13226             DU_FREE(ueReleaseComplete->protocolIEs.list.array, ueReleaseComplete->protocolIEs.list.size);
13227          }
13228          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
13229       }
13230       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
13231    }
13232
13233 }
13234 /*****************************************************************i
13235  *
13236  * @brief Build and Send UE Context Release Complete
13237  *
13238  * @details
13239  *
13240  *    Function : BuildAndSendUeContextReleaseComplete
13241  *
13242  *    Functionality:
13243  *         - Build and Send UE Context Release Complete
13244  *
13245  * @params[in]  cellId,  gnbCuUeF1apId, gnbDuUeF1apId
13246  * @return ROK     - success
13247  *         RFAILED - failure
13248  *
13249  * *************************************************************/
13250 uint8_t BuildAndSendUeContextReleaseComplete(uint16_t cellId, uint32_t gnbCuUeF1apId, uint32_t gnbDuUeF1apId)
13251 {
13252    bool memAllocFail = false;
13253    uint8_t ieIdx =0, ret = RFAILED, elementCnt = 0;
13254    asn_enc_rval_t encRetVal;
13255    F1AP_PDU_t *f1apMsg = NULLP;
13256    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
13257
13258    DU_LOG("\nINFO  --> Building the UE Context Release Complete");
13259    do
13260    {
13261       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
13262       if(f1apMsg == NULLP)
13263       {
13264          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for f1apMsg");
13265          break;
13266       }
13267
13268       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
13269       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
13270       if(f1apMsg->choice.successfulOutcome == NULLP)
13271       {
13272          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for\
13273                successfulOutcome");
13274          break;
13275       }
13276       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextRelease;
13277       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
13278       f1apMsg->choice.successfulOutcome->value.present = \
13279       SuccessfulOutcome__value_PR_UEContextReleaseComplete;
13280
13281       ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
13282
13283       elementCnt = 2;
13284       ueReleaseComplete->protocolIEs.list.count = elementCnt;
13285       ueReleaseComplete->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseComplete_t *);
13286
13287       /* Initialize the UE Release Complete members */
13288       DU_ALLOC(ueReleaseComplete->protocolIEs.list.array,ueReleaseComplete->protocolIEs.list.size);
13289       if(ueReleaseComplete->protocolIEs.list.array == NULLP)
13290       {
13291          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE array");
13292          break;
13293       }
13294       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
13295       {
13296          DU_ALLOC(ueReleaseComplete->protocolIEs.list.array[ieIdx],\
13297                sizeof(UEContextReleaseComplete_t));
13298          if(ueReleaseComplete->protocolIEs.list.array[ieIdx] == NULLP)
13299          {
13300             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE\
13301             elements");
13302             memAllocFail = true;
13303             break;
13304          }
13305       }
13306       if(memAllocFail == true)
13307          break;
13308
13309
13310       ieIdx=0;
13311       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
13312       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13313       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present = \
13314       UEContextReleaseCompleteIEs__value_PR_GNB_CU_UE_F1AP_ID;
13315       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
13316
13317       ieIdx++;
13318       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
13319       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13320       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present =\
13321       UEContextReleaseCompleteIEs__value_PR_GNB_DU_UE_F1AP_ID;
13322       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
13323
13324       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13325
13326       /* Encode the F1SetupComplete type as APER */
13327       memset(encBuf, 0, ENC_BUF_MAX_LEN);
13328       encBufSize = 0;
13329       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
13330       /* Encode results */
13331       if(encRetVal.encoded == ENCODE_FAIL)
13332       {
13333          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseComplete structure (at %s)\n",\
13334                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13335          break;
13336       }
13337       else
13338       {
13339          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseComplete\n");
13340          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
13341          {
13342             printf("%x",encBuf[ieIdx]);
13343          }
13344       }
13345
13346       /* Sending msg */
13347       if(sendF1APMsg() != ROK)
13348       {
13349          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Complete failed");
13350          break;
13351       }
13352       ret = ROK;
13353       break;
13354    }while(true);
13355
13356    if(ret == ROK)
13357    {
13358       duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
13359       ret = duSendCellDeletReq(cellId);
13360       if(ret != ROK)
13361       {
13362          DU_LOG("\nERROR  -->  F1AP: BuildAndSendUeContextReleaseComplete(): Failed to process cell\
13363                Delete req for CellId");
13364       }
13365    }
13366    FreeUeContextReleaseComplete(f1apMsg);
13367    return ret;
13368
13369 }
13370
13371 /*******************************************************************
13372 *
13373 * @brief added free part for the memory allocated by aper_decoder
13374 *
13375 * @details
13376 *
13377 *    Function : freeAperDecodeUeContextReleaseCommand
13378 *
13379 *    Functionality: added free part for the memory allocated by aper_decoder
13380 *
13381 * @params[in] F1AP_PDU_t *f1apMsg
13382 * @return void
13383 *
13384 * ****************************************************************/
13385 void freeAperDecodeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
13386 {
13387    uint8_t ieIdx=0;
13388    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
13389
13390    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
13391
13392    if(ueContextReleaseCommand->protocolIEs.list.array)
13393    {
13394       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
13395       {
13396          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
13397          {
13398             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
13399             {
13400                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13401                   break;
13402                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13403                   break;
13404                case ProtocolIE_ID_id_Cause:
13405                   break;
13406                case ProtocolIE_ID_id_RRCContainer:
13407                {
13408                   if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
13409                   {
13410                      free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
13411                   }
13412                   break;
13413                }
13414                default :
13415                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
13416                        ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
13417                   break;
13418             }
13419          }
13420          free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]);
13421       }
13422       free(ueContextReleaseCommand->protocolIEs.list.array);
13423    }
13424 }
13425 /*******************************************************************
13426 *
13427 * @brief processing of UE Context Release Command
13428 *
13429 * @details
13430 *
13431 *    Function : procF1UeContextReleaseCommand
13432 *
13433 *    Functionality: processing of UE Context Release Command
13434 *
13435 * @params[in] F1AP_PDU_t *f1apMsg
13436 * @return void
13437 *
13438 * ****************************************************************/
13439 uint8_t procF1UeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
13440 {
13441    uint8_t  ieIdx=0, ret=ROK, ueIdx=0;
13442    uint16_t cellIdx =0;
13443    bool ueIdxFound;
13444    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0;
13445    DuUeCb   *duUeCb = NULLP;
13446    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
13447
13448    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
13449
13450    if(ueContextReleaseCommand->protocolIEs.list.array)
13451    {
13452       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
13453       {
13454          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
13455          {
13456             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
13457             {
13458                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13459                   {
13460                      gnbCuUeF1apId= ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13461                                     value.choice.GNB_CU_UE_F1AP_ID;
13462                      break;
13463                   }
13464
13465                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13466                   {
13467                      gnbDuUeF1apId = ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13468                                      value.choice.GNB_DU_UE_F1AP_ID;
13469                      break;
13470                   }
13471
13472                case ProtocolIE_ID_id_Cause:
13473                   {
13474                      break;
13475                   }
13476
13477                case ProtocolIE_ID_id_RRCContainer:
13478                   {
13479                      for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
13480                      {
13481                         for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
13482                         {
13483                            if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
13484                                  (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
13485                            {
13486                               duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
13487                               DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
13488                               if(duUeCb->f1UeDb)
13489                               {
13490                                  memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
13491                                  duUeCb->f1UeDb->actionType = UE_CTXT_RELEASE;
13492                                  duUeCb->f1UeDb->cellIdx = cellIdx;
13493                                  /* Filling Dl RRC Msg Info */
13494                                  DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
13495                                  if(!duUeCb->f1UeDb->dlRrcMsg)
13496                                  {
13497                                     DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
13498                                     Memory allocation failed ");
13499                                     ret = RFAILED;
13500                                  }
13501                                  else
13502                                  {
13503                                     duUeCb->f1UeDb->dlRrcMsgPres = true;
13504                                     memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
13505                                     ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
13506                                           &ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13507                                           value.choice.RRCContainer);
13508                                  }
13509
13510                               }
13511                               else
13512                               {
13513                                  DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
13514                                  Memory allocation failed ");
13515                                  ret = RFAILED;
13516
13517                               }
13518
13519                               ueIdxFound = true;
13520                               break;
13521                            }
13522                         }
13523                         if(ueIdxFound == true)
13524                         {
13525                            break;
13526                         }
13527                      }
13528                      if(!ueIdxFound)
13529                      {
13530                         DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
13531                         ret = RFAILED;
13532                      }
13533
13534
13535                      break;
13536                   }
13537                default :
13538                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
13539                         ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
13540                   break;
13541             }
13542          }
13543       }
13544    }
13545    if(ret != RFAILED)
13546    {
13547       duProcUeContextReleaseCommand(duUeCb);
13548    }
13549    freeAperDecodeUeContextReleaseCommand(f1apMsg);
13550    return ret;
13551 }
13552 /**************************************************************
13553  *
13554  * @brief Handles received F1AP message and sends back response
13555  *
13556  * @details
13557  *
13558  *    Function : F1APMsgHdlr
13559  *
13560  *    Functionality:
13561  *         - Decodes received F1AP control message
13562  *         - Prepares response message, encodes and sends to SCTP
13563  *
13564  * @params[in]
13565  * @return ROK     - success
13566  *         RFAILED - failure
13567  *
13568  * ****************************************************************/
13569 void F1APMsgHdlr(Buffer *mBuf)
13570 {
13571    int i =0;
13572    char *recvBuf =NULLP;
13573    MsgLen copyCnt =0;
13574    MsgLen recvBufLen =0;
13575    F1AP_PDU_t *f1apMsg =NULLP;
13576    asn_dec_rval_t rval; /* Decoder return value */
13577    F1AP_PDU_t f1apasnmsg ;
13578    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
13579    ODU_PRINT_MSG(mBuf, 0,0);
13580
13581    /* Copy mBuf into char array to decode it */
13582    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
13583    DU_ALLOC(recvBuf, (Size)recvBufLen);
13584
13585    if(recvBuf == NULLP)
13586    {
13587       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
13588       return;
13589    }
13590    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
13591    {
13592       DU_LOG("\nERROR   -->  F1AP : Failed while copying %d", copyCnt);
13593       return;
13594    }
13595
13596    printf("\nDEBUG   -->  F1AP : Received flat buffer to be decoded : ");
13597    for(i=0; i< recvBufLen; i++)
13598    {
13599       printf("%x",recvBuf[i]);
13600    }
13601
13602    /* Decoding flat buffer into F1AP messsage */
13603    f1apMsg = &f1apasnmsg;
13604    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
13605
13606    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
13607    DU_FREE(recvBuf, (Size)recvBufLen);
13608
13609    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
13610    {
13611       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
13612       return;
13613    }
13614    printf("\n");
13615    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13616
13617    switch(f1apMsg->present)
13618    {
13619       case F1AP_PDU_PR_successfulOutcome:
13620          {
13621             switch(f1apMsg->choice.successfulOutcome->value.present)
13622             {
13623                case SuccessfulOutcome__value_PR_ResetAcknowledge:
13624                   {
13625                      DU_LOG("\nINFO   -->  F1AP : F1ResetAcknowledge is received successfully ");
13626                      break;
13627                   }
13628                case SuccessfulOutcome__value_PR_F1SetupResponse:
13629                   {
13630 #ifndef ODU_TEST_STUB
13631                      procF1SetupRsp(f1apMsg);
13632 #endif
13633                      break;
13634                   }
13635
13636                case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
13637                   {
13638                      procF1GNBDUCfgUpdAck(f1apMsg);
13639                      break;
13640                   }
13641
13642                default:
13643                   {
13644                      DU_LOG("\nERROR  -->  F1AP : Invalid type of SuccessfulOutcome__value_PR_ResetAcknowledge [%d]",\
13645                            f1apMsg->choice.successfulOutcome->value.present);
13646                      return;
13647                   }
13648             }/* End of switch(successfulOutcome) */
13649             free(f1apMsg->choice.successfulOutcome);
13650             break;
13651          }
13652       case F1AP_PDU_PR_initiatingMessage:
13653          {
13654             switch(f1apMsg->choice.initiatingMessage->value.present)
13655             {
13656                case InitiatingMessage__value_PR_Reset:
13657                   {
13658                      procF1ResetReq(f1apMsg);
13659                      break;
13660                   }
13661                case InitiatingMessage__value_PR_DLRRCMessageTransfer:
13662                   {
13663                      procF1DlRrcMsgTrans(f1apMsg);
13664                      break;
13665                   }
13666                case InitiatingMessage__value_PR_UEContextSetupRequest:
13667                   {
13668                      procF1UeContextSetupReq(f1apMsg);
13669                      break;
13670                   }
13671                case InitiatingMessage__value_PR_UEContextModificationRequest:
13672                   {
13673                      procF1UeContextModificationReq(f1apMsg);
13674                      break;
13675                   }
13676                case InitiatingMessage__value_PR_UEContextReleaseCommand:
13677                   {
13678                       procF1UeContextReleaseCommand(f1apMsg);
13679                       break;
13680                   }
13681                default:
13682                   {
13683                      DU_LOG("\nERROR  -->  F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
13684                            f1apMsg->choice.initiatingMessage->value.present);
13685                      return;
13686                   }
13687             }/* End of switch(initiatingMessage) */
13688             free(f1apMsg->choice.initiatingMessage);
13689             break;
13690          }
13691
13692       default:
13693          {
13694             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
13695             return;
13696          }
13697          free(f1apMsg);
13698
13699    }/* End of switch(f1apMsg->present) */
13700
13701 } /* End of F1APMsgHdlr */
13702
13703 /**********************************************************************
13704   End of file
13705  **********************************************************************/