src/du_app/du_f1ap_msg_hdl.c

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   4 #                                                                              #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
   6 #   you may not use this file except in compliance with the License.           #
   7 #   You may obtain a copy of the License at                                    #
   8 #                                                                              #
   9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10 #                                                                              #
  11 #   Unless required by applicable law or agreed to in writing, software        #
  12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
  14 #   See the License for the specific language governing permissions and        #
  15 #   limitations under the License.                                             #
  16 ################################################################################
  17 *******************************************************************************/
  18
  19 /* This file contains F1AP message handler functions */
  20 #include "common_def.h"
  21 #include "lrg.h"
  22 #include "legtp.h"
  23 #include "lkw.x"
  24 #include "lrg.x"
  25 #include "F1AP-PDU.h"
  26 #include "du_app_mac_inf.h"
  27 #include "du_cfg.h"
  28 #include "du_app_rlc_inf.h"
  29 #include "du_mgr_main.h"
  30 #include "du_utils.h"
  31 #include "RAT-Type.h"
  32 #include "FeatureSetUplinkPerCC.h"
  33 #include "FeatureSetDownlinkPerCC.h"
  34 #include "FeatureSets.h"
  35 #include "UE-NR-Capability.h"
  36 #include "UE-CapabilityRAT-Container.h"
  37 #include "UE-CapabilityRAT-ContainerListRRC.h"
  38 #include "GNB-DU-System-Information.h"
  39 #include "CellGroupConfigRrc.h"
  40 #include "MAC-CellGroupConfig.h"
  41 #include "SchedulingRequestConfig.h"
  42 #include "SchedulingRequestToAddMod.h"
  43 #include "BSR-Config.h"
  44 #include "TAG-Config.h"
  45 #include "TAG.h"
  46 #include "PHR-Config.h"
  47 #include "RLC-Config.h"
  48 #include "UL-AM-RLC.h"
  49 #include "DL-AM-RLC.h"
  50 #include "LogicalChannelConfig.h"
  51 #include "RLC-BearerConfig.h"
  52 #include "PhysicalCellGroupConfig.h"
  53 #include "SpCellConfig.h"
  54 #include "TDD-UL-DL-ConfigDedicated.h"
  55 #include "ServingCellConfig.h"
  56 #include "ControlResourceSet.h"
  57 #include "SearchSpace.h"
  58 #include "PDCCH-Config.h"
  59 #include "PDSCH-TimeDomainResourceAllocation.h"
  60 #include "PDSCH-TimeDomainResourceAllocationList.h"
  61 #include "PDSCH-CodeBlockGroupTransmission.h"
  62 #include "PDSCH-ServingCellConfig.h"
  63 #include "DMRS-DownlinkConfig.h"
  64 #include "PDSCH-Config.h"
  65 #include "BWP-DownlinkDedicated.h"
  66 #include "PUSCH-TimeDomainResourceAllocation.h"
  67 #include "PUSCH-TimeDomainResourceAllocationList.h"
  68 #include "DMRS-UplinkConfig.h"
  69 #include "PUSCH-Config.h"
  70 #include "SRS-ResourceId.h"
  71 #include "SRS-Resource.h"
  72 #include "SRS-ResourceSet.h"
  73 #include "SRS-Config.h"
  74 #include "BWP-UplinkDedicated.h"
  75 #include "PUSCH-ServingCellConfig.h"
  76 #include "UplinkConfig.h"
  77 #include "DUtoCURRCContainer.h"
  78 #include "GBR-QoSFlowInformation.h"
  79 #include "QoSFlowLevelQoSParameters.h"
  80 #include "PUCCH-Config.h"
  81 #include "PUCCH-ResourceSet.h"
  82 #include "PUCCH-Resource.h"
  83 #include "PUCCH-PowerControl.h"
  84 #include "P0-PUCCH.h"
  85 #include "PUCCH-PathlossReferenceRS.h"
  86 #include "PUCCH-format0.h"
  87 #include "PUCCH-format1.h"
  88 #include "PUCCH-format2.h"
  89 #include "PUCCH-format3.h"
  90 #include "PUCCH-format4.h"
  91 #include "PUCCH-FormatConfig.h"
  92 #include "SchedulingRequestResourceConfig.h"
  93 #include<ProtocolIE-Field.h>
  94 #include "ProtocolExtensionField.h"
  95 #include "odu_common_codec.h"
  96 #include "du_mgr.h"
  97 #include "du_cell_mgr.h"
  98 #include "du_f1ap_msg_hdl.h"
  99 #include "DRBs-Setup-Item.h"
 100 #include "DLUPTNLInformation-ToBeSetup-List.h"
 101 #include "DLUPTNLInformation-ToBeSetup-Item.h"
 102 #include "UPTransportLayerInformation.h"
 103 #include "GTPTunnel.h"
 104
 105 #ifdef O1_ENABLE
 106 #include "ConfigInterface.h"
 107 extern StartupConfig g_cfg;
 108 #endif
 109
 110 DuCfgParams duCfgParam;
 111
 112 /************************************************************************
 113  *
 114  * @brief Converts enum values into actual value of Poll retransmit timer
 115  *
 116  * @details
 117  *
 118  *    Function : getPollPdu
 119  *
 120  *    Functionality: Converts enum values into actual value of poll
 121  *    retransmit timer
 122  *
 123  * @params[in] Enum value of pollPdu
 124  * @return Actual value of pollPdu
 125  *
 126  * **********************************************************************/
 127
 128 uint16_t getPollRetxTmr(uint8_t pollRetxTmrCfg)
 129 {
 130    uint16_t pollRetxTmr;
 131
 132    /* All values of poll retx timer are at interval of 5ms.
 133     * This is valid upto 250ms
 134     * Hence converting the enum value to actual value by multiplying it to 5
 135     */
 136    if(pollRetxTmrCfg <= T_PollRetransmit_ms250)
 137       pollRetxTmr = (pollRetxTmrCfg + 1) * 5;
 138    else
 139    {
 140       switch(pollRetxTmrCfg)
 141       {
 142          case T_PollRetransmit_ms300:
 143             pollRetxTmr = 300;
 144             break;
 145          case T_PollRetransmit_ms350:
 146             pollRetxTmr = 350;
 147             break;
 148          case T_PollRetransmit_ms400:
 149             pollRetxTmr = 400;
 150             break;
 151          case T_PollRetransmit_ms450:
 152             pollRetxTmr = 450;
 153             break;
 154          case T_PollRetransmit_ms500:
 155             pollRetxTmr = 500;
 156             break;
 157          case T_PollRetransmit_ms800:
 158             pollRetxTmr = 800;
 159             break;
 160          default:
 161             DU_LOG("\nERROR  -->  F1AP: Invalid value of Poll Retransmit timer");
 162             pollRetxTmr = 0;
 163       }
 164    }
 165    return pollRetxTmr;
 166 }
 167
 168 /*******************************************************************
 169  *
 170  * @brief Converts enum values into actual value of PollPdu
 171  *
 172  * @details
 173  *
 174  *    Function : getPollPdu
 175  *
 176  *    Functionality: Converts enum values into actual value of PollPdu
 177  *
 178  * @params[in] Enum value of pollPdu
 179  * @return Actual value of pollPdu
 180  *
 181  * ****************************************************************/
 182 int32_t getPollPdu(uint8_t pollPduCfg)
 183 {
 184    int32_t pollPdu;
 185    switch(pollPduCfg)
 186    {
 187       case PollPDU_p4:
 188          pollPdu = 4;
 189          break;
 190       case PollPDU_p8:
 191          pollPdu = 8;
 192          break;
 193       case PollPDU_p16:
 194          pollPdu = 16;
 195          break;
 196       case PollPDU_p32:
 197          pollPdu = 32;
 198          break;
 199       case PollPDU_p64:
 200          pollPdu = 64;
 201          break;
 202       case PollPDU_p128:
 203          pollPdu = 128;
 204          break;
 205       case PollPDU_p256:
 206          pollPdu = 256;
 207          break;
 208       case PollPDU_p512:
 209          pollPdu = 512;
 210          break;
 211       case PollPDU_p1024:
 212          pollPdu = 1024;
 213          break;
 214       case PollPDU_p2048:
 215          pollPdu = 2048;
 216          break;
 217       case PollPDU_p4096:
 218          pollPdu = 4096;
 219          break;
 220       case PollPDU_p6144:
 221          pollPdu = 6144;
 222          break;
 223       case PollPDU_p8192:
 224          pollPdu = 8192;
 225          break;
 226       case PollPDU_p12288:
 227          pollPdu = 12288;
 228          break;
 229       case PollPDU_p16384:
 230          pollPdu = 16384;
 231          break;
 232       case PollPDU_p20480:
 233          pollPdu = 20480;
 234          break;
 235       case PollPDU_p24576:
 236          pollPdu = 24576;
 237          break;
 238       case PollPDU_p28672:
 239          pollPdu = 28672;
 240          break;
 241       case PollPDU_p32768:
 242          pollPdu = 32768;
 243          break;
 244       case PollPDU_p40960:
 245          pollPdu = 40960;
 246          break;
 247       case PollPDU_p49152:
 248          pollPdu = 49152;
 249          break;
 250       case PollPDU_p57344:
 251          pollPdu = 57344;
 252          break;
 253       case PollPDU_p65536:
 254          pollPdu = 65536;
 255          break;
 256       case PollPDU_infinity:
 257          pollPdu = -1;
 258          break;
 259       default:
 260          DU_LOG("\nERROR  -->  F1AP: Invalid value of poll pdu");
 261          pollPdu = 0;
 262          break;
 263    }
 264    return pollPdu;
 265 }
 266
 267 /*******************************************************************
 268  *
 269  * @brief Converts enum values into actual value of poll bytes
 270  *
 271  * @details
 272  *
 273  *    Function : getPollByte
 274  *
 275  *    Functionality: Converts enum values into actual value of pollBytes
 276  *
 277  * @params[in] Enum value
 278  * @return Actual value
 279  *
 280  * ****************************************************************/
 281 int32_t getPollByte(uint16_t pollBytesCfg)
 282 {
 283    int32_t pollBytes;
 284    switch(pollBytesCfg)
 285    {
 286       case PollByte_kB1:
 287          pollBytes = 1000;
 288          break;
 289       case PollByte_kB2:
 290          pollBytes = 2000;
 291          break;
 292       case PollByte_kB5:
 293          pollBytes = 5000;
 294          break;
 295       case PollByte_kB8:
 296          pollBytes = 8000;
 297          break;
 298       case PollByte_kB10:
 299          pollBytes = 10000;
 300          break;
 301       case PollByte_kB15:
 302          pollBytes = 15000;
 303          break;
 304       case PollByte_kB25:
 305          pollBytes = 25000;
 306          break;
 307       case PollByte_kB50:
 308          pollBytes = 50000;
 309          break;
 310       case PollByte_kB75:
 311          pollBytes = 75000;
 312          break;
 313       case PollByte_kB100:
 314          pollBytes = 100000;
 315          break;
 316       case PollByte_kB125:
 317          pollBytes = 125000;
 318          break;
 319       case PollByte_kB250:
 320          pollBytes = 250000;
 321          break;
 322       case PollByte_kB375:
 323          pollBytes = 375000;
 324          break;
 325       case PollByte_kB500:
 326          pollBytes = 500000;
 327          break;
 328       case PollByte_kB750:
 329          pollBytes = 750000;
 330          break;
 331       case PollByte_kB1000:
 332          pollBytes = 1000000;
 333          break;
 334       case PollByte_kB1250:
 335          pollBytes = 1250000;
 336          break;
 337       case PollByte_kB1500:
 338          pollBytes = 1500000;
 339          break;
 340       case PollByte_kB2000:
 341          pollBytes = 2000000;
 342          break;
 343       case PollByte_kB3000:
 344          pollBytes = 3000000;
 345          break;
 346       case PollByte_kB4000:
 347          pollBytes = 4000000;
 348          break;
 349       case PollByte_kB4500:
 350          pollBytes = 4500000;
 351          break;
 352       case PollByte_kB5000:
 353          pollBytes = 5000000;
 354          break;
 355       case PollByte_kB5500:
 356          pollBytes = 5500000;
 357          break;
 358       case PollByte_kB6000:
 359          pollBytes = 6000000;
 360          break;
 361       case PollByte_kB6500:
 362          pollBytes = 6500000;
 363          break;
 364       case PollByte_kB7000:
 365          pollBytes = 7000000;
 366          break;
 367       case PollByte_kB7500:
 368          pollBytes = 7500000;
 369          break;
 370       case PollByte_mB8:
 371          pollBytes = 8000000;
 372          break;
 373       case PollByte_mB9:
 374          pollBytes = 9000000;
 375          break;
 376       case PollByte_mB10:
 377          pollBytes = 10000000;
 378          break;
 379       case PollByte_mB11:
 380          pollBytes = 11000000;
 381          break;
 382       case PollByte_mB12:
 383          pollBytes = 12000000;
 384          break;
 385       case PollByte_mB13:
 386          pollBytes = 13000000;
 387          break;
 388       case PollByte_mB14:
 389          pollBytes = 14000000;
 390          break;
 391       case PollByte_mB15:
 392          pollBytes = 15000000;
 393          break;
 394       case PollByte_mB16:
 395          pollBytes = 16000000;
 396          break;
 397       case PollByte_mB17:
 398          pollBytes = 17000000;
 399          break;
 400       case PollByte_mB18:
 401          pollBytes = 18000000;
 402          break;
 403       case PollByte_mB20:
 404          pollBytes = 20000000;
 405          break;
 406       case PollByte_mB25:
 407          pollBytes = 25000000;
 408          break;
 409       case PollByte_mB30:
 410          pollBytes = 30000000;
 411          break;
 412       case PollByte_mB40:
 413          pollBytes = 40000000;
 414          break;
 415       case PollByte_infinity:
 416          pollBytes = -1;
 417          break;
 418       default:
 419          DU_LOG("\nERROR  -->  F1AP: Invalid value of poll bytes");
 420          pollBytes = 0;
 421    }
 422    return pollBytes;
 423 }
 424
 425 /*******************************************************************
 426  *
 427  * @brief Converts enum values into actual value of maxRetx
 428  *
 429  * @details
 430  *
 431  *    Function : getMaxRetx
 432  *
 433  *    Functionality: Converts enum values into actual value of maxRetx
 434  *
 435  * @params[in] Enum value
 436  * @return Actual value
 437  *
 438  * ****************************************************************/
 439 uint8_t getMaxRetx(uint8_t maxRetxCfg)
 440 {
 441    uint8_t maxRetx;
 442    switch(maxRetxCfg)
 443    {
 444       case UL_AM_RLC__maxRetxThreshold_t1:
 445          maxRetx = 1;
 446          break;
 447       case UL_AM_RLC__maxRetxThreshold_t2:
 448          maxRetx = 2;
 449          break;
 450       case UL_AM_RLC__maxRetxThreshold_t3:
 451          maxRetx = 3;
 452          break;
 453       case UL_AM_RLC__maxRetxThreshold_t4:
 454          maxRetx = 4;
 455          break;
 456       case UL_AM_RLC__maxRetxThreshold_t6:
 457          maxRetx = 6;
 458          break;
 459       case UL_AM_RLC__maxRetxThreshold_t8:
 460          maxRetx = 8;
 461          break;
 462       case UL_AM_RLC__maxRetxThreshold_t16:
 463          maxRetx = 16;
 464          break;
 465       case UL_AM_RLC__maxRetxThreshold_t32:
 466          maxRetx = 32;
 467          break;
 468       default:
 469          DU_LOG("\nERROR  -->  F1AP: Invalid configuration for Max retransmission threshold");
 470          maxRetx = 0;
 471    }
 472    return maxRetx;
 473 }
 474
 475 /*******************************************************************
 476  * @brief Converts enum values into actual value of reassembly timer
 477  *
 478  * @details
 479  *
 480  *    Function : getReAsmblTmr
 481  *
 482  *    Functionality: Converts enum values into actual value of reassembly
 483  *    timer
 484  *
 485  * @params[in] Enum value of reassembly timer
 486  * @return Actual value of reassembly timer
 487  *
 488  * **********************************************************************/
 489
 490 int8_t getReAsmblTmr(uint8_t reAsmblTmrCfg)
 491 {
 492    int8_t reAsmblTmr = 0;
 493
 494    if(reAsmblTmrCfg == T_Reassembly_ms0)
 495    {
 496       reAsmblTmr = 0;
 497    }
 498    else if(reAsmblTmrCfg >= T_Reassembly_ms5 || reAsmblTmrCfg <= T_Reassembly_ms100)
 499    {
 500      /* All values of re assembly timer are at interval of 5ms.
 501       * This is valid upto 100ms
 502       * Hence converting the enum value to actual value by multiplying it to 5
 503       */
 504       reAsmblTmr = reAsmblTmrCfg * 5;
 505    }
 506    else if(reAsmblTmrCfg >= T_Reassembly_ms110 || reAsmblTmrCfg <= T_Reassembly_ms200)
 507    {
 508      /* All values of re assembly timer are at interval of 10ms.
 509       * This is valid upto 200ms
 510       * since enum value starts from 20 for 100ms, subtracting 10 and
 511       * converting the enum value to actual value by multiplying it to 10
 512       */
 513       reAsmblTmr = ((reAsmblTmrCfg-10) * 10);
 514    }
 515    else
 516    {
 517       DU_LOG("\nERROR  -->  F1AP : Invalid value of Re Assembly timer %d", reAsmblTmrCfg);
 518       reAsmblTmr = -1;
 519    }
 520    return reAsmblTmr;
 521 }
 522
 523 /************************************************************************
 524  *
 525  * @brief Converts enum values into actual value of status prohibit timer
 526  *
 527  * @details
 528  *
 529  *    Function : getStatProhTmr
 530  *
 531  *    Functionality: Converts enum values into actual value of status prohibit
 532  *    timer
 533  *
 534  * @params[in] Enum value of status prohibit timer
 535  * @return Actual value of status prohibit timer
 536  *
 537  * **********************************************************************/
 538
 539 int16_t getStatProhTmr(uint8_t statProhTmrCfg)
 540 {
 541    int16_t statProhTmr =0;
 542
 543    if(statProhTmrCfg == T_StatusProhibit_ms0)
 544    {
 545       statProhTmr = 0;
 546    }
 547    else if(statProhTmrCfg >= T_StatusProhibit_ms5 || statProhTmrCfg <= T_StatusProhibit_ms250)
 548    {
 549       /* All values of re assembly timer are at interval of 5ms.
 550        * This is valid upto 250ms
 551        * Hence converting the enum value to actual value by multiplying it to 5
 552        */
 553       statProhTmr = statProhTmrCfg * 5;
 554    }
 555    else
 556    {
 557       switch(statProhTmrCfg)
 558       {
 559          case T_StatusProhibit_ms300:
 560             statProhTmr = 300;
 561             break;
 562          case T_StatusProhibit_ms350:
 563             statProhTmr = 350;
 564             break;
 565          case T_StatusProhibit_ms400:
 566             statProhTmr = 400;
 567             break;
 568          case T_StatusProhibit_ms450:
 569             statProhTmr = 450;
 570             break;
 571          case T_StatusProhibit_ms500:
 572             statProhTmr = 500;
 573             break;
 574          case T_StatusProhibit_ms800:
 575             statProhTmr = 800;
 576             break;
 577          case T_StatusProhibit_ms1000:
 578             statProhTmr = 1000;
 579             break;
 580          case T_StatusProhibit_ms1200:
 581             statProhTmr = 1200;
 582             break;
 583          case T_StatusProhibit_ms1600:
 584             statProhTmr = 1600;
 585             break;
 586          case T_StatusProhibit_ms2000:
 587             statProhTmr = 2000;
 588             break;
 589          case T_StatusProhibit_ms2400:
 590             statProhTmr = 2400;
 591             break;
 592          default:
 593             DU_LOG("\nInvalid value of Status Prohibit timer %d", statProhTmrCfg);
 594             statProhTmr = -1;
 595             break;
 596       }
 597    }
 598    return statProhTmr;
 599 }
 600
 601 /*******************************************************************
 602 *
 603 * @brief Adding F1AP pdu to reserved pdu list
 604 *
 605 * @details
 606 *
 607 *    Function : addToReservedF1apPduList
 608 *
 609 *    Functionality: Adding F1AP pdu to reserved pdu list.
 610 *     These pdu are awaiting aknowledgment from CU
 611 *
 612 * @params[in] uint8_t transId, F1AP_PDU_t *f1apMsg
 613 *
 614 * @return ROK - success
 615 *         RFAILED - failure
 616 *
 617 * ****************************************************************/
 618
 619 void addToReservedF1apPduList(uint8_t transId, F1AP_PDU_t *f1apPdu)
 620 {
 621    CmLList         *node = NULLP;
 622    ReservedF1apPduInfo *pduInfo = NULLP;
 623    DU_ALLOC(pduInfo, sizeof(ReservedF1apPduInfo));
 624    if(pduInfo)
 625    {
 626       DU_ALLOC(node, sizeof(CmLList));
 627       if(node)
 628       {
 629          pduInfo->transId = transId;
 630          pduInfo->f1apMsg = (void*) f1apPdu;
 631
 632          node->node = (PTR)pduInfo;
 633          cmLListAdd2Tail(&duCb.reservedF1apPduList, node);
 634       }
 635    }
 636 }
 637
 638 /*******************************************************************
 639 *
 640 * @brief searching for F1AP pdu from ReservedF1apPduList
 641 *
 642 * @details
 643 *
 644 *    Function : searchFromReservedF1apPduList
 645 *
 646 *    Functionality: searching for F1AP pdu information
 647 *
 648 * @params[in] uint8_t transId
 649 *
 650 * @return pointer to F1AP_PDU_t
 651 *
 652 * ****************************************************************/
 653
 654 CmLList *searchFromReservedF1apPduList(uint8_t transId)
 655 {
 656    CmLList         *node;
 657    ReservedF1apPduInfo *f1apPdu;
 658    if(duCb.reservedF1apPduList.count)
 659    {
 660       CM_LLIST_FIRST_NODE(&duCb.reservedF1apPduList, node);
 661       while(node)
 662       {
 663          f1apPdu = (ReservedF1apPduInfo*)node->node;
 664          if(f1apPdu->transId == transId)
 665          {
 666             return node;
 667          }
 668          node = node->next;
 669       }
 670    }
 671    return NULL;
 672 }
 673
 674 /*******************************************************************
 675 *
 676 * @brief deleting F1AP pdu information from ReservedF1apPduList
 677 *
 678 * @details
 679 *
 680 *    Function : deleteFromReservedF1apPduList
 681 *
 682 *    Functionality: deleting pdu information from ReservedF1apPduList
 683 *
 684 * @params[in] CmLList *node
 685 *
 686 * @return void
 687 *
 688 * ****************************************************************/
 689
 690 void deleteFromReservedF1apPduList(CmLList *node)
 691 {
 692    ReservedF1apPduInfo *f1apPdu;
 693
 694    if(node != NULL)
 695    {
 696       f1apPdu = (ReservedF1apPduInfo *)node->node;
 697       cmLListDelFrm(&duCb.reservedF1apPduList, node);
 698       DU_FREE(f1apPdu, sizeof(ReservedF1apPduInfo));
 699       DU_FREE(node, sizeof(CmLList));
 700       node = NULL;
 701    }
 702 }
 703
 704 /*******************************************************************
 705  *
 706  * @brief Builds Uplink Info for NR
 707  *
 708  * @details
 709  *
 710  *    Function : BuildULNRInfo
 711  *
 712  *    Functionality: Building NR Uplink Info
 713  *
 714  * @params[in] NRFreqInfo_t *ulnrfreq
 715  * @return ROK     - success
 716  *         RFAILED - failure
 717  *
 718  * ****************************************************************/
 719 uint8_t BuildULNRInfo(NRFreqInfo_t *ulnrfreq)
 720 {
 721    uint8_t idx=0;
 722    ulnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 723                        fdd.ulNrFreqInfo.nrArfcn;
 724    ulnrfreq->freqBandListNr.list.count = 1;
 725    ulnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 726    DU_ALLOC(ulnrfreq->freqBandListNr.list.array,ulnrfreq->freqBandListNr.list.size);
 727    if(ulnrfreq->freqBandListNr.list.array == NULLP)
 728    {
 729       return RFAILED;
 730    }
 731    for(idx=0;idx<ulnrfreq->freqBandListNr.list.count;idx++)
 732    {
 733       DU_ALLOC(ulnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 734       if(ulnrfreq->freqBandListNr.list.array[idx] == NULLP)
 735       {
 736          return RFAILED;
 737       }
 738    }
 739    ulnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 740                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
 741                                                                  freqBand[0].nrFreqBand;
 742    ulnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 743    return ROK;
 744 }
 745 /*******************************************************************
 746  *
 747  * @brief Builds Downlink NR Info
 748  *
 749  * @details
 750  *
 751  *    Function : BuildDLNRInfo
 752  *
 753  *    Functionality: Building Downlink NR Info
 754  *
 755  * @params[in] NRFreqInfo_t *dlnrfreq
 756  * @return ROK     - success
 757  *         RFAILED - failure
 758  *
 759  * ****************************************************************/
 760 uint8_t BuildDLNRInfo(NRFreqInfo_t *dlnrfreq)
 761 {
 762    uint8_t idx=0;
 763    dlnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 764                        fdd.dlNrFreqInfo.nrArfcn;
 765    dlnrfreq->freqBandListNr.list.count = 1;
 766    dlnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 767    DU_ALLOC(dlnrfreq->freqBandListNr.list.array,dlnrfreq->freqBandListNr.list.size);
 768    if(dlnrfreq->freqBandListNr.list.array == NULLP)
 769    {
 770       return RFAILED;
 771    }
 772    for(idx=0;idx< dlnrfreq->freqBandListNr.list.count;idx++)
 773    {
 774       DU_ALLOC(dlnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 775       if(dlnrfreq->freqBandListNr.list.array[idx] == NULLP)
 776       {
 777          return RFAILED;
 778       }
 779    }
 780    dlnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 781                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
 782                                                                  freqBand[0].nrFreqBand;
 783    dlnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 784
 785    return ROK;
 786 }
 787
 788 /*******************************************************************
 789  *
 790  * @brief Builds NRCell ID
 791  *
 792  * @details
 793  *
 794  *    Function : BuildNrCellId
 795  *
 796  *    Functionality: Building the NR Cell ID
 797  *
 798  * @params[in] BIT_STRING_t *nrcell
 799  * @return ROK     - success
 800  *         RFAILED - failure
 801  *
 802  * ****************************************************************/
 803
 804 S16 BuildNrCellId(BIT_STRING_t *nrcell)
 805 {
 806    memset(nrcell->buf, 0, nrcell->size);
 807    nrcell->buf[4]   = 16;
 808    nrcell->bits_unused = 4;
 809    return ROK;
 810 }
 811
 812 /*******************************************************************
 813  *
 814  * @brief Builds Nrcgi
 815  *
 816  * @details
 817  *
 818  *    Function : BuildNrcgi
 819  *
 820  *    Functionality: Building the PLMN ID and NR Cell id
 821  *
 822  * @params[in] NRCGI_t *nrcgi
 823  * @return ROK     - success
 824  *         RFAILED - failure
 825  *
 826  * ****************************************************************/
 827 uint8_t BuildNrcgi(NRCGI_t *nrcgi)
 828 {
 829    uint8_t ret;
 830    uint8_t byteSize = 5;
 831    /* Allocate Buffer Memory */
 832    nrcgi->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 833    DU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
 834    if(nrcgi->pLMN_Identity.buf == NULLP)
 835    {
 836       return RFAILED;
 837    }
 838    ret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 839          nrcgi->pLMN_Identity.buf); // Building PLMN function
 840    if(ret != ROK)
 841    {
 842       return RFAILED;
 843    }
 844    /*nrCellIdentity*/
 845    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
 846    DU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
 847    if(nrcgi->nRCellIdentity.buf == NULLP)
 848    {
 849       return RFAILED;
 850    }
 851    BuildNrCellId(&nrcgi->nRCellIdentity);
 852
 853    return ROK;
 854 }
 855 /*******************************************************************
 856  *
 857  * @brief Builds FiveGStac
 858  *
 859  * @details
 860  *
 861  *    Function : BuildFiveGSTac
 862  *
 863  *    Functionality: Building the FiveGSTac
 864  *
 865  * @params[in] OCTET_STRING_t *fivegsTac
 866  * @return ROK     - success
 867  *         RFAILED - failure
 868  *
 869  * ****************************************************************/
 870 uint8_t BuildFiveGSTac(Served_Cell_Information_t *servcell)
 871 {
 872    DU_ALLOC(servcell->fiveGS_TAC,sizeof(FiveGS_TAC_t));
 873    if(servcell->fiveGS_TAC == NULLP)
 874    {
 875       return RFAILED;
 876    }
 877    servcell->fiveGS_TAC->size = 3 * sizeof(uint8_t);
 878    DU_ALLOC(servcell->fiveGS_TAC->buf,\
 879          sizeof(servcell->fiveGS_TAC->size));
 880    if(servcell->fiveGS_TAC->buf == NULLP)
 881    {
 882       return RFAILED;
 883    }
 884    servcell->fiveGS_TAC->buf[0] = 0;
 885    servcell->fiveGS_TAC->buf[1] = 0;
 886    servcell->fiveGS_TAC->buf[2] = duCfgParam.srvdCellLst[0].duCellInfo.tac;
 887    return ROK;
 888 }
 889 /*******************************************************************
 890  *
 891  * @brief Builds NR Mode
 892  *
 893  * @details
 894  *
 895  *    Function : BuildNrMode
 896  *
 897  *    Functionality: Building the NR Mode
 898  *
 899  * @params[in] NR_Mode_Info_t *fdd
 900  * @return ROK     - success
 901  *         RFAILED - failure
 902  *
 903  * ****************************************************************/
 904 uint8_t BuildNrMode(NR_Mode_Info_t *mode)
 905 {
 906    uint8_t BuildDLNRInforet=0;
 907    uint8_t BuildULNRInforet=0;
 908    /* FDD Mode */
 909    mode->present = NR_Mode_Info_PR_fDD;
 910    if(mode->present == NR_Mode_Info_PR_fDD)
 911    {
 912       DU_ALLOC(mode->choice.fDD,sizeof(FDD_Info_t));
 913       if(mode->choice.fDD == NULLP)
 914       {
 915          return RFAILED;
 916       }
 917       BuildULNRInforet = BuildULNRInfo(&mode->choice.fDD->uL_NRFreqInfo);
 918       if(BuildULNRInforet != ROK)
 919       {
 920          return RFAILED;
 921       }
 922       BuildDLNRInforet = BuildDLNRInfo(&mode->choice.fDD->dL_NRFreqInfo);
 923       if(BuildDLNRInforet != ROK)
 924       {
 925          return RFAILED;
 926       }
 927    }
 928    mode->choice.fDD->uL_Transmission_Bandwidth.nRSCS = \
 929                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 930                                                        f1Mode.mode.fdd.ulTxBw.nrScs;
 931    mode->choice.fDD->uL_Transmission_Bandwidth.nRNRB = \
 932                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 933                                                        f1Mode.mode.fdd.ulTxBw.nrb;
 934    mode->choice.fDD->dL_Transmission_Bandwidth.nRSCS = \
 935                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 936                                                        f1Mode.mode.fdd.dlTxBw.nrScs;
 937    mode->choice.fDD->dL_Transmission_Bandwidth.nRNRB = \
 938                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 939                                                        f1Mode.mode.fdd.dlTxBw.nrb;
 940    return ROK;
 941 }
 942 /*******************************************************************
 943  *
 944  * @brief Builds IE Extensions for Served PLMNs
 945  *
 946  * @details
 947  *
 948  *    Function : BuildExtensions
 949  *
 950  *    Functionality: Building the IE Extensions
 951  *
 952  * @params[in] struct ProtocolExtensionContainer_4624P3 *buildextend
 953  * @return ROK     - success
 954  *         RFAILED - failure
 955  *
 956  * ****************************************************************/
 957 uint8_t BuildExtensions(ProtocolExtensionContainer_4624P3_t **ieExtend)
 958 {
 959    uint8_t idx=0, plmnidx=0, sliceLstIdx=0;
 960    uint8_t elementCnt=0, extensionCnt=0;
 961
 962    extensionCnt=IE_EXTENSION_LIST_COUNT;
 963    DU_ALLOC(*ieExtend,sizeof(ProtocolExtensionContainer_4624P3_t));
 964    if((*ieExtend) == NULLP)
 965    {
 966       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 967       return RFAILED;
 968    }
 969    (*ieExtend)->list.count = extensionCnt;
 970    (*ieExtend)->list.size = \
 971                             extensionCnt * sizeof(ServedPLMNs_ItemExtIEs_t *);
 972    DU_ALLOC((*ieExtend)->list.array,(*ieExtend)->list.size);
 973    if((*ieExtend)->list.array == NULLP)
 974    {
 975       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 976       return RFAILED;
 977    }
 978    for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
 979    {
 980       DU_ALLOC((*ieExtend)->list.array[plmnidx],\
 981             sizeof(ServedPLMNs_ItemExtIEs_t));
 982       if((*ieExtend)->list.array[plmnidx] == NULLP)
 983       {
 984          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 985          return RFAILED;
 986       }
 987    }
 988
 989    elementCnt = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].taiSliceSuppLst.numSupportedSlices;
 990    idx = 0;
 991    (*ieExtend)->list.array[idx]->id = ProtocolIE_ID_id_TAISliceSupportList;
 992    (*ieExtend)->list.array[idx]->criticality = Criticality_ignore;
 993    (*ieExtend)->list.array[idx]->extensionValue.present = \
 994    ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
 995    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 996       list.count = elementCnt;
 997    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 998       list.size = (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 999       list.count * sizeof(SliceSupportItem_t *);
1000
1001    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1002          list.array, elementCnt * sizeof(SliceSupportItem_t *));
1003    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1004          list.array == NULLP)
1005    {
1006       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1007       return RFAILED;
1008    }
1009
1010    for(sliceLstIdx =0; sliceLstIdx<elementCnt; sliceLstIdx++)
1011    {
1012       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1013             list.array[sliceLstIdx],sizeof(SliceSupportItem_t));
1014       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1015             list.array[sliceLstIdx] == NULLP)
1016       {
1017          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1018          return RFAILED;
1019       }
1020       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1021          list.array[sliceLstIdx]->sNSSAI.sST.size = sizeof(uint8_t);
1022       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
1023             .list.array[sliceLstIdx]->sNSSAI.sST.buf,(*ieExtend)->list.array[idx]->\
1024             extensionValue.choice.SliceSupportList.\
1025             list.array[sliceLstIdx]->sNSSAI.sST.size);
1026       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
1027             .list.array[sliceLstIdx]->sNSSAI.sST.buf == NULLP)
1028       {
1029          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1030          return RFAILED;
1031       }
1032       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1033          list.array[sliceLstIdx]->sNSSAI.sST.buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.\
1034          cellInfo.srvdPlmn[0].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
1035
1036       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1037             list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1038       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1039             list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
1040       {
1041          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1042          return RFAILED;
1043       }
1044       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1045          list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
1046       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1047             list.array[sliceLstIdx]->sNSSAI.sD->buf, (*ieExtend)->list.array[idx]->extensionValue.choice.\
1048             SliceSupportList.list.array[sliceLstIdx]->sNSSAI.sD->size);
1049       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1050             list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
1051       {
1052          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1053          return RFAILED;
1054       }
1055       memcpy((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1056       list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[0].duCellInfo.\
1057       cellInfo.srvdPlmn[0].taiSliceSuppLst.snssai[sliceLstIdx]->sd, (*ieExtend)->list.array[idx]->\
1058       extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->sNSSAI.sD->size);
1059    }
1060    return ROK;
1061 }
1062 /*******************************************************************
1063  *
1064  * @brief Builds Served PLMN
1065  *
1066  * @details
1067  *
1068  *    Function : BuildServedPlmn
1069  *
1070  *    Functionality: Building the Served PLMN
1071  *
1072  * @params[in] GNB_DU_Served_Cells_Item_t *srvCellItem
1073  * @return ROK     - success
1074  *         RFAILED - failure
1075  *
1076  * ****************************************************************/
1077 uint8_t  BuildServedPlmn(ServedPLMNs_List_t *srvplmn)
1078 {
1079    uint8_t  plmnidx;
1080    uint8_t  servPlmnCnt=1;
1081    uint8_t buildPlmnIdret=0;
1082    uint8_t BuildExtensionsret=0;
1083    srvplmn->list.count = servPlmnCnt;
1084    srvplmn->list.size = \
1085                         servPlmnCnt*sizeof(ServedPLMNs_Item_t *);
1086    DU_ALLOC(srvplmn->list.array,srvplmn->list.size);
1087    if(srvplmn->list.array == NULLP)
1088    {
1089       return RFAILED;
1090    }
1091    for(plmnidx=0; plmnidx<servPlmnCnt; plmnidx++)
1092    {
1093       DU_ALLOC(srvplmn->list.array[plmnidx],\
1094             sizeof(ServedPLMNs_Item_t));
1095       if(srvplmn->list.array[plmnidx] == NULLP)
1096       {
1097          return RFAILED;
1098       }
1099    }
1100    srvplmn->list.array[0]->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
1101    DU_ALLOC(srvplmn->list.array[0]->pLMN_Identity.buf, srvplmn->list.array[0]->pLMN_Identity.size);
1102    buildPlmnIdret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
1103          srvplmn->list.array[0]->pLMN_Identity.buf);
1104    if(buildPlmnIdret!= ROK)
1105    {
1106       return RFAILED;
1107    }
1108    BuildExtensionsret = BuildExtensions(&srvplmn->list.array[0]->iE_Extensions);
1109    if(BuildExtensionsret!= ROK)
1110    {
1111       return RFAILED;
1112    }
1113    return ROK;
1114 }
1115 /*******************************************************************
1116  *
1117  * @brief Builds Served Cell List
1118  *
1119  * @details
1120  *
1121  *    Function : BuildServedCellList
1122  *
1123  *    Functionality: Building Served Cell List
1124  *
1125  * @params[in] PLMNID plmn
1126  * @return ROK     - success
1127  *         RFAILED - failure
1128  *
1129  * ****************************************************************/
1130
1131 uint8_t BuildServedCellList(GNB_DU_Served_Cells_List_t *duServedCell)
1132 {
1133    uint8_t  BuildNrcgiret=0;
1134    uint8_t  BuildFiveGSTacret=0;
1135    uint8_t  BuildServedPlmnret=0;
1136    uint8_t  BuildNrModeret=0;
1137    uint8_t  idx;
1138    uint8_t  plmnidx;
1139    uint8_t  plmnCnt=1;
1140    GNB_DU_Served_Cells_Item_t *srvCellItem;
1141    duServedCell->list.size = plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t *);
1142    duServedCell->list.count = plmnCnt;
1143
1144    DU_ALLOC(duServedCell->list.array, duServedCell->list.size);
1145    if(duServedCell->list.array == NULLP)
1146    {
1147       return RFAILED;
1148    }
1149    for(plmnidx=0; plmnidx<plmnCnt; plmnidx++)
1150    {
1151       DU_ALLOC(duServedCell->list.array[plmnidx],\
1152             sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1153       if(duServedCell->list.array[plmnidx] == NULLP)
1154       {
1155          return RFAILED;
1156       }
1157    }
1158    idx = 0;
1159    duServedCell->list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_Served_Cells_Item;
1160    duServedCell->list.array[idx]->criticality = Criticality_reject;
1161    duServedCell->list.array[idx]->value.present = \
1162                                                   GNB_DU_Served_Cells_ItemIEs__value_PR_GNB_DU_Served_Cells_Item;
1163    srvCellItem = \
1164                  &duServedCell->list.array[idx]->value.choice.GNB_DU_Served_Cells_Item;
1165    /*nRCGI*/
1166    BuildNrcgiret = BuildNrcgi(&srvCellItem->served_Cell_Information.nRCGI);
1167    if(BuildNrcgiret != ROK)
1168    {
1169       return RFAILED;
1170    }
1171    /*nRPCI*/
1172    srvCellItem->served_Cell_Information.nRPCI = \
1173                                                 duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
1174
1175    /*fiveGS_TAC*/
1176    BuildFiveGSTacret = BuildFiveGSTac(&srvCellItem->served_Cell_Information);
1177    if(BuildFiveGSTacret != ROK)
1178    {
1179       return RFAILED;
1180    }
1181    /*Served PLMNs*/
1182    BuildServedPlmnret = BuildServedPlmn(&srvCellItem->served_Cell_Information.servedPLMNs);
1183    if(BuildServedPlmnret !=ROK)
1184    {
1185       return RFAILED;
1186    }
1187    /*nR Mode Info with FDD*/
1188    BuildNrModeret = BuildNrMode(&srvCellItem->served_Cell_Information.nR_Mode_Info);
1189    if(BuildNrModeret != ROK)
1190    {
1191       return RFAILED;
1192    }
1193    /*Measurement timing Config*/
1194    srvCellItem->served_Cell_Information.measurementTimingConfiguration.\
1195       size = sizeof(uint8_t);
1196    DU_ALLOC(srvCellItem->served_Cell_Information.\
1197          measurementTimingConfiguration.buf,srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1198    if(srvCellItem->served_Cell_Information.\
1199          measurementTimingConfiguration.buf == NULLP)
1200    {
1201       return RFAILED;
1202    }
1203    srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf[0] = \
1204                                                                                 duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
1205
1206    /* GNB DU System Information */
1207    DU_ALLOC(srvCellItem->gNB_DU_System_Information,
1208          sizeof(GNB_DU_System_Information_t));
1209    if(!srvCellItem->gNB_DU_System_Information)
1210    {
1211       return RFAILED;
1212    }
1213    /* MIB */
1214    srvCellItem->gNB_DU_System_Information->mIB_message.size = duCfgParam.srvdCellLst[0].duSysInfo.mibLen;
1215    DU_ALLOC(srvCellItem->gNB_DU_System_Information->mIB_message.buf,
1216          srvCellItem->gNB_DU_System_Information->mIB_message.size);
1217    if(!srvCellItem->gNB_DU_System_Information->mIB_message.buf)
1218    {
1219       return RFAILED;
1220    }
1221    memcpy(srvCellItem->gNB_DU_System_Information->mIB_message.buf, duCfgParam.srvdCellLst[0].duSysInfo.mibMsg, \
1222                    srvCellItem->gNB_DU_System_Information->mIB_message.size);
1223
1224    /* SIB1 */
1225    srvCellItem->gNB_DU_System_Information->sIB1_message.size =\
1226                                                               duCfgParam.srvdCellLst[0].duSysInfo.sib1Len;
1227
1228    DU_ALLOC(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,
1229          srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1230    if(!srvCellItem->gNB_DU_System_Information->sIB1_message.buf)
1231    {
1232       return RFAILED;
1233    }
1234    for(int x=0; x<srvCellItem->gNB_DU_System_Information->sIB1_message.size; x++)
1235    {
1236       srvCellItem->gNB_DU_System_Information->sIB1_message.buf[x]=\
1237                                                                   duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg[x];
1238    }
1239    return ROK;
1240 }
1241 /*******************************************************************
1242  *
1243  * @brief Builds RRC Version
1244  *
1245  * @details
1246  *
1247  *    Function : BuildRrcVer
1248  *
1249  *    Functionality: Building RRC Version
1250  *
1251  * @params[in] int idx,int elementCnt,RRC_Version_t *rrcver
1252  * @return ROK     - success
1253  *         RFAILED - failure
1254  *
1255  * ****************************************************************/
1256 uint8_t BuildRrcVer(RRC_Version_t *rrcVer)
1257 {
1258    uint8_t rrcExt;
1259    uint8_t rrcLatest;
1260    rrcVer->latest_RRC_Version.size = sizeof(uint8_t);
1261    DU_ALLOC(rrcVer->latest_RRC_Version.buf,sizeof(uint8_t));
1262    if(rrcVer->latest_RRC_Version.buf == NULLP)
1263    {
1264       return RFAILED;
1265    }
1266    rrcVer->latest_RRC_Version.buf[0] = 0;
1267    rrcVer->latest_RRC_Version.bits_unused = 5;
1268    DU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1269    if(rrcVer->iE_Extensions == NULLP)
1270    {
1271       return RFAILED;
1272    }
1273    rrcVer->iE_Extensions->list.count = 1;
1274    rrcVer->iE_Extensions->list.size = sizeof(RRC_Version_ExtIEs_t *);
1275    DU_ALLOC(rrcVer->iE_Extensions->list.array,rrcVer->iE_Extensions->list.size);
1276    if(rrcVer->iE_Extensions->list.array == NULLP)
1277    {
1278       return RFAILED;
1279    }
1280    rrcExt = 0;
1281    DU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
1282          sizeof(RRC_Version_ExtIEs_t));
1283    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
1284    {
1285       return RFAILED;
1286    }
1287    rrcVer->iE_Extensions->list.array[rrcExt]->id = \
1288                                                    ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
1289    rrcVer->iE_Extensions->list.array[rrcExt]->criticality = Criticality_reject;
1290    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.present =\
1291                                                                       RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
1292    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1293       .Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
1294    DU_ALLOC(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1295          .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1296          array[rrcExt]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1297    if(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1298          .Latest_RRC_Version_Enhanced.buf == NULLP)
1299    {
1300       return RFAILED;
1301    }
1302    rrcLatest = 0;
1303    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1304       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 15;
1305    rrcLatest++;
1306    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1307       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 5;
1308    rrcLatest++;
1309    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1310       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 0;
1311    return ROK;
1312 }
1313 /*******************************************************************
1314  *
1315  * @brief Sends F1 msg over SCTP
1316  *
1317  * @details
1318  *
1319  *    Function : sendF1APMsg
1320  *
1321  *    Functionality: Sends F1 msg over SCTP
1322  *
1323  * @params[in] Region region
1324  *             Pool pool
1325  * @return ROK     - success
1326  *         RFAILED - failure
1327  *
1328  * ****************************************************************/
1329 uint8_t sendF1APMsg()
1330 {
1331    Buffer *mBuf = NULLP;
1332
1333    if(ODU_GET_MSG_BUF(DU_APP_MEM_REGION, DU_POOL, &mBuf) == ROK)
1334    {
1335       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
1336       {
1337             ODU_PRINT_MSG(mBuf, 0,0);
1338
1339             if(sctpSend(mBuf, F1_INTERFACE) != ROK)
1340             {
1341                DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
1342                ODU_PUT_MSG_BUF(mBuf);
1343                return RFAILED;
1344             }
1345       }
1346       else
1347       {
1348          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
1349          ODU_PUT_MSG_BUF(mBuf);
1350          return RFAILED;
1351       }
1352       ODU_PUT_MSG_BUF(mBuf);
1353    }
1354    else
1355    {
1356       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
1357       return RFAILED;
1358    }
1359    return ROK;
1360 } /* sendF1APMsg */
1361
1362 /*******************************************************************
1363  *
1364  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1365  *
1366  * @details
1367  *
1368  *    Function :  FreeRrcVer
1369  *
1370  *    Functionality: deallocating the memory of function BuildRrcVer
1371  *
1372  * @params[in] RRC_Version_t *rrcVer
1373  *
1374  * @return void
1375  *
1376  *****************************************************************/
1377 void FreeRrcVer(RRC_Version_t *rrcVer)
1378 {
1379    if(rrcVer->latest_RRC_Version.buf != NULLP)
1380    {
1381       if(rrcVer->iE_Extensions != NULLP)
1382       {
1383          if(rrcVer->iE_Extensions->list.array != NULLP)
1384          {
1385             if(rrcVer->iE_Extensions->list.array[0] != NULLP)
1386             {
1387                if(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf
1388                      != NULLP)
1389                {
1390                   DU_FREE(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice\
1391                         .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1392                         array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1393                }
1394                DU_FREE(rrcVer->iE_Extensions->list.array[0],sizeof(RRC_Version_ExtIEs_t));
1395             }
1396             DU_FREE(rrcVer->iE_Extensions->list.array,sizeof(RRC_Version_ExtIEs_t*));
1397          }
1398          DU_FREE(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1399       }
1400       DU_FREE(rrcVer->latest_RRC_Version.buf,rrcVer->latest_RRC_Version.size);
1401    }
1402 }
1403 /*******************************************************************
1404  *
1405  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1406  *
1407  * @details
1408  *
1409  *    Function :  FreeServedCellList
1410  *
1411  *    Functionality:  deallocating the memory of function BuildServedCellList
1412
1413  *
1414  * @params[in] GNB_DU_Served_Cells_List_t *duServedCell
1415  *
1416  * @return void
1417  *
1418  * ****************************************************************/
1419 void FreeServedCellList( GNB_DU_Served_Cells_List_t *duServedCell)
1420 {
1421    uint8_t   plmnCnt=MAX_PLMN;
1422    uint8_t  extensionCnt=IE_EXTENSION_LIST_COUNT;
1423    uint8_t  plmnIdx=0, sliceIdx=0;
1424    GNB_DU_Served_Cells_Item_t *srvCellItem;
1425    ServedPLMNs_Item_t  *servedPlmnItem;
1426    SliceSupportItem_t  *sliceSupportItem;
1427
1428    if(duServedCell->list.array!=NULLP)
1429    {
1430       if(duServedCell->list.array[0]!=NULLP)
1431       {
1432          srvCellItem= &duServedCell->list.array[0]->value.choice.GNB_DU_Served_Cells_Item;
1433
1434          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1435                srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size * sizeof(uint8_t));
1436          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1437                srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size * sizeof(uint8_t));
1438
1439          if(srvCellItem->served_Cell_Information.fiveGS_TAC!=NULLP)
1440          {
1441             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
1442                   sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
1443             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,sizeof(FiveGS_TAC_t));
1444          }
1445
1446          if(srvCellItem->served_Cell_Information.servedPLMNs.list.array!=NULLP)
1447          {
1448             if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx] != NULLP)
1449             {
1450                servedPlmnItem = srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx];
1451                DU_FREE(servedPlmnItem->pLMN_Identity.buf, servedPlmnItem->pLMN_Identity.size);
1452
1453                if(servedPlmnItem->iE_Extensions != NULLP)
1454                {
1455                   if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1456                   {
1457                      if(servedPlmnItem->iE_Extensions->list.array[0] != NULLP)
1458                      {
1459                         if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1460                         SliceSupportList.list.array != NULLP)
1461                         {
1462                            for(sliceIdx =0; sliceIdx<servedPlmnItem->iE_Extensions->list.array[0]->\
1463                            extensionValue.choice.SliceSupportList.list.count; sliceIdx++)
1464                            {
1465                               if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1466                               SliceSupportList.list.array[sliceIdx] != NULLP)
1467                               {
1468                                  sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[0]->\
1469                                  extensionValue.choice.SliceSupportList.list.array[sliceIdx];
1470
1471                                  DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sizeof(uint8_t));
1472
1473                                  if(sliceSupportItem->sNSSAI.sD != NULLP)
1474                                  {
1475                                     DU_FREE(sliceSupportItem->sNSSAI.sD->buf,\
1476                                     sliceSupportItem->sNSSAI.sD->size);
1477                                     DU_FREE(sliceSupportItem->sNSSAI.sD, sizeof(OCTET_STRING_t));
1478                                  }
1479
1480                                  DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.\
1481                                  choice.SliceSupportList.list.array[sliceIdx], sizeof(SliceSupportItem_t));
1482                               }
1483                            }
1484                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1485                            SliceSupportList.list.array, servedPlmnItem->iE_Extensions->list.array[0]->\
1486                            extensionValue.choice.SliceSupportList.list.size);
1487                         }
1488                         DU_FREE(servedPlmnItem->iE_Extensions->list.array[0],\
1489                         sizeof(ServedPLMNs_ItemExtIEs_t));
1490                      }
1491                      DU_FREE(servedPlmnItem->iE_Extensions->list.array,\
1492                      extensionCnt*sizeof(ServedPLMNs_ItemExtIEs_t*));
1493                   }
1494                   DU_FREE(servedPlmnItem->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P3_t));
1495                }
1496                DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx],\
1497                sizeof(ServedPLMNs_Item_t));
1498             }
1499             DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array,\
1500             sizeof(ServedPLMNs_Item_t *));
1501          }
1502
1503          if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD != NULLP)
1504          {
1505             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
1506                   freqBandListNr.list.array != NULLP)
1507             {
1508                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
1509                uL_NRFreqInfo.freqBandListNr.list.array[0],sizeof(FreqBandNrItem_t));
1510                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
1511                uL_NRFreqInfo.freqBandListNr.list.array,sizeof(FreqBandNrItem_t*));
1512             }
1513
1514             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1515                   freqBandListNr.list.array)
1516             {
1517                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1518                      freqBandListNr.list.array[0],sizeof(FreqBandNrItem_t));
1519                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1520                      freqBandListNr.list.array,sizeof(FreqBandNrItem_t *));
1521             }
1522             DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD, sizeof(FDD_Info_t));
1523          }
1524
1525          DU_FREE(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1526                srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1527
1528          if(srvCellItem->gNB_DU_System_Information != NULLP)
1529          {
1530             if(srvCellItem->gNB_DU_System_Information->mIB_message.buf != NULLP)
1531             {
1532                DU_FREE(srvCellItem->gNB_DU_System_Information->mIB_message.buf,\
1533                      srvCellItem->gNB_DU_System_Information->mIB_message.size);
1534             }
1535
1536             if(srvCellItem->gNB_DU_System_Information->sIB1_message.buf != NULLP)
1537             {
1538                DU_FREE(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,\
1539                      srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1540             }
1541
1542             DU_FREE(srvCellItem->gNB_DU_System_Information, sizeof(GNB_DU_System_Information_t));
1543          }
1544
1545          DU_FREE(duServedCell->list.array[0], sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1546       }
1547       DU_FREE(duServedCell->list.array, plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t*));
1548    }
1549 }
1550
1551 /*******************************************************************
1552  *
1553  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1554  *
1555  * @details
1556  *
1557  *    Function :  FreeF1SetupReq
1558  *
1559  *    Functionality:  deallocating the memory of function BuildAndSendF1SetupReq
1560  *
1561  * @params[in] F1AP_PDU_t *f1apMsg
1562  *
1563  * @return void
1564  *
1565  * ****************************************************************/
1566 void FreeF1SetupReq(F1AP_PDU_t *f1apMsg)
1567 {
1568    uint8_t ieIdx, ieIdx2;
1569    F1SetupRequest_t *f1SetupReq=NULLP;
1570
1571    if(f1apMsg != NULLP)
1572    {
1573       if(f1apMsg->choice.initiatingMessage != NULLP)
1574       {
1575          f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1576          if(f1SetupReq->protocolIEs.list.array != NULLP)
1577          {
1578             for(ieIdx = 0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
1579             {
1580                if(f1SetupReq->protocolIEs.list.array[ieIdx] != NULLP)
1581                {
1582                   switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
1583                   {
1584                      case ProtocolIE_ID_id_TransactionID:
1585                         break;
1586                      case ProtocolIE_ID_id_gNB_DU_ID:
1587                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1588                               f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1589                         break;
1590                      case ProtocolIE_ID_id_gNB_DU_Name:
1591                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,\
1592                               strlen((char *)duCfgParam.duName));
1593                         break;
1594                      case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
1595                         FreeServedCellList(&f1SetupReq->protocolIEs.list.\
1596                               array[ieIdx]->value.choice.GNB_DU_Served_Cells_List);
1597                         break;
1598                      case ProtocolIE_ID_id_GNB_DU_RRC_Version:
1599                         FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version);
1600                         break;
1601                      default:
1602                         DU_LOG("\nERROR  -->  Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id);
1603                         break;
1604                   }
1605                }
1606             }
1607             for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++)
1608             {
1609                DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx2],sizeof(F1SetupRequestIEs_t));
1610             }
1611             DU_FREE(f1SetupReq->protocolIEs.list.array,\
1612                   f1SetupReq->protocolIEs.list.size);
1613          }
1614          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1615       }
1616       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1617    }
1618 }
1619 /*******************************************************************
1620  *
1621  * @brief Builds and Send the F1SetupRequest
1622  *
1623  * @details
1624  *
1625  *    Function : BuildAndSendF1SetupReq
1626  *
1627  * Functionality:Fills the F1SetupRequest
1628  *
1629  * @return ROK     - success
1630  *         RFAILED - failure
1631  *
1632  ******************************************************************/
1633 uint8_t BuildAndSendF1SetupReq()
1634 {
1635    uint8_t   ret, ieIdx, elementCnt;
1636    F1AP_PDU_t                 *f1apMsg = NULLP;
1637    F1SetupRequest_t           *f1SetupReq=NULLP;
1638    GNB_DU_Served_Cells_List_t *duServedCell=NULLP;
1639    RRC_Version_t              *rrcVer=NULLP;
1640    asn_enc_rval_t             encRetVal;        /* Encoder return value */
1641    ret= RFAILED;
1642
1643    DU_LOG("\nINFO   -->  F1AP : Building F1 Setup Request\n");
1644    do
1645    {
1646       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1647       if(f1apMsg == NULLP)
1648       {
1649          break;
1650       }
1651       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1652       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1653       if(f1apMsg->choice.initiatingMessage == NULLP)
1654       {
1655          break;
1656       }
1657       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_F1Setup;
1658       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
1659       f1apMsg->choice.initiatingMessage->value.present = \
1660                                                          InitiatingMessage__value_PR_F1SetupRequest;
1661
1662       f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1663
1664       elementCnt = (duCfgParam.duName != NULL) ? 5 : 4;
1665
1666       f1SetupReq->protocolIEs.list.count = elementCnt;
1667       f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t );
1668
1669       /* Initialize the F1Setup members */
1670       DU_ALLOC(f1SetupReq->protocolIEs.list.array,f1SetupReq->protocolIEs.list.size);
1671       if(f1SetupReq->protocolIEs.list.array == NULLP)
1672       {
1673          break;
1674       }
1675       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
1676       {
1677          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx],\
1678                sizeof(F1SetupRequestIEs_t));
1679          if(f1SetupReq->protocolIEs.list.array[ieIdx] == NULLP)
1680          {
1681             break;
1682          }
1683       }
1684
1685       ieIdx = 0;
1686       /*TransactionID*/
1687       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransactionID;
1688       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1689       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present =\
1690                                                                F1SetupRequestIEs__value_PR_TransactionID;
1691       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = \
1692                                                                              TRANS_ID;
1693
1694       /*DU ID*/
1695       ieIdx++;
1696       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
1697       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1698       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1699                                                                 F1SetupRequestIEs__value_PR_GNB_DU_ID;
1700       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size =\
1701                                                                              sizeof(uint8_t);
1702
1703       DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1704             f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1705       if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == \
1706             NULLP)
1707       {
1708          break;
1709       }
1710
1711       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] =\
1712          duCfgParam.duId;
1713
1714       /*DU Name*/
1715       if(duCfgParam.duName != NULL)
1716       {
1717          ieIdx++;
1718          f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_Name;
1719          f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
1720          f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = F1SetupRequestIEs__value_PR_GNB_DU_Name;
1721          f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.size =\
1722             strlen((char *)duCfgParam.duName);
1723          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.\
1724                GNB_DU_Name.buf, strlen((char *)duCfgParam.duName));
1725          if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.\
1726                buf == NULLP)
1727          {
1728             break;
1729          }
1730          strcpy((char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.\
1731                choice.GNB_DU_Name.buf,
1732                (char*)&duCfgParam.duName);
1733
1734       }
1735
1736       /*Served Cell list */
1737       ieIdx++;
1738       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1739                                                      ProtocolIE_ID_id_gNB_DU_Served_Cells_List;
1740       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1741       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1742                                                                 F1SetupRequestIEs__value_PR_GNB_DU_Served_Cells_List;
1743       duServedCell = &f1SetupReq->protocolIEs.list.\
1744                      array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
1745       if(BuildServedCellList(duServedCell))
1746       {
1747          break;
1748       }
1749       /*RRC Version*/
1750       ieIdx++;
1751       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1752                                                      ProtocolIE_ID_id_GNB_DU_RRC_Version ;
1753       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1754       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1755                                                                 F1SetupRequestIEs__value_PR_RRC_Version;
1756       rrcVer = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
1757       if(BuildRrcVer(rrcVer))
1758       {
1759          break;
1760       }
1761       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1762
1763       /* Encode the F1SetupRequest type as APER */
1764       memset(encBuf, 0, ENC_BUF_MAX_LEN);
1765       encBufSize = 0;
1766       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1767             encBuf);
1768
1769       /* Encode results */
1770       if(encRetVal.encoded == ENCODE_FAIL)
1771       {
1772          DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupRequest structure (at %s)\n",\
1773                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1774          break;
1775       }
1776       else
1777       {
1778          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1SetupRequest\n");
1779          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
1780          {
1781             printf("%x",encBuf[ieIdx]);
1782          }
1783       }
1784
1785       /* Sending msg */
1786       if(sendF1APMsg() != ROK)
1787       {
1788          DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup request failed");
1789          break;
1790       }
1791
1792       ret=ROK;
1793       break;
1794    }while(true);
1795
1796    FreeF1SetupReq(f1apMsg);
1797
1798    return ret;
1799 }/* End of BuildAndSendF1SetupReq */
1800
1801 /*******************************************************************
1802  *
1803  * @brief Deallocating memory allocated for Served_Cells_To_Modify_Item_t
1804  *
1805  * @details
1806  *
1807  *    Function : freeCellsToModifyItem
1808  *
1809  *    Functionality: Deallocating memory of variables allocated in
1810  *                    BuildAndSendDUConfigUpdate function
1811  *
1812  * @params[in]  Served_Cells_To_Modify_Item_t *modifyItem
1813  *
1814  * @return ROK     - void
1815  *
1816  * ****************************************************************/
1817
1818 void freeCellsToModifyItem(Served_Cells_To_Modify_Item_t *modifyItem)
1819 {
1820    uint8_t arrIdx=0, servedPlmnIdx=0, sliceLstIdx=0;
1821    ServedPLMNs_Item_t *servedPlmnItem = NULLP;
1822    SliceSupportItem_t *sliceSupportItem = NULLP;
1823
1824    DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf, modifyItem->oldNRCGI.pLMN_Identity.size);
1825    DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf, modifyItem->oldNRCGI.nRCellIdentity.size);
1826
1827    DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1828            modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
1829    DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1830          modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
1831
1832    if(modifyItem->served_Cell_Information.servedPLMNs.list.array != NULLP)
1833    {
1834       if(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx] != NULLP)
1835       {
1836          servedPlmnItem = modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx];
1837
1838          DU_FREE(servedPlmnItem->pLMN_Identity.buf,servedPlmnItem->pLMN_Identity.size);
1839
1840          if(servedPlmnItem->iE_Extensions != NULLP)
1841          {
1842             if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1843             {
1844                if(servedPlmnItem->iE_Extensions->list.array[arrIdx] != NULLP)
1845                {
1846                   if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1847                         list.array != NULLP)
1848                   {
1849                      for(sliceLstIdx =0; sliceLstIdx<servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
1850                            extensionValue.choice.SliceSupportList.list.count; sliceLstIdx++)
1851                      {
1852                         if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1853                               list.array[sliceLstIdx] != NULLP)
1854                         {
1855
1856                            sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1857                                               SliceSupportList.list.array[sliceLstIdx];
1858
1859                            DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sliceSupportItem->sNSSAI.sST.size);
1860                            if(sliceSupportItem->sNSSAI.sD != NULLP)
1861                            {
1862                               DU_FREE(sliceSupportItem->sNSSAI.sD->buf, sliceSupportItem->sNSSAI.sD->size);
1863                               DU_FREE(sliceSupportItem->sNSSAI.sD,sizeof(OCTET_STRING_t));
1864                            }
1865                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1866                                  SliceSupportList.list.array[sliceLstIdx], sizeof(SliceSupportItem_t));
1867                         }
1868                      }
1869                      DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.\
1870                            choice.SliceSupportList.list.array,\
1871                            servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
1872                            extensionValue.choice.SliceSupportList.list.size);
1873                   }
1874                }
1875                for(servedPlmnIdx=0; servedPlmnIdx< servedPlmnItem->iE_Extensions->list.count ; servedPlmnIdx++)
1876                {
1877                   DU_FREE(servedPlmnItem->iE_Extensions->list.array[servedPlmnIdx], sizeof(ServedPLMNs_ItemExtIEs_t ));
1878                }
1879                DU_FREE(servedPlmnItem->iE_Extensions->list.array, servedPlmnItem->iE_Extensions->list.size);
1880             }
1881             DU_FREE(servedPlmnItem->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1882          }
1883       }
1884       for(servedPlmnIdx=0; servedPlmnIdx<modifyItem->served_Cell_Information.servedPLMNs.list.count; servedPlmnIdx++)
1885       {
1886          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[servedPlmnIdx], sizeof(ServedPLMNs_Item_t));
1887       }
1888       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1889          modifyItem->served_Cell_Information.servedPLMNs.list.size);
1890    }
1891
1892    if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD != NULLP)
1893    {
1894       if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1895       {
1896          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
1897                array[arrIdx], sizeof(FreqBandNrItem_t));
1898          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array, \
1899                modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1900       }
1901
1902       if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1903       {
1904          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.\
1905              array[arrIdx], sizeof(FreqBandNrItem_t));
1906          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,\
1907                modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1908       }
1909       DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD,sizeof(FDD_Info_t));
1910    }
1911
1912    DU_FREE(modifyItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1913       modifyItem->served_Cell_Information.measurementTimingConfiguration.size);
1914 }
1915
1916 /*******************************************************************
1917  *
1918  * @brief Deallocating memory of BuildAndSendDUConfigUpdate
1919  *
1920  * @details
1921  *
1922  *    Function : FreeDUConfigUpdate
1923  *
1924  *    Functionality: Deallocating memory of variables allocated in
1925  *                    BuildAndSendDUConfigUpdate function
1926  *
1927  * @params[in]  F1AP_PDU_t *f1apDuCfg
1928  *
1929  * @return ROK     - void
1930  *
1931  * ****************************************************************/
1932 void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg)
1933 {
1934    uint8_t  ieIdx=0, cellModifyIdx=0, cellDeleteIdx=0;
1935    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
1936    Served_Cells_To_Modify_List_t  *cellsToModify=NULLP;
1937    Served_Cells_To_Delete_List_t  *cellsToDelete=NULLP;
1938    Served_Cells_To_Delete_Item_t  *deleteItem = NULLP;
1939    Served_Cells_To_Delete_ItemIEs_t *deleteItemIe = NULLP;
1940
1941    if(f1apDuCfg != NULLP)
1942    {
1943       if(f1apDuCfg->choice.initiatingMessage != NULLP)
1944       {
1945          duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->\
1946                        value.choice.GNBDUConfigurationUpdate;
1947          if(duCfgUpdate->protocolIEs.list.array != NULLP)
1948          {
1949             for(ieIdx=0; ieIdx<duCfgUpdate->protocolIEs.list.count; ieIdx++)
1950             {
1951                if(duCfgUpdate->protocolIEs.list.array[ieIdx] != NULLP)
1952                {
1953                   switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
1954                   {
1955                      case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
1956                         {
1957                            cellsToModify = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1958                                            value.choice.Served_Cells_To_Modify_List;
1959                            if(cellsToModify->list.array != NULLP)
1960                            {
1961                               for(cellModifyIdx=0; cellModifyIdx<cellsToModify->list.count ;cellModifyIdx++)
1962                               {
1963                                  if(cellsToModify->list.array[cellModifyIdx] != NULLP)
1964                                  {
1965                                     freeCellsToModifyItem(&cellsToModify->list.array[cellModifyIdx]->value.choice.\
1966                                           Served_Cells_To_Modify_Item);
1967                                     DU_FREE(cellsToModify->list.array[cellModifyIdx],\
1968                                           sizeof(Served_Cells_To_Modify_ItemIEs_t));
1969                                  }
1970                               }
1971                               DU_FREE(cellsToModify->list.array,cellsToModify->list.size);
1972                            }
1973                            break;
1974                         }
1975                      case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
1976                         {
1977                            cellsToDelete = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1978                                            value.choice.Served_Cells_To_Delete_List;
1979                            if(cellsToDelete->list.array != NULLP)
1980                            {
1981                               for(cellDeleteIdx=0; cellDeleteIdx<cellsToDelete->list.count ;cellDeleteIdx++)
1982                               {
1983                                  if(cellsToDelete->list.array[cellDeleteIdx] != NULLP)
1984                                  {
1985                                     deleteItemIe = ((Served_Cells_To_Delete_ItemIEs_t*)\
1986                                           cellsToDelete->list.array[cellDeleteIdx]);
1987                                     deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
1988                                     DU_FREE(deleteItem->oldNRCGI.pLMN_Identity.buf,\
1989                                           deleteItem->oldNRCGI.pLMN_Identity.size);
1990                                     DU_FREE(deleteItem->oldNRCGI.nRCellIdentity.buf,\
1991                                           deleteItem->oldNRCGI.nRCellIdentity.size);
1992                                     DU_FREE(cellsToDelete->list.array[cellDeleteIdx],\
1993                                           sizeof(Served_Cells_To_Delete_ItemIEs_t));
1994                                  }
1995                               }
1996                               DU_FREE(cellsToDelete->list.array,cellsToDelete->list.size);
1997                            }
1998
1999                            break;
2000                         }
2001                      case ProtocolIE_ID_id_gNB_DU_ID:
2002                         {
2003                            DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2004                                  duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2005                            break;
2006                         }
2007                   }
2008                   DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx],\
2009                         sizeof(GNBDUConfigurationUpdateIEs_t));
2010                }
2011             }
2012             DU_FREE(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2013          }
2014          DU_FREE(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2015       }
2016       DU_FREE(f1apDuCfg, (Size)sizeof(F1AP_PDU_t));
2017    }
2018 }
2019
2020 /*******************************************************************
2021  *
2022  * @brief Fills Served Plmns required in ServCellInfo IE
2023  *
2024  * @details
2025  *
2026  *    Function : fillServedPlmns
2027  *
2028  *    Functionality: Fills Served Plmns required in ServCellInfo IE
2029  *
2030  * @params[in] Pointer to ServedPLMNs_List_t *
2031  *
2032  * @return ROK     - success
2033  *         RFAILED - failure
2034  *
2035  *****************************************************************/
2036
2037 uint8_t fillServedPlmns(ServedPLMNs_List_t *servedPlmn)
2038 {
2039    uint8_t ieIdx=0, arrayIdx=0, ieListCnt=0, elementCnt=0, sliceLstIdx=0;
2040
2041    servedPlmn->list.array[arrayIdx]->pLMN_Identity.size = 3*sizeof(uint8_t);
2042    DU_ALLOC(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf, servedPlmn->list.\
2043          array[arrayIdx]->pLMN_Identity.size);
2044    if(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf == NULLP)
2045    {
2046       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2047       return RFAILED;
2048    }
2049    buildPlmnId(duCfgParam.srvdCellLst[arrayIdx].duCellInfo.cellInfo.srvdPlmn[arrayIdx].plmn,\
2050          servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf);
2051    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
2052    if(servedPlmn->list.array[arrayIdx]->iE_Extensions == NULLP)
2053    {
2054       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2055       return RFAILED;
2056    }
2057
2058    ieListCnt=1;
2059    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.count = ieListCnt;
2060    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.size = ieListCnt *sizeof(ServedPLMNs_ItemExtIEs_t *);
2061    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array,servedPlmn->list.array[arrayIdx]->\
2062          iE_Extensions->list.size);
2063    if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array == NULLP)
2064    {
2065       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2066       return RFAILED;
2067    }
2068    for(ieIdx=arrayIdx;ieIdx<ieListCnt;ieIdx++)
2069    {
2070       DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx],\
2071             sizeof(ServedPLMNs_ItemExtIEs_t));
2072       if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx] == NULLP)
2073       {
2074          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2075          return RFAILED;
2076       }
2077    }
2078
2079    ieIdx = 0;
2080    elementCnt = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].taiSliceSuppLst.numSupportedSlices;
2081    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->id =ProtocolIE_ID_id_TAISliceSupportList;
2082    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->criticality = Criticality_ignore;
2083    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.present = \
2084    ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
2085    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2086       list.count = elementCnt;
2087    servedPlmn->list.array[arrayIdx]->\
2088       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2089       list.size = elementCnt * sizeof(SliceSupportItem_t *);
2090    DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2091          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2092          list.array,servedPlmn->list.array[arrayIdx]->\
2093          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.size);
2094    if(servedPlmn->list.array[arrayIdx]->\
2095          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2096          list.array == NULLP)
2097    {
2098       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2099       return RFAILED;
2100    }
2101
2102    for(sliceLstIdx =0; sliceLstIdx< elementCnt; sliceLstIdx++)
2103    {
2104       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2105       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2106       list.array[sliceLstIdx],sizeof( SliceSupportItem_t));
2107       if(servedPlmn->list.array[arrayIdx]->\
2108       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2109       list.array[sliceLstIdx] == NULLP)
2110       {
2111          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2112          return RFAILED;
2113       }
2114
2115       servedPlmn->list.array[arrayIdx]->\
2116       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2117       list.array[sliceLstIdx]->sNSSAI.sST.size = sizeof(uint8_t);
2118       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2119       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2120       list.array[sliceLstIdx]->sNSSAI.sST.buf,servedPlmn->list.array[arrayIdx]->\
2121       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->\
2122       sNSSAI.sST.size);
2123
2124       if(servedPlmn->list.array[arrayIdx]->\
2125       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2126       list.array[sliceLstIdx]->sNSSAI.sST.buf == NULLP)
2127       {
2128          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2129          return RFAILED;
2130       }
2131       servedPlmn->list.array[arrayIdx]->\
2132       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2133       list.array[sliceLstIdx]->sNSSAI.sST.buf[arrayIdx] =  duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
2134       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
2135
2136       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2137       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2138       list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
2139       if(servedPlmn->list.array[arrayIdx]->\
2140       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2141       list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
2142       {
2143          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2144          return RFAILED;
2145       }
2146       servedPlmn->list.array[arrayIdx]->\
2147       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2148       list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
2149       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2150       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2151       list.array[sliceLstIdx]->sNSSAI.sD->buf,servedPlmn->list.array[arrayIdx]->\
2152       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2153       list.array[sliceLstIdx]->sNSSAI.sD->size);
2154       if(servedPlmn->list.array[arrayIdx]->\
2155       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2156       list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
2157       {
2158          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2159          return RFAILED;
2160       }
2161       memcpy(servedPlmn->list.array[arrayIdx]->\
2162       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2163       list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
2164       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sd,\
2165       servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2166       list.array[sliceLstIdx]->sNSSAI.sD->size);
2167    }
2168    return ROK;
2169 }
2170
2171 /*******************************************************************
2172  *
2173  * @brief Fills Nr Fdd Info required in ServCellInfo IE
2174  *
2175  * @details
2176  *
2177  *    Function : fillNrFddInfo
2178  *
2179  *    Functionality: Fills Nr Fdd Info required in ServCellInfo IE
2180  *
2181  * @params[in] Pointer to NR_Mode_Info_t *
2182  *
2183  * @return ROK     - success
2184  *         RFAILED - failure
2185  *
2186  *****************************************************************/
2187
2188 uint8_t fillNrFddInfo(NR_Mode_Info_t *nrFdd)
2189 {
2190    nrFdd->choice.fDD->uL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.\
2191       f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn;
2192    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.count = 1;
2193    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t*);
2194    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
2195          array, nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size);
2196    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2197    {
2198       return RFAILED;
2199    }
2200    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0], \
2201       sizeof(FreqBandNrItem_t));
2202    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2203    {
2204       return RFAILED;
2205    }
2206    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2207       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
2208       freqBand[0].nrFreqBand;
2209    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2210    nrFdd->choice.fDD->dL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.\
2211       dlNrFreqInfo.nrArfcn;
2212    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.count = 1;
2213    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
2214    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,nrFdd->\
2215          choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
2216    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2217    {
2218       return RFAILED;
2219    }
2220    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0],\
2221          sizeof(FreqBandNrItem_t));
2222    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2223    {
2224       return RFAILED;
2225    }
2226    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2227       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
2228       freqBand[0].nrFreqBand;
2229    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2230
2231    /*Transmission Bandwidth*/
2232    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2233       f1Mode.mode.fdd.ulTxBw.nrScs;
2234    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2235       f1Mode.mode.fdd.ulTxBw.nrb;
2236    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2237       f1Mode.mode.fdd.dlTxBw.nrScs;
2238    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2239       f1Mode.mode.fdd.dlTxBw.nrb;
2240
2241    return ROK;
2242 }
2243
2244 /*******************************************************************
2245  *
2246  * @brief Fills ServCellInfo IE
2247  *
2248  * @details
2249  *
2250  *    Function : fillServedCellInfo
2251  *
2252  *    Functionality: Fills ServCellInfo
2253  *
2254  * @params[in] Pointer to Served_Cell_Information_t *
2255  *
2256  * @return ROK     - success
2257  *         RFAILED - failure
2258  *
2259  *****************************************************************/
2260
2261 uint8_t fillServedCellInfo(Served_Cell_Information_t *srvCellInfo)
2262 {
2263    uint8_t tmp, ieIdx, ieListCnt;
2264
2265    /*nRCGI*/
2266    srvCellInfo->nRCGI.pLMN_Identity.size =3*sizeof(uint8_t);
2267    DU_ALLOC(srvCellInfo->nRCGI.pLMN_Identity.buf,\
2268          srvCellInfo->nRCGI.pLMN_Identity.size);
2269    if(srvCellInfo->nRCGI.pLMN_Identity.buf == NULLP)
2270    {
2271       return RFAILED;
2272    }
2273    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2274          srvCellInfo->nRCGI.pLMN_Identity.buf);
2275    srvCellInfo->nRCGI.nRCellIdentity.size =5*sizeof(uint8_t);
2276    DU_ALLOC(srvCellInfo->nRCGI.nRCellIdentity.buf,\
2277          srvCellInfo->nRCGI.nRCellIdentity.size);
2278    if(srvCellInfo->nRCGI.nRCellIdentity.buf == NULLP)
2279    {
2280       return RFAILED;
2281    }
2282    for (tmp = 0 ; tmp < srvCellInfo->\
2283          nRCGI.nRCellIdentity.size-1 ; tmp++)
2284    {
2285       srvCellInfo->nRCGI.nRCellIdentity.buf[tmp] = 0;
2286    }
2287    srvCellInfo->nRCGI.nRCellIdentity.buf[4] = 16;
2288    srvCellInfo->nRCGI.nRCellIdentity.bits_unused =4;
2289
2290    /*nRPCI*/
2291    srvCellInfo->nRPCI = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
2292
2293    /*servedPLMNs*/
2294    ieListCnt = 1;
2295    srvCellInfo->servedPLMNs.list.count = ieListCnt;
2296    srvCellInfo->servedPLMNs.list.size = ieListCnt*sizeof(ServedPLMNs_Item_t *);
2297    DU_ALLOC(srvCellInfo->servedPLMNs.list.array,\
2298          srvCellInfo->servedPLMNs.list.size);
2299    if(srvCellInfo->servedPLMNs.list.array == NULLP)
2300    {
2301       return RFAILED;
2302    }
2303    for(ieIdx=0; ieIdx < ieListCnt; ieIdx++)
2304    {
2305       DU_ALLOC(srvCellInfo->servedPLMNs.list.array[ieIdx],\
2306             sizeof(ServedPLMNs_Item_t));
2307       if(srvCellInfo->servedPLMNs.list.array[ieIdx]== NULLP)
2308       {
2309          return RFAILED;
2310       }
2311    }
2312    if(fillServedPlmns(&srvCellInfo->servedPLMNs))
2313    {
2314       return RFAILED;
2315    }
2316
2317    /*nR Mode Info with FDD*/
2318    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_fDD;
2319    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.fDD,\
2320          sizeof(FDD_Info_t));
2321    if(srvCellInfo->nR_Mode_Info.choice.fDD == NULLP)
2322    {
2323       return RFAILED;
2324    }
2325    if(fillNrFddInfo(&srvCellInfo->nR_Mode_Info))
2326       return RFAILED;
2327
2328    /*Measurement timing Config*/
2329    srvCellInfo->measurementTimingConfiguration.size = sizeof(uint8_t);
2330    DU_ALLOC(srvCellInfo->measurementTimingConfiguration.\
2331          buf,srvCellInfo->measurementTimingConfiguration.size);
2332    if(srvCellInfo->measurementTimingConfiguration.buf == NULLP)
2333    {
2334       return RFAILED;
2335    }
2336    srvCellInfo->measurementTimingConfiguration.\
2337          buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
2338
2339    return ROK;
2340 }
2341
2342 /*******************************************************************
2343  *
2344  * @brief Fills ServCellToModItem IE
2345  *
2346  * @details
2347  *
2348  *    Function : fillServCellToModItem
2349  *
2350  *    Functionality: Fills ServCellToModItem IE
2351  *
2352  * @params[in] Pointer to Served_Cells_To_Modify_Item_t *
2353  *
2354  * @return ROK     - success
2355  *         RFAILED - failure
2356  *
2357  *****************************************************************/
2358
2359 uint8_t fillServCellToModItem(Served_Cells_To_Modify_Item_t *modifyItem)
2360 {
2361    uint8_t ieIdx;
2362
2363    /*pLMN_Identity*/
2364    modifyItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2365    DU_ALLOC(modifyItem->oldNRCGI.pLMN_Identity.buf,modifyItem->oldNRCGI.pLMN_Identity.size);
2366    if(modifyItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2367    {
2368       return RFAILED;
2369    }
2370    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2371          modifyItem->oldNRCGI.pLMN_Identity.buf);
2372
2373    /*nRCellIdentity*/
2374    modifyItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2375    DU_ALLOC(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2376          modifyItem->oldNRCGI.nRCellIdentity.size);
2377    if(modifyItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2378    {
2379       return RFAILED;
2380    }
2381    for(ieIdx = 0; ieIdx < modifyItem->oldNRCGI.nRCellIdentity.size-1; ieIdx++)
2382    {
2383       modifyItem->oldNRCGI.nRCellIdentity.buf[ieIdx] = 0;
2384    }
2385    modifyItem->oldNRCGI.nRCellIdentity.buf[4] = 16;
2386    modifyItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
2387
2388    if(fillServedCellInfo(&modifyItem->served_Cell_Information))
2389       return RFAILED;
2390    else
2391       return ROK;
2392 }
2393
2394 /*******************************************************************
2395  *
2396  * @brief Builds ServCellToModList
2397  *
2398  * @details
2399  *
2400  *    Function : buildServCellToModList
2401  *
2402  *    Functionality: Builds the serv cell to Mod List
2403  *
2404  * @params[in] Pointer to Served_Cells_To_Modify_List_t *
2405  *
2406  * @return ROK     - success
2407  *         RFAILED - failure
2408  *
2409  *****************************************************************/
2410
2411 uint8_t buildServCellToModList(Served_Cells_To_Modify_List_t *cellsToModify)
2412 {
2413    uint8_t ieListCnt, ieIdx;
2414    Served_Cells_To_Modify_Item_t *modifyItem = NULLP;
2415
2416    ieListCnt = 1;
2417    cellsToModify->list.count = ieListCnt;
2418    cellsToModify->list.size = ieListCnt*sizeof(Served_Cells_To_Modify_ItemIEs_t *);
2419    DU_ALLOC(cellsToModify->list.array,cellsToModify->list.size);
2420    if(cellsToModify->list.array == NULLP)
2421    {
2422       return RFAILED;
2423    }
2424    for(ieIdx=0; ieIdx< ieListCnt; ieIdx++)
2425    {
2426       DU_ALLOC(cellsToModify->list.array[ieIdx],sizeof(Served_Cells_To_Modify_ItemIEs_t));
2427       if(cellsToModify->list.array[ieIdx] == NULLP)
2428       {
2429          return RFAILED;
2430       }
2431    }
2432    cellsToModify->list.array[0]->id = ProtocolIE_ID_id_Served_Cells_To_Modify_Item;
2433    cellsToModify->list.array[0]->criticality = Criticality_reject;
2434    cellsToModify->list.array[0]->value.present =\
2435       Served_Cells_To_Modify_ItemIEs__value_PR_Served_Cells_To_Modify_Item;
2436    modifyItem=&cellsToModify->list.array[0]->value.choice.Served_Cells_To_Modify_Item;
2437
2438    if(fillServCellToModItem(modifyItem))
2439       return RFAILED;
2440    else
2441       return ROK;
2442 }
2443 /*******************************************************************
2444  *
2445  * @brief filling the DeleteItemList
2446  *
2447  * @details
2448  *
2449  *    Function : fillCellToDeleteItem
2450  *
2451  *    Functionality: Filling the DeleteItemIe
2452  *
2453  * @params[in] Pointer to Served_Cells_To_Delete_ItemIEs_t
2454  *
2455  * @return ROK     - success
2456  *         RFAILED - failure
2457  *
2458  *****************************************************************/
2459 uint8_t fillCellToDeleteItem(struct Served_Cells_To_Delete_ItemIEs *deleteItemIe)
2460 {
2461    uint8_t arrIdx;
2462    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
2463
2464    deleteItemIe->id = ProtocolIE_ID_id_Served_Cells_To_Delete_Item;
2465    deleteItemIe->criticality = Criticality_reject;
2466    deleteItemIe->value.present =\
2467    Served_Cells_To_Delete_ItemIEs__value_PR_Served_Cells_To_Delete_Item;
2468    deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
2469
2470    /*pLMN_Identity*/
2471    deleteItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2472    DU_ALLOC(deleteItem->oldNRCGI.pLMN_Identity.buf,deleteItem->oldNRCGI.pLMN_Identity.size);
2473    if(deleteItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2474    {
2475       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2476       return RFAILED;
2477    }
2478    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2479          deleteItem->oldNRCGI.pLMN_Identity.buf);
2480
2481    /*nRCellIdentity*/
2482    deleteItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2483    DU_ALLOC(deleteItem->oldNRCGI.nRCellIdentity.buf,\
2484          deleteItem->oldNRCGI.nRCellIdentity.size);
2485    if(deleteItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2486    {
2487       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2488       return RFAILED;
2489    }
2490    for(arrIdx = 0; arrIdx < deleteItem->oldNRCGI.nRCellIdentity.size-1; arrIdx++)
2491    {
2492       deleteItem->oldNRCGI.nRCellIdentity.buf[arrIdx] = 0;
2493    }
2494    deleteItem->oldNRCGI.nRCellIdentity.buf[4] = 16;
2495    deleteItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
2496    return ROK;
2497 }
2498 /*******************************************************************
2499  *
2500  * @brief Builds ServCellToDeleteList
2501  *
2502  * @details
2503  *
2504  *    Function : buildServCellToDeleteList
2505  *
2506  *    Functionality: Builds the serv cell to delete List
2507  *
2508  * @params[in] Pointer to Served_Cells_To_Delete_List_t *
2509  *
2510  * @return ROK     - success
2511  *         RFAILED - failure
2512  *
2513  *****************************************************************/
2514
2515 uint8_t buildServCellToDeleteList(Served_Cells_To_Delete_List_t *cellsToDelete)
2516 {
2517    uint8_t ieListCnt, arrIdx;
2518
2519    ieListCnt = 1;
2520    cellsToDelete->list.count = ieListCnt;
2521    cellsToDelete->list.size = ieListCnt*sizeof(Served_Cells_To_Delete_ItemIEs_t *);
2522
2523    DU_ALLOC(cellsToDelete->list.array,cellsToDelete->list.size);
2524    if(cellsToDelete->list.array == NULLP)
2525    {
2526       DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2527       return RFAILED;
2528    }
2529
2530    for(arrIdx=0; arrIdx< ieListCnt; arrIdx++)
2531    {
2532       DU_ALLOC(cellsToDelete->list.array[arrIdx],sizeof(Served_Cells_To_Delete_ItemIEs_t));
2533       if(cellsToDelete->list.array[arrIdx] == NULLP)
2534       {
2535          DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2536          return RFAILED;
2537       }
2538    }
2539
2540    arrIdx=0;
2541    if(fillCellToDeleteItem((Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx]) !=ROK)
2542    {
2543       DU_LOG("\nERROR  -->  F1AP: buildServCellToDeleteList(): failed to fill Served_Cells_To_Delete_ItemIEs");
2544       return RFAILED;
2545    }
2546    return ROK;
2547 }
2548
2549 /*******************************************************************
2550  *
2551  * @brief Builds and sends the DUConfigUpdate
2552  *
2553  * @details
2554  *
2555  *    Function : BuildAndSendDUConfigUpdate
2556  *
2557  *    Functionality: Constructs the DU Update message and sends
2558  *                   it to the CU through SCTP.
2559  *
2560  * @params[in] void **buf,Buffer to which encoded pattern is written into
2561  * @params[in] int *size,size of buffer
2562  *
2563  * @return ROK     - success
2564  *         RFAILED - failure
2565  *
2566  * ****************************************************************/
2567 uint8_t BuildAndSendDUConfigUpdate(ServCellAction servCellAction)
2568 {
2569    uint8_t ret =0, ieIdx=0, elementCnt=0;
2570    bool memAlloctionFailure = false;
2571    F1AP_PDU_t                 *f1apDuCfg = NULLP;
2572    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
2573    asn_enc_rval_t encRetVal;     /* Encoder return value */
2574
2575    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2576    ret= RFAILED;
2577
2578    while(true)
2579    {
2580       DU_LOG("\nINFO   -->  F1AP : Building DU config update\n");
2581       /* Allocate the memory for F1DuCfg */
2582       DU_ALLOC(f1apDuCfg, sizeof(F1AP_PDU_t));
2583       if(f1apDuCfg == NULLP)
2584       {
2585          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2586          break;
2587       }
2588
2589       f1apDuCfg->present = F1AP_PDU_PR_initiatingMessage;
2590       DU_ALLOC(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2591       if(f1apDuCfg->choice.initiatingMessage == NULLP)
2592       {
2593          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2594          break;
2595       }
2596
2597       f1apDuCfg->choice.initiatingMessage->procedureCode = \
2598                                                            ProcedureCode_id_gNBDUConfigurationUpdate;
2599       f1apDuCfg->choice.initiatingMessage->criticality = Criticality_reject;
2600       f1apDuCfg->choice.initiatingMessage->value.present = \
2601                                                            InitiatingMessage__value_PR_GNBDUConfigurationUpdate;
2602       duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\
2603                     choice.GNBDUConfigurationUpdate;
2604       elementCnt = 3;
2605       duCfgUpdate->protocolIEs.list.count = elementCnt;
2606       duCfgUpdate->protocolIEs.list.size = \
2607                                            elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t*);
2608
2609       /* Initialize the F1Setup members */
2610       DU_ALLOC(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2611       if(duCfgUpdate->protocolIEs.list.array == NULLP)
2612       {
2613          DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2614          break;
2615       }
2616       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
2617       {
2618          DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx],sizeof(GNBDUConfigurationUpdateIEs_t));
2619          if(duCfgUpdate->protocolIEs.list.array[ieIdx] == NULLP)
2620          {
2621             DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2622             memAlloctionFailure = true;
2623             break;
2624          }
2625       }
2626
2627       if(memAlloctionFailure == true)
2628       {
2629          break;
2630       }
2631       /*TransactionID*/
2632       ieIdx = 0;
2633       duCfgUpdate->protocolIEs.list.array[ieIdx]->id=ProtocolIE_ID_id_TransactionID;
2634       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
2635       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2636       GNBDUConfigurationUpdateIEs__value_PR_TransactionID;
2637       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = TRANS_ID;
2638
2639       ieIdx++;
2640       if(servCellAction == SERV_CELL_TO_MODIFY)
2641       {
2642          /*Served Cell to Modify */
2643          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2644          ProtocolIE_ID_id_Served_Cells_To_Modify_List;
2645          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2646          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2647          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Modify_List;
2648          if(buildServCellToModList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2649                   Served_Cells_To_Modify_List))
2650          {
2651             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToModList");
2652             break;
2653          }
2654       }
2655       else
2656       {
2657          /*Served Cell to Delete */
2658          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2659          ProtocolIE_ID_id_Served_Cells_To_Delete_List;
2660          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2661          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2662          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Delete_List;
2663          if(buildServCellToDeleteList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2664          Served_Cells_To_Delete_List)!=ROK)
2665          {
2666             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToDeleteList");
2667             break;
2668          }
2669
2670       }
2671       // NOTE :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
2672       /*GNB DU ID */
2673       ieIdx++;
2674       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
2675       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
2676       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2677       GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID;
2678       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size = sizeof(uint8_t);
2679       DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2680             duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2681       if(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == NULLP)
2682       {
2683          DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): Memory allocation failed for GNB_DU_ID");
2684          break;
2685       }
2686       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] = duCfgParam.duId;
2687
2688       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
2689
2690       /* Encode the DU Config Update type as APER */
2691       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
2692       encBufSize = 0;
2693       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
2694
2695       /* Checking encode results */
2696       if(encRetVal.encoded == ENCODE_FAIL)
2697       {
2698          DU_LOG("ERROR  -->  F1AP : Could not encode DUConfigUpdate structure (at %s)\n",\
2699                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2700          break;
2701       }
2702       else
2703       {
2704          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DUConfigUpdate\n");
2705          for(ieIdx =0; ieIdx < encBufSize; ieIdx++)
2706          {
2707             printf("%x",encBuf[ieIdx]);
2708          }
2709       }
2710       /* Sending msg */
2711       if(sendF1APMsg() != ROK)
2712       {
2713          DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update failed");
2714          break;
2715       }
2716
2717       ret = ROK;
2718       break;
2719    }
2720
2721    addToReservedF1apPduList(TRANS_ID,f1apDuCfg);
2722    return ret;
2723 }
2724
2725
2726 /*******************************************************************
2727  *
2728  * @brief free the ULRRCMessageTransfer
2729  *
2730  * @details
2731  *
2732  *    Function : FreeULRRCMessageTransfer
2733  *
2734  *    Functionality: Deallocating the memory of variable allocated in
2735  *                      FreeULRRCMessageTransfer
2736  *
2737  * @params[in]
2738  *
2739  * @return ROK     - void
2740  *
2741  ******************************************************************/
2742 void FreeULRRCMessageTransfer( F1AP_PDU_t *f1apMsg)
2743 {
2744    uint8_t idx1;
2745    ULRRCMessageTransfer_t  *ulRRCMsg;
2746
2747    if(f1apMsg != NULLP)
2748    {
2749       if(f1apMsg->choice.initiatingMessage != NULLP)
2750       {
2751          ulRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2752          if(ulRRCMsg->protocolIEs.list.array != NULLP)
2753          {
2754             for(idx1=0;idx1<ulRRCMsg->protocolIEs.list.count;idx1++)
2755             {
2756                if(ulRRCMsg->protocolIEs.list.array[idx1] != NULLP)
2757                {
2758                   if(ulRRCMsg->protocolIEs.list.array[idx1]->value.present ==
2759                         ULRRCMessageTransferIEs__value_PR_RRCContainer)
2760                   {
2761                      DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2762                            ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2763                   }
2764                   DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1],sizeof(ULRRCMessageTransferIEs_t));
2765                }
2766             }
2767             DU_FREE(ulRRCMsg->protocolIEs.list.array,ulRRCMsg->protocolIEs.list.size );
2768          }
2769          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2770       }
2771       DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
2772    }
2773 }
2774 /*******************************************************************
2775  *
2776  * @brief Builds and sends the ULRRCMessageTransfer
2777  *
2778  * @details
2779  *
2780  *    Function : BuildAndSendULRRCMessageTransfer
2781  *
2782  *    Functionality: Constructs the UL RRC Message Transfer and sends
2783  *                   it to the CU through SCTP.
2784  *
2785  * @params[in]
2786  *
2787  * @return ROK     - success
2788  *         RFAILED - failure
2789  *
2790  * ****************************************************************/
2791 uint8_t BuildAndSendULRRCMessageTransfer(DuUeCb  ueCb, uint8_t lcId, \
2792       uint16_t msgLen, uint8_t *rrcMsg)
2793 {
2794    uint8_t   elementCnt =0;
2795    uint8_t   idx1 =0;
2796    uint8_t   idx =0;
2797    F1AP_PDU_t                   *f1apMsg = NULLP;
2798    ULRRCMessageTransfer_t       *ulRRCMsg = NULLP;
2799    asn_enc_rval_t               encRetVal;        /* Encoder return value */
2800    uint8_t ret =RFAILED;
2801
2802    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2803
2804    while(true)
2805    {
2806       DU_LOG("\n INFO   -->  F1AP : Building UL RRC Message Transfer Message\n");
2807
2808       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
2809       if(f1apMsg == NULLP)
2810       {
2811          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2812          break;
2813       }
2814       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
2815       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2816       if(f1apMsg->choice.initiatingMessage == NULLP)
2817       {
2818          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
2819          break;
2820       }
2821       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_ULRRCMessageTransfer;
2822       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
2823       f1apMsg->choice.initiatingMessage->value.present = \
2824                                                          InitiatingMessage__value_PR_ULRRCMessageTransfer;
2825       ulRRCMsg =
2826          &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2827       elementCnt = 4;
2828       ulRRCMsg->protocolIEs.list.count = elementCnt;
2829       ulRRCMsg->protocolIEs.list.size = \
2830                                         elementCnt * sizeof(ULRRCMessageTransferIEs_t *);
2831
2832       /* Initialize the F1Setup members */
2833       DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size);
2834       if(ulRRCMsg->protocolIEs.list.array == NULLP)
2835       {
2836          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
2837          break;
2838       }
2839       for(idx=0; idx<elementCnt; idx++)
2840       {
2841          DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t));
2842          if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP)
2843          {
2844             break;
2845          }
2846       }
2847
2848       idx1 = 0;
2849
2850       /*GNB CU UE F1AP ID*/
2851       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
2852       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2853       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2854                                                               ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
2855       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = ueCb.gnbCuUeF1apId;
2856
2857       /*GNB DU UE F1AP ID*/
2858       idx1++;
2859       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
2860       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2861       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2862                                                               ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
2863       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = ueCb.gnbDuUeF1apId;
2864
2865       /*SRBID*/
2866       idx1++;
2867       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
2868       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2869       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2870                                                               ULRRCMessageTransferIEs__value_PR_SRBID;
2871       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = lcId;
2872
2873       /*RRCContainer*/
2874       idx1++;
2875       ulRRCMsg->protocolIEs.list.array[idx1]->id  = ProtocolIE_ID_id_RRCContainer;
2876       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2877       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2878                                                               ULRRCMessageTransferIEs__value_PR_RRCContainer;
2879       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size = msgLen;
2880       DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2881             ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
2882       if(!ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
2883       {
2884          DU_LOG(" ERROR  -->  F1AP : Memory allocation for BuildAndSendULRRCMessageTransfer failed");
2885          break;
2886       }
2887       memset(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, 0, msgLen);
2888       memcpy(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, \
2889             rrcMsg, ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2890
2891       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2892
2893       /* Encode the F1SetupRequest type as APER */
2894       memset(encBuf, 0, ENC_BUF_MAX_LEN);
2895       encBufSize = 0;
2896       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
2897             encBuf);
2898       /* Encode results */
2899       if(encRetVal.encoded == ENCODE_FAIL)
2900       {
2901          DU_LOG( "\nERROR  -->  F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
2902                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2903          break;
2904       }
2905       else
2906       {
2907          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
2908          for(int i=0; i< encBufSize; i++)
2909          {
2910             printf("%x",encBuf[i]);
2911          }
2912       }
2913
2914       /* Sending  msg  */
2915       if(sendF1APMsg()  !=      ROK)
2916       {
2917          DU_LOG("\nERROR  -->   F1AP : Sending  UL RRC Message Transfer Failed");
2918          break;
2919       }
2920       ret = ROK;
2921       break;
2922    }
2923    FreeULRRCMessageTransfer(f1apMsg);
2924
2925    return ret;
2926 }/* End of BuildAndSendULRRCMessageTransfer*/
2927
2928 /*******************************************************************
2929  *
2930  * @brief Builds tag config
2931  *
2932  * @details
2933  *
2934  *    Function : BuildTagConfig
2935  *
2936  *    Functionality: Builds tag config in MacCellGroupConfig
2937  *
2938  * @params[in] TAG_Config *tag_Config
2939  *
2940  * @return ROK     - success
2941  *         RFAILED - failure
2942  *
2943  * ****************************************************************/
2944 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
2945 {
2946    struct TAG_Config__tag_ToAddModList *tagList;
2947    uint8_t                     idx, elementCnt;
2948
2949    tagConfig->tag_ToReleaseList = NULLP;
2950    tagConfig->tag_ToAddModList = NULLP;
2951    DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
2952    if(!tagConfig->tag_ToAddModList)
2953    {
2954       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2955       return RFAILED;
2956    }
2957
2958    elementCnt = 1; //ODU_VALUE_ONE;
2959    tagList = tagConfig->tag_ToAddModList;
2960    tagList->list.count = elementCnt;
2961    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
2962
2963    tagList->list.array = NULLP;
2964    DU_ALLOC(tagList->list.array, tagList->list.size);
2965    if(!tagList->list.array)
2966    {
2967       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2968       return RFAILED;
2969    }
2970
2971    for(idx=0; idx<tagList->list.count; idx++)
2972    {
2973       tagList->list.array[idx] = NULLP;
2974       DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
2975       if(!tagList->list.array[idx])
2976       {
2977          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2978          return RFAILED;
2979       }
2980    }
2981
2982    idx = 0;
2983    tagList->list.array[idx]->tag_Id = TAG_ID;
2984    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
2985
2986    return ROK;
2987 }
2988
2989 /*******************************************************************
2990  *
2991  * @brief Builds PHR Config
2992  *
2993  * @details
2994  *
2995  *    Function : BuildPhrConfig
2996  *
2997  *    Functionality: Builds phrConfig in MacCellGroupConfig
2998  *
2999  * @params[in] PHR Config *
3000  *
3001  * @return ROK     - success
3002  *         RFAILED - failure
3003  *
3004  * ****************************************************************/
3005 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
3006 {
3007
3008    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
3009    phrConfig->choice.setup = NULLP;
3010    DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
3011    if(!phrConfig->choice.setup)
3012    {
3013       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
3014       return RFAILED;
3015    }
3016
3017    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
3018    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
3019    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
3020    phrConfig->choice.setup->multiplePHR              = false;
3021    phrConfig->choice.setup->dummy                    = false;
3022    phrConfig->choice.setup->phr_Type2OtherCell       = false;
3023    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
3024
3025    return ROK;
3026 }
3027
3028 /*******************************************************************
3029  *
3030  * @brief Builds BSR Config
3031  *
3032  * @details
3033  *
3034  *    Function : BuildBsrConfig
3035  *
3036  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
3037  *
3038  * @params[in] BSR_Config *bsrConfig
3039  *
3040  * @return ROK     - success
3041  *         RFAILED - failure
3042  *
3043  * ****************************************************************/
3044 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
3045 {
3046    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
3047    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
3048    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
3049
3050    return ROK;
3051 }
3052
3053 /*******************************************************************
3054  *
3055  * @brief Builds scheduling request config
3056  *
3057  * @details
3058  *
3059  *    Function : BuildSchedulingReqConfig
3060  *
3061  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
3062  *
3063  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
3064  *
3065  * @return ROK     - success
3066  *         RFAILED - failure
3067  *
3068  * ****************************************************************/
3069 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
3070 {
3071    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
3072    uint8_t                     idx, elementCnt;
3073
3074    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
3075    DU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
3076          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
3077    if(!schedulingRequestConfig->schedulingRequestToAddModList)
3078    {
3079       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3080       return RFAILED;
3081    }
3082
3083    elementCnt = 1; //ODU_VALUE_ONE;
3084    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
3085    schReqList->list.count = elementCnt;
3086    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
3087
3088    schReqList->list.array = NULLP;
3089    DU_ALLOC(schReqList->list.array, schReqList->list.size);
3090    if(!schReqList->list.array)
3091    {
3092       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3093       return RFAILED;
3094    }
3095
3096    for(idx=0;idx<schReqList->list.count; idx++)
3097    {
3098       schReqList->list.array[idx] = NULLP;
3099       DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
3100       if(!schReqList->list.array[idx])
3101       {
3102          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3103          return RFAILED;
3104       }
3105    }
3106
3107    idx = 0;
3108    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
3109
3110    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
3111    DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
3112    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
3113    {
3114       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3115       return RFAILED;
3116    }
3117    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
3118    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
3119    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
3120
3121    return ROK;
3122 }
3123
3124 /*******************************************************************
3125  *
3126  * @brief Builds RLC Config
3127  *
3128  * @details
3129  *
3130  *    Function : BuildRlcConfig
3131  *
3132  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
3133  *
3134  * @params[in] RLC_Config *rlcConfig
3135  *
3136  * @return ROK     - success
3137  *         RFAILED - failure
3138  *
3139  * ****************************************************************/
3140 uint8_t BuildRlcConfig(struct RLC_Config *rlcConfig)
3141 {
3142
3143    rlcConfig->present = RLC_Config_PR_am;
3144
3145    rlcConfig->choice.am = NULLP;
3146    DU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
3147    if(!rlcConfig->choice.am)
3148    {
3149       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3150       return RFAILED;
3151    }
3152
3153    /* UL */
3154    rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
3155    DU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3156    if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
3157    {
3158       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3159       return RFAILED;
3160    }
3161    *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3162    rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
3163    rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
3164    rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
3165    rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
3166
3167    /* DL */
3168    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
3169    DU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3170    if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
3171    {
3172       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3173       return RFAILED;
3174    }
3175    *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3176    rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
3177    rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
3178
3179    return ROK;
3180 }
3181
3182 /*******************************************************************
3183  *
3184  * @brief Builds MAC LC Config
3185  *
3186  * @details
3187  *
3188  *    Function : BuildMacLCConfig
3189  *
3190  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
3191  *
3192  * @params[in] struct LogicalChannelConfig macLcConfig
3193  *
3194  * @return ROK     - success
3195  *         RFAILED - failure
3196  *
3197  * ****************************************************************/
3198 uint8_t BuildMacLCConfig(struct LogicalChannelConfig *macLcConfig)
3199 {
3200
3201    macLcConfig->ul_SpecificParameters = NULLP;
3202    DU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
3203    if(!macLcConfig->ul_SpecificParameters)
3204    {
3205       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3206       return RFAILED;
3207    }
3208
3209    macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
3210    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     PRIORTISIED_BIT_RATE;
3211    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     BUCKET_SIZE_DURATION;
3212    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
3213    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
3214    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
3215    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
3216
3217    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
3218    DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
3219    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
3220    {
3221       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3222       return RFAILED;
3223    }
3224    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
3225
3226    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
3227    DU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
3228    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
3229    {
3230       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3231       return RFAILED;
3232    }
3233    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
3234
3235    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
3236    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
3237    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
3238
3239    return ROK;
3240 }
3241
3242 /*******************************************************************
3243  *
3244  * @brief Builds RLC Bearer to Add/Mod list
3245  *
3246  * @details
3247  *
3248  *    Function :BuildRlcBearerToAddModList
3249  *
3250  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
3251  *
3252  * @params[in] rlc_BearerToAddModList
3253  *
3254  * @return ROK     - success
3255  *         RFAILED - failure
3256  *
3257  * ****************************************************************/
3258 uint8_t BuildRlcBearerToAddModList(struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
3259 {
3260    uint8_t                     idx, elementCnt;
3261
3262    elementCnt = 1;
3263    rlcBearerList->list.count = elementCnt;
3264    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
3265
3266    rlcBearerList->list.array = NULLP;
3267    DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
3268    if(!rlcBearerList->list.array)
3269    {
3270       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3271       return RFAILED;
3272    }
3273
3274    for(idx=0; idx<rlcBearerList->list.count; idx++)
3275    {
3276       rlcBearerList->list.array[idx] = NULLP;
3277       DU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
3278       if(!rlcBearerList->list.array[idx])
3279       {
3280          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3281          return RFAILED;
3282       }
3283    }
3284
3285    idx = 0;
3286    rlcBearerList->list.array[idx]->logicalChannelIdentity = SRB1_LCID;
3287
3288    DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, \
3289       sizeof(struct RLC_BearerConfig__servedRadioBearer));
3290    if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3291    {
3292       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3293       return RFAILED;
3294    }
3295
3296    rlcBearerList->list.array[idx]->servedRadioBearer->present = \
3297       RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
3298    rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = \
3299       SRB1_LCID;
3300
3301    rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3302    rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3303    DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3304    if(!rlcBearerList->list.array[idx]->rlc_Config)
3305    {
3306       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3307       return RFAILED;
3308    }
3309
3310    if(BuildRlcConfig(rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3311    {
3312       DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3313       return RFAILED;
3314    }
3315
3316    rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3317    DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, \
3318       sizeof(struct LogicalChannelConfig));
3319    if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3320    {
3321       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3322       return RFAILED;
3323    }
3324
3325    if(BuildMacLCConfig(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3326    {
3327       DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3328       return RFAILED;
3329    }
3330
3331    return ROK;
3332 }
3333
3334 /*******************************************************************
3335  *
3336  * @brief Build Control resource set to add/modify list
3337  *
3338  * @details
3339  *
3340  *    Function : BuildControlRSetToAddModList
3341  *
3342  *    Functionality: Build Control resource set to add/modify list
3343  *
3344  * @params[in]
3345  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3346  *
3347  * @return ROK     - success
3348  *         RFAILED - failure
3349  *
3350  * ****************************************************************/
3351    uint8_t BuildControlRSetToAddModList
3352 (
3353  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3354  )
3355 {
3356    uint8_t idx;
3357    uint8_t elementCnt;
3358    uint8_t numBytes, bitsUnused;
3359    struct ControlResourceSet *controlRSet;
3360    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3361    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3362
3363
3364    elementCnt = 1;
3365    controlRSetList->list.count = elementCnt;
3366    controlRSetList->list.size = \
3367                                 elementCnt * sizeof(struct ControlResourceSet *);
3368
3369    controlRSetList->list.array = NULLP;
3370    DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3371    if(!controlRSetList->list.array)
3372    {
3373       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3374       return RFAILED;
3375    }
3376
3377    for(idx = 0; idx < elementCnt; idx++)
3378    {
3379       controlRSetList->list.array[idx] = NULLP;
3380       DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3381       if(!controlRSetList->list.array[idx])
3382       {
3383          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3384          return RFAILED;
3385       }
3386    }
3387
3388    idx=0;
3389    controlRSet = controlRSetList->list.array[idx];
3390
3391    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3392
3393    /* size 6 bytes
3394     * 3 LSBs unsued
3395     * Bit string stored ff0000000000
3396     */
3397    numBytes = 6;
3398    bitsUnused = 3;
3399    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3400
3401    controlRSet->frequencyDomainResources.buf = NULLP;
3402    DU_ALLOC(controlRSet->frequencyDomainResources.buf, \
3403          controlRSet->frequencyDomainResources.size);
3404    if(!controlRSet->frequencyDomainResources.buf)
3405    {
3406       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3407       return RFAILED;
3408    }
3409
3410    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3411    coreset0EndPrb = CORESET0_END_PRB;
3412    coreset1StartPrb = coreset0EndPrb + 6;
3413    coreset1NumPrb = CORESET1_NUM_PRB;
3414    /* calculate the PRBs */
3415    freqDomRscAllocType0(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3416    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3417    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3418
3419    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3420    controlRSet->cce_REG_MappingType.present = \
3421                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3422
3423    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3424    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3425    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3426    controlRSet->tci_PresentInDCI = NULLP;
3427 #if 0
3428    uint8_t tciStateIdx;
3429
3430    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3431          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3432    if(!controlRset->tci_StatesPDCCH_ToAddList)
3433    {
3434       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3435       return RFAILED;
3436    }
3437
3438    elementCnt = 1;
3439    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3440    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3441    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3442          controlRset->tci_StatesPDCCH_ToAddList->list.size)
3443       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3444       {
3445          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3446          return RFAILED;
3447       }
3448
3449    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3450    {
3451       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3452       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3453       {
3454          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3455          return RFAILED;
3456       }
3457    }
3458
3459    tciStateIdx = 0;
3460    /* TODO */
3461    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3462
3463    DU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3464    if(!controlRset->tci_PresentInDCI)
3465    {
3466       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3467       return RFAILED;
3468    }
3469    /* TODO */
3470    *(controlRset->tci_PresentInDCI);
3471 #endif
3472
3473    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3474    DU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3475    if(!controlRSet->pdcch_DMRS_ScramblingID)
3476    {
3477       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3478       return RFAILED;
3479    }
3480    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3481
3482    return ROK;
3483 } /* End BuildControlRSetToAddModList */
3484
3485 /*******************************************************************
3486  *
3487  * @brief Build search space to add/modify list
3488  *
3489  * @details
3490  *
3491  *    Function : BuildSearchSpcToAddModList
3492  *
3493  *    Functionality: Build search space to add/modify list
3494  *
3495  * @params[in]
3496  * @return ROK     - success
3497  *         RFAILED - failure
3498  *
3499  * ****************************************************************/
3500    uint8_t BuildSearchSpcToAddModList
3501 (
3502  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
3503  )
3504 {
3505    uint8_t idx;
3506    uint8_t numBytes;
3507    uint8_t byteIdx;
3508    uint8_t bitsUnused;
3509    uint8_t elementCnt;
3510    struct SearchSpace *searchSpc;
3511
3512    elementCnt = 1;
3513    searchSpcList->list.count = elementCnt;
3514    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3515
3516    searchSpcList->list.array = NULLP;
3517    DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3518    if(!searchSpcList->list.array)
3519    {
3520       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3521       return RFAILED;
3522    }
3523
3524    for(idx = 0; idx < elementCnt; idx++)
3525    {
3526       searchSpcList->list.array[idx] = NULLP;
3527       DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3528       if(!searchSpcList->list.array[idx])
3529       {
3530          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3531          return RFAILED;
3532       }
3533    }
3534
3535    idx = 0;
3536    searchSpc = searchSpcList->list.array[idx];
3537
3538    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3539
3540    searchSpc->controlResourceSetId = NULLP;
3541    DU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3542    if(!searchSpc->controlResourceSetId)
3543    {
3544       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3545       return RFAILED;
3546    }
3547    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3548
3549    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3550    DU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
3551          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3552    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3553    {
3554       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3555       return RFAILED;
3556    }
3557    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
3558                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3559
3560    searchSpc->duration = NULLP;
3561    searchSpc->monitoringSymbolsWithinSlot = NULLP;
3562    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3563    if(!searchSpc->monitoringSymbolsWithinSlot)
3564    {
3565       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3566       return RFAILED;
3567    }
3568
3569    /* Values taken from reference logs :
3570     * size 2 bytes
3571     * 2 LSBs unsued
3572     * Bit string stores 8000
3573     */
3574    numBytes = 2;
3575    bitsUnused = 2;
3576
3577    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3578    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3579    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
3580          searchSpc->monitoringSymbolsWithinSlot->size);
3581    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3582    {
3583       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3584       return RFAILED;
3585    }
3586
3587    byteIdx = 0;
3588    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
3589                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3590    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3591    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3592
3593    searchSpc->nrofCandidates = NULLP;
3594    DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3595    if(!searchSpc->nrofCandidates)
3596    {
3597       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3598       return RFAILED;
3599    }
3600
3601    searchSpc->nrofCandidates->aggregationLevel1 = \
3602                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3603    searchSpc->nrofCandidates->aggregationLevel2 = \
3604                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3605    searchSpc->nrofCandidates->aggregationLevel4 = \
3606                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3607    searchSpc->nrofCandidates->aggregationLevel8 = \
3608                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3609    searchSpc->nrofCandidates->aggregationLevel16 = \
3610                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3611
3612    searchSpc->searchSpaceType = NULLP;
3613    DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3614    if(!searchSpc->searchSpaceType)
3615    {
3616       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3617       return RFAILED;
3618    }
3619
3620    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3621
3622    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3623    DU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
3624          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3625    if(!searchSpc->searchSpaceType->choice.ue_Specific)
3626    {
3627       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3628       return RFAILED;
3629    }
3630    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
3631                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3632
3633    return ROK;
3634 }/* End BuildSearchSpcToAddModList */
3635
3636 /*******************************************************************
3637  *
3638  * @brief Builds BWP DL dedicated PDCCH config
3639  *
3640  * @details
3641  *
3642  *    Function : BuildBWPDlDedPdcchCfg
3643  *
3644  *    Functionality: Builds BWP DL dedicated PDCCH config
3645  *
3646  * @params[in] struct PDCCH_Config *pdcchCfg
3647  *
3648  * @return ROK     - success
3649  *         RFAILED - failure
3650  *
3651  * ****************************************************************/
3652 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
3653 {
3654    pdcchCfg->controlResourceSetToAddModList = NULLP;
3655    DU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
3656          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3657    if(!pdcchCfg->controlResourceSetToAddModList)
3658    {
3659       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3660       return RFAILED;
3661    }
3662
3663    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
3664    {
3665       return RFAILED;
3666    }
3667
3668    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3669
3670    pdcchCfg->searchSpacesToAddModList = NULLP;
3671    DU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3672          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3673    if(!pdcchCfg->searchSpacesToAddModList)
3674    {
3675       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3676       return RFAILED;
3677    }
3678
3679    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3680    {
3681       return RFAILED;
3682    }
3683
3684    pdcchCfg->searchSpacesToReleaseList = NULLP;
3685    pdcchCfg->downlinkPreemption = NULLP;
3686    pdcchCfg->tpc_PUSCH = NULLP;
3687    pdcchCfg->tpc_PUCCH = NULLP;
3688    pdcchCfg->tpc_SRS = NULLP;
3689
3690    return ROK;
3691 }
3692
3693 /*******************************************************************
3694  *
3695  * @brief Builds DMRS DL PDSCH Mapping type A
3696  *
3697  * @details
3698  *
3699  *    Function : BuildDMRSDLPdschMapTypeA
3700  *
3701  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3702  *
3703  * @params[in]
3704  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3705  * @return ROK     - success
3706  *         RFAILED - failure
3707  *
3708  * ****************************************************************/
3709    uint8_t BuildDMRSDLPdschMapTypeA
3710 (
3711  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3712  )
3713 {
3714    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3715    dmrsDlCfg->choice.setup = NULLP;
3716    DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3717    if(!dmrsDlCfg->choice.setup)
3718    {
3719       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3720       return RFAILED;
3721    }
3722
3723    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3724    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3725    DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3726    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3727    {
3728       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3729       return RFAILED;
3730    }
3731    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3732
3733    dmrsDlCfg->choice.setup->maxLength = NULLP;
3734    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3735    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3736    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3737
3738    return ROK;
3739 }
3740
3741 /*******************************************************************
3742  *
3743  * @brief Builds TCI states to add/modify list
3744  *
3745  * @details
3746  *
3747  *    Function : BuildTCIStatesToAddModList
3748  *
3749  *    Functionality:Builds TCI states to add/modify list
3750  *
3751  * @params[in]
3752  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3753  *
3754  * @return ROK     - success
3755  *         RFAILED - failure
3756  *
3757  * ****************************************************************/
3758 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3759 {
3760    return ROK;
3761 }
3762
3763 /*******************************************************************
3764  *
3765  * @brief Builds PDSCH time domain allocation list
3766  *
3767  * @details
3768  *
3769  *    Function : BuildPdschTimeDomAllocList
3770  *
3771  *    Functionality: Builds PDSCH time domain allocation list
3772  *
3773  * @params[in]
3774  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3775  *
3776  * @return ROK     - success
3777  *         RFAILED - failure
3778  *
3779  * ****************************************************************/
3780    uint8_t BuildPdschTimeDomAllocList
3781 (
3782  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3783  )
3784 {
3785    uint8_t idx;
3786    uint8_t elementCnt;
3787    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3788
3789    timeDomAllocList->present = \
3790                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3791
3792    timeDomAllocList->choice.setup = NULLP;
3793    DU_ALLOC(timeDomAllocList->choice.setup, \
3794          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3795    if(!timeDomAllocList->choice.setup)
3796    {
3797       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3798       return RFAILED;
3799    }
3800
3801    elementCnt = 2;
3802    timeDomAllocList->choice.setup->list.count = elementCnt;
3803    timeDomAllocList->choice.setup->list.size = \
3804                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3805
3806    timeDomAllocList->choice.setup->list.array = NULLP;
3807    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3808          timeDomAllocList->choice.setup->list.size);
3809    if(!timeDomAllocList->choice.setup->list.array)
3810    {
3811       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3812       return RFAILED;
3813    }
3814
3815    for(idx = 0; idx < elementCnt; idx++)
3816    {
3817       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3818       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3819             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3820       if(!timeDomAllocList->choice.setup->list.array[idx])
3821       {
3822          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3823          return RFAILED;
3824       }
3825    }
3826
3827    idx = 0;
3828    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3829    DU_ALLOC(timeDomAlloc->k0, sizeof(long));
3830    if(!timeDomAlloc->k0)
3831    {
3832       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3833       return RFAILED;
3834    }
3835    *(timeDomAlloc->k0) = 0;
3836    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3837    timeDomAlloc->startSymbolAndLength = \
3838                                         calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
3839
3840    idx++;
3841    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3842    DU_ALLOC(timeDomAlloc->k0, sizeof(long));
3843    if(!timeDomAlloc->k0)
3844    {
3845       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3846       return RFAILED;
3847    }
3848    *(timeDomAlloc->k0) = 1;
3849    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3850    timeDomAlloc->startSymbolAndLength = calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
3851
3852    return ROK;
3853 }
3854
3855 /*******************************************************************
3856  *
3857  * @brief Builds PDSCH PRB Bundling type
3858  *
3859  * @details
3860  *
3861  *    Function : BuildPdschPrbBundlingType
3862  *
3863  *    Functionality: Builds PDSCH PRB Bundling type
3864  *
3865  * @params[in]
3866  * struct PDSCH_Config__prb_BundlingType *prbBndlType
3867  *
3868  * @return ROK     - success
3869  *         RFAILED - failure
3870  *
3871  * ****************************************************************/
3872    uint8_t BuildPdschPrbBundlingType
3873 (
3874  struct PDSCH_Config__prb_BundlingType *prbBndlType
3875  )
3876 {
3877    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
3878
3879    prbBndlType->choice.staticBundling = NULLP;
3880    DU_ALLOC(prbBndlType->choice.staticBundling, \
3881          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
3882    if(!prbBndlType->choice.staticBundling)
3883    {
3884       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
3885       return RFAILED;
3886    }
3887    prbBndlType->choice.staticBundling->bundleSize = NULLP;
3888
3889    return ROK;
3890 }
3891
3892 /*******************************************************************
3893  *
3894  * @brief Builds BWP DL dedicated PDSCH config
3895  *
3896  * @details
3897  *
3898  *    Function : BuildBWPDlDedPdschCfg
3899  *
3900  *    Functionality: Builds BWP DL dedicated PDSCH config
3901  *
3902  * @params[in] struct PDSCH_Config *pdschCfg
3903  *
3904  * @return ROK     - success
3905  *         RFAILED - failure
3906  *
3907  * ****************************************************************/
3908 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
3909 {
3910    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
3911
3912    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
3913    DU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
3914          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
3915    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
3916    {
3917       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3918       return RFAILED;
3919    }
3920
3921    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
3922    {
3923       return RFAILED;
3924    }
3925
3926    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
3927    pdschCfg->tci_StatesToAddModList = NULLP;
3928    pdschCfg->tci_StatesToReleaseList = NULLP;
3929    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
3930 #if 0
3931    DU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
3932    if(!pdschCfg->tci_StatesToAddModList)
3933    {
3934       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3935       return RFAILED;
3936    }
3937    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
3938    {
3939       return RFAILED;
3940    }
3941 #endif
3942
3943    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
3944
3945    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
3946    DU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
3947          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
3948    if(!pdschCfg->pdsch_TimeDomainAllocationList)
3949    {
3950       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3951       return RFAILED;
3952    }
3953
3954    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
3955    {
3956       return RFAILED;
3957    }
3958
3959    pdschCfg->pdsch_AggregationFactor = NULLP;
3960    pdschCfg->rateMatchPatternToAddModList = NULLP;
3961    pdschCfg->rateMatchPatternToReleaseList = NULLP;
3962    pdschCfg->rateMatchPatternGroup1 = NULLP;
3963    pdschCfg->rateMatchPatternGroup2 = NULLP;
3964    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
3965    pdschCfg->mcs_Table = NULLP;
3966
3967    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
3968    DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
3969    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
3970    {
3971       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3972       return RFAILED;
3973    }
3974    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
3975
3976    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
3977    {
3978       return RFAILED;
3979    }
3980
3981    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
3982    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
3983    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3984    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3985    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3986    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3987    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
3988
3989    return ROK;
3990 }
3991
3992 /*******************************************************************
3993  *
3994  * @brief Builds intitial DL BWP
3995  * @details
3996  *
3997  *    Function : BuildInitialDlBWP
3998  *
3999  *    Functionality: Builds intitial DL BWP in spCellCfgDed
4000  *
4001  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4002  *
4003  * @return ROK     - success
4004  *         RFAILED - failure
4005  *
4006  * ****************************************************************/
4007 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
4008 {
4009    dlBwp->pdcch_Config = NULLP;
4010    DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
4011    if(!dlBwp->pdcch_Config)
4012    {
4013       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4014       return RFAILED;
4015    }
4016    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
4017
4018    dlBwp->pdcch_Config->choice.setup = NULLP;
4019    DU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
4020    if(!dlBwp->pdcch_Config->choice.setup)
4021    {
4022       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4023       return RFAILED;
4024    }
4025    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
4026    {
4027       return RFAILED;
4028    }
4029
4030    dlBwp->pdsch_Config = NULLP;
4031    DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
4032    if(!dlBwp->pdsch_Config)
4033    {
4034       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4035       return RFAILED;
4036    }
4037    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
4038
4039    dlBwp->pdsch_Config->choice.setup = NULLP;
4040    DU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
4041    if(!dlBwp->pdsch_Config->choice.setup)
4042    {
4043       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4044       return RFAILED;
4045    }
4046
4047    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
4048    {
4049       return RFAILED;
4050    }
4051
4052    dlBwp->sps_Config = NULLP;
4053    dlBwp->radioLinkMonitoringConfig = NULLP;
4054    return ROK;
4055 }
4056
4057 /*******************************************************************
4058  *
4059  * @brief Builds DMRS UL Pusch Mapping type A
4060  *
4061  * @details
4062  *
4063  *    Function : BuildDMRSULPuschMapTypeA
4064  *
4065  *    Functionality: Builds DMRS UL Pusch Mapping type A
4066  *
4067  * @params[in]
4068  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4069  * @return ROK     - success
4070  *         RFAILED - failure
4071  *
4072  * ****************************************************************/
4073    uint8_t BuildDMRSULPuschMapTypeA
4074 (
4075  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4076  )
4077 {
4078    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
4079    dmrsUlCfg->choice.setup= NULLP;
4080    DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
4081    if(!dmrsUlCfg->choice.setup)
4082    {
4083       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4084       return RFAILED;
4085    }
4086
4087    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
4088    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
4089    DU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
4090    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4091    {
4092       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4093       return RFAILED;
4094    }
4095    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
4096
4097    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
4098    dmrsUlCfg->choice.setup->maxLength = NULLP;
4099    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
4100    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
4101          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4102    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4103    {
4104       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4105       return RFAILED;
4106    }
4107
4108    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
4109    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4110          sizeof(long));
4111    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
4112    {
4113       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4114       return RFAILED;
4115    }
4116    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
4117
4118    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
4119    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
4120    return ROK;
4121 }
4122
4123 /*******************************************************************
4124  *
4125  * @brief Build PUSCH time domain allocation list
4126  *
4127  * @details
4128  *
4129  *    Function : BuildPuschTimeDomAllocList
4130  *
4131  *    Functionality: Build PUSCH time domain allocation list
4132  *
4133  * @params[in]
4134  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4135  *
4136  * @return ROK     - success
4137  *         RFAILED - failure
4138  *
4139  * ****************************************************************/
4140    uint8_t BuildPuschTimeDomAllocList
4141 (
4142  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4143  )
4144 {
4145    uint8_t idx;
4146    uint8_t elementCnt;
4147    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
4148
4149    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
4150    timeDomAllocList->choice.setup = NULLP;
4151    DU_ALLOC(timeDomAllocList->choice.setup, \
4152          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4153    if(!timeDomAllocList->choice.setup)
4154    {
4155       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4156       return RFAILED;
4157    }
4158
4159    elementCnt = 2;
4160    timeDomAllocList->choice.setup->list.count = elementCnt;
4161    timeDomAllocList->choice.setup->list.size = \
4162                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
4163    timeDomAllocList->choice.setup->list.array = NULLP;
4164    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
4165          timeDomAllocList->choice.setup->list.size);
4166    if(!timeDomAllocList->choice.setup->list.array)
4167    {
4168       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4169       return RFAILED;
4170    }
4171
4172    for(idx = 0; idx < elementCnt; idx++)
4173    {
4174       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4175       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
4176             sizeof(PUSCH_TimeDomainResourceAllocation_t));
4177       if(!timeDomAllocList->choice.setup->list.array[idx])
4178       {
4179          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4180          return RFAILED;
4181       }
4182    }
4183
4184    idx = 0;
4185    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4186    DU_ALLOC(timeDomAlloc->k2, sizeof(long));
4187    if(!timeDomAlloc->k2)
4188    {
4189       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4190       return RFAILED;
4191    }
4192    *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
4193    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4194    timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
4195
4196    idx++;
4197    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4198    DU_ALLOC(timeDomAlloc->k2, sizeof(long));
4199    if(!timeDomAlloc->k2)
4200    {
4201       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4202       return RFAILED;
4203    }
4204    *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
4205    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4206    timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
4207
4208    return ROK;
4209 }
4210
4211 /*******************************************************************
4212  *
4213  * @brief Builds BWP UL dedicated PUSCH Config
4214  *
4215  * @details
4216  *
4217  *    Function : BuildBWPUlDedPuschCfg
4218  *
4219  *    Functionality:
4220  *      Builds BWP UL dedicated PUSCH Config
4221  *
4222  * @params[in] : PUSCH_Config_t *puschCfg
4223  *
4224  * @return ROK     - success
4225  *         RFAILED - failure
4226  *
4227  * ****************************************************************/
4228 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
4229 {
4230    puschCfg->dataScramblingIdentityPUSCH = NULLP;
4231    DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4232    if(!puschCfg->dataScramblingIdentityPUSCH)
4233    {
4234       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4235       return RFAILED;
4236    }
4237    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
4238
4239    puschCfg->txConfig = NULLP;
4240    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4241    DU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4242          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4243    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4244    {
4245       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4246       return RFAILED;
4247    }
4248
4249    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4250    {
4251       return RFAILED;
4252    }
4253
4254    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4255    puschCfg->pusch_PowerControl = NULLP;
4256    puschCfg->frequencyHopping = NULLP;
4257    puschCfg->frequencyHoppingOffsetLists = NULLP;
4258    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4259
4260    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4261    DU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
4262          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4263    if(!puschCfg->pusch_TimeDomainAllocationList)
4264    {
4265       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4266       return RFAILED;
4267    }
4268
4269    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
4270    {
4271       return RFAILED;
4272    }
4273
4274    puschCfg->pusch_AggregationFactor = NULLP;
4275    puschCfg->mcs_Table = NULLP;
4276    puschCfg->mcs_TableTransformPrecoder = NULLP;
4277    puschCfg->transformPrecoder = NULLP;
4278    DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4279    if(!puschCfg->transformPrecoder)
4280    {
4281       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4282       return RFAILED;
4283    }
4284    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4285
4286    puschCfg->codebookSubset = NULLP;
4287    puschCfg->maxRank = NULLP;
4288    puschCfg->rbg_Size = NULLP;
4289    puschCfg->uci_OnPUSCH = NULLP;
4290    puschCfg->tp_pi2BPSK = NULLP;
4291
4292    return ROK;
4293 }
4294
4295 /*******************************************************************
4296  *
4297  * @brief Builds BWP UL dedicated PUCCH Config
4298  *
4299  * @details
4300  *
4301  *    Function : BuildBWPUlDedPucchCfg
4302  *
4303  *    Functionality:
4304  *      Builds BWP UL dedicated PUCCH Config
4305  *
4306  * @params[in] : PUCCH_Config_t *pucchCfg
4307  *
4308  * @return ROK     - success
4309  *         RFAILED - failure
4310  *
4311  * ****************************************************************/
4312 uint8_t BuildBWPUlDedPucchCfg(PUCCH_Config_t *pucchCfg)
4313 {
4314    uint8_t arrIdx, elementCnt;
4315
4316    DU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
4317    if(pucchCfg->dl_DataToUL_ACK == NULLP)
4318    {
4319       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4320       return RFAILED;
4321    }
4322
4323    elementCnt = 2;
4324    pucchCfg->dl_DataToUL_ACK->list.count = elementCnt;
4325    pucchCfg->dl_DataToUL_ACK->list.size = elementCnt * sizeof(long *);
4326    DU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
4327    if(pucchCfg->dl_DataToUL_ACK->list.array == NULLP)
4328    {
4329       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4330       return RFAILED;
4331    }
4332
4333    for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
4334    {
4335       DU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
4336       if(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx] == NULLP)
4337       {
4338           DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4339           return RFAILED;
4340       }
4341    }
4342
4343    arrIdx = 0;
4344    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx++]) = 1;
4345    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx]) = 2;
4346    return ROK;
4347 }
4348
4349 /*******************************************************************
4350  *
4351  * @brief Fills SRS resource to add/modify list
4352  *
4353  * @details
4354  *
4355  *    Function : BuildSrsRsrcAddModList
4356  *
4357  *    Functionality: Fills SRS resource to add/modify list
4358  *
4359  * @params[in]
4360  * @return ROK     - success
4361  *         RFAILED - failure
4362  *
4363  * ****************************************************************/
4364 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
4365 {
4366    uint8_t   elementCnt;
4367    uint8_t   rsrcIdx;
4368
4369    elementCnt = 1;
4370    resourceList->list.count = elementCnt;
4371    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
4372    resourceList->list.array = NULLP;
4373    DU_ALLOC(resourceList->list.array, resourceList->list.size);
4374    if(!resourceList->list.array)
4375    {
4376       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4377       return RFAILED;
4378    }
4379
4380    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4381    {
4382       DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4383       if(!resourceList->list.array[rsrcIdx])
4384       {
4385          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4386          return RFAILED;
4387       }
4388    }
4389
4390    rsrcIdx = 0;
4391    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
4392    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
4393    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
4394
4395    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
4396    DU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
4397          sizeof(struct SRS_Resource__transmissionComb__n2));
4398    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
4399    {
4400       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4401       return RFAILED;
4402    }
4403    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
4404       = SRS_COMB_OFFSET_N2;
4405    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
4406       = SRS_CYCLIC_SHIFT_N2;
4407
4408    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
4409                                                                       PUSCH_START_SYMBOL;
4410    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
4411                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
4412    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
4413                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
4414
4415    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
4416    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
4417    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
4418    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
4419    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
4420    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
4421                                                                SRS_Resource__groupOrSequenceHopping_neither;
4422
4423    /* Setting resource type to aperiodic for intergration purposes */
4424    resourceList->list.array[rsrcIdx]->resourceType.present = \
4425                                                              SRS_Resource__resourceType_PR_aperiodic;
4426    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
4427    DU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
4428          sizeof(struct SRS_Resource__resourceType__aperiodic));
4429    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
4430    {
4431       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4432       return RFAILED;
4433    }
4434    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
4435
4436    return ROK;
4437 }
4438
4439 /*******************************************************************
4440  *
4441  * @brief Build SRS resource set Add/mod list
4442  *
4443  * @details
4444  *
4445  *    Function : BuildSrsRsrcSetAddModList
4446  *
4447  *    Functionality: Build SRS resource set Add/mod list
4448  *
4449  * @params[in]
4450  * @return ROK     - success
4451  *         RFAILED - failure
4452  *
4453  * ****************************************************************/
4454    uint8_t BuildSrsRsrcSetAddModList
4455 (
4456  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
4457  )
4458 {
4459    uint8_t  elementCnt;
4460    uint8_t  rSetIdx;
4461    uint8_t  rsrcIdx;
4462    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
4463
4464    elementCnt = 1;
4465    rsrcSetList->list.count = elementCnt;
4466    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
4467    rsrcSetList->list.array = NULLP;
4468    DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
4469    if(!rsrcSetList->list.array)
4470    {
4471       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4472       return RFAILED;
4473    }
4474
4475    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4476    {
4477       DU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4478       if(!rsrcSetList->list.array[rSetIdx])
4479       {
4480          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4481          return RFAILED;
4482       }
4483    }
4484
4485    rSetIdx = 0;
4486    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
4487
4488    /* Fill Resource Id list in resource set */
4489    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
4490    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4491          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4492    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4493    {
4494       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4495       return RFAILED;
4496    }
4497
4498    elementCnt = 1;
4499    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4500    rsrcIdList->list.count = elementCnt;
4501    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
4502    rsrcIdList->list.array = NULLP;
4503    DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
4504    if(!rsrcIdList->list.array)
4505    {
4506       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4507       return RFAILED;
4508    }
4509
4510    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4511    {
4512       DU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4513       if(!rsrcIdList->list.array[rsrcIdx])
4514       {
4515          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4516          return RFAILED;
4517       }
4518    }
4519
4520    rsrcIdx = 0;
4521    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
4522
4523    /* Fill resource type */
4524    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
4525                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
4526
4527    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
4528    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4529          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4530    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
4531    {
4532       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4533       return RFAILED;
4534    }
4535    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
4536       = APERIODIC_SRS_RESRC_TRIGGER;
4537
4538    /* TODO : Fill values for below IEs as expected by Viavi */
4539    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
4540    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
4541
4542
4543    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
4544    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
4545    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
4546    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
4547    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
4548
4549    return ROK;
4550 }
4551
4552 /*******************************************************************
4553  *
4554  * @brief Builds BWP UL dedicated SRS Config
4555  *
4556  * @details
4557  *
4558  *    Function : BuildBWPUlDedSrsCfg
4559  *
4560  *    Functionality: Builds BWP UL dedicated SRS Config
4561  *
4562  * @params[in] SRS Config
4563  * @return ROK     - success
4564  *         RFAILED - failure
4565  *
4566  * ****************************************************************/
4567 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
4568 {
4569    srsCfg->srs_ResourceSetToReleaseList = NULLP;
4570    srsCfg->srs_ResourceSetToAddModList = NULLP;
4571    DU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
4572          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4573    if(!srsCfg->srs_ResourceSetToAddModList)
4574    {
4575       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4576       return RFAILED;
4577    }
4578    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
4579    {
4580       return RFAILED;
4581    }
4582
4583    srsCfg->srs_ResourceToReleaseList = NULLP;
4584
4585    /* Resource to Add/Modify list */
4586    srsCfg->srs_ResourceToAddModList = NULLP;
4587    DU_ALLOC(srsCfg->srs_ResourceToAddModList, \
4588          sizeof(struct SRS_Config__srs_ResourceToAddModList));
4589    if(!srsCfg->srs_ResourceToAddModList)
4590    {
4591       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4592       return RFAILED;
4593    }
4594
4595    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
4596    {
4597       return RFAILED;
4598    }
4599
4600    srsCfg->tpc_Accumulation = NULLP;
4601
4602    return ROK;
4603 }
4604
4605
4606
4607 /*******************************************************************
4608  *
4609  * @brief Builds Pusch Serving cell Config
4610  *
4611  * @details
4612  *
4613  *    Function : BuildPuschSrvCellCfg
4614  *
4615  *    Functionality: Builds Pusch Serving cell Config
4616  *
4617  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
4618  *
4619  * @return ROK     - success
4620  *         RFAILED - failure
4621  *
4622  * ****************************************************************/
4623 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
4624 {
4625    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
4626    puschCfg->choice.setup = NULLP;
4627    DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4628    if(!puschCfg->choice.setup)
4629    {
4630       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4631       return RFAILED;
4632    }
4633
4634    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4635    puschCfg->choice.setup->rateMatching = NULLP;
4636    puschCfg->choice.setup->xOverhead = NULLP;
4637    puschCfg->choice.setup->ext1 = NULLP;
4638    DU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
4639    if(!puschCfg->choice.setup->ext1)
4640    {
4641       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4642       return RFAILED;
4643    }
4644
4645    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
4646    DU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
4647    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
4648    {
4649       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4650       return RFAILED;
4651    }
4652    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
4653
4654    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
4655    DU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
4656    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
4657    {
4658       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4659       return RFAILED;
4660    }
4661    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
4662    return ROK;
4663 }
4664
4665 /*******************************************************************
4666  *
4667  * @brief Builds inital UL BWP
4668  *
4669  * @details
4670  *
4671  *    Function : BuildInitialUlBWP
4672  *
4673  *    Functionality: Builds initial UL BWP
4674  *
4675  * @params[in] BWP_UplinkDedicated_t *ulBwp
4676  * @return ROK     - success
4677  *         RFAILED - failure
4678  *
4679  * ****************************************************************/
4680 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4681 {
4682    ulBwp->pucch_Config = NULLP;
4683    DU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
4684    if(!ulBwp->pucch_Config)
4685    {
4686       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4687       return RFAILED;
4688    }
4689
4690    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
4691    ulBwp->pucch_Config->choice.setup = NULLP;
4692    DU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
4693    if(!ulBwp->pucch_Config->choice.setup)
4694    {
4695       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4696       return RFAILED;
4697    }
4698
4699    if(BuildBWPUlDedPucchCfg(ulBwp->pucch_Config->choice.setup) != ROK)
4700    {
4701       return RFAILED;
4702    }
4703
4704    /* Fill BWP UL dedicated PUSCH config */
4705    ulBwp->pusch_Config = NULLP;
4706    DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4707    if(!ulBwp->pusch_Config)
4708    {
4709       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4710       return RFAILED;
4711    }
4712
4713    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
4714    ulBwp->pusch_Config->choice.setup = NULLP;
4715    DU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4716    if(!ulBwp->pusch_Config->choice.setup)
4717    {
4718       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4719       return RFAILED;
4720    }
4721
4722    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
4723    {
4724       return RFAILED;
4725    }
4726
4727    ulBwp->configuredGrantConfig = NULLP;
4728
4729    /* Fill BPW UL dedicated SRS config */
4730    ulBwp->srs_Config = NULLP;
4731    DU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4732    if(!ulBwp->srs_Config)
4733    {
4734       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4735       return RFAILED;
4736    }
4737
4738    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
4739    ulBwp->srs_Config->choice.setup = NULLP;
4740    DU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4741    if(!ulBwp->srs_Config->choice.setup)
4742    {
4743       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4744       return RFAILED;
4745    }
4746
4747    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
4748    {
4749       return RFAILED;
4750    }
4751
4752    ulBwp->beamFailureRecoveryConfig = NULLP;
4753
4754    return ROK;
4755 }
4756
4757 /*******************************************************************
4758  *
4759  * @brief Builds UL config
4760  * @details
4761  *
4762  *    Function : BuildUlCfg
4763  *
4764  *    Functionality: Builds UL config in spCellCfgDed
4765  *
4766  * @params[in] UplinkConfig_t *ulCfg
4767  *
4768  * @return ROK     - success
4769  *         RFAILED - failure
4770  *
4771  * ****************************************************************/
4772 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
4773 {
4774    ulCfg->initialUplinkBWP = NULLP;
4775    DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4776    if(!ulCfg->initialUplinkBWP)
4777    {
4778       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4779       return RFAILED;
4780    }
4781
4782    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
4783    {
4784       return RFAILED;
4785    }
4786
4787    ulCfg->uplinkBWP_ToReleaseList = NULLP;
4788    ulCfg->uplinkBWP_ToAddModList = NULLP;
4789    ulCfg->firstActiveUplinkBWP_Id = NULLP;
4790    DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4791    if(!ulCfg->firstActiveUplinkBWP_Id)
4792    {
4793       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4794       return RFAILED;
4795    }
4796    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
4797
4798    ulCfg->pusch_ServingCellConfig = NULLP;
4799    DU_ALLOC(ulCfg->pusch_ServingCellConfig, \
4800          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4801    if(!ulCfg->pusch_ServingCellConfig)
4802    {
4803       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4804       return RFAILED;
4805    }
4806
4807    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
4808    {
4809       return RFAILED;
4810    }
4811
4812    ulCfg->carrierSwitching = NULLP;
4813    ulCfg->ext1 = NULLP;
4814    return ROK;
4815 }
4816
4817 /*******************************************************************
4818  *
4819  * @brief Builds PDSCH serving cell config
4820  * @details
4821  *
4822  *    Function : BuildPdschSrvCellCfg
4823  *
4824  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
4825  *
4826  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
4827  *
4828  * @return ROK     - success
4829  *         RFAILED - failure
4830  *
4831  * ****************************************************************/
4832 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
4833 {
4834    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
4835    pdschCfg->choice.setup = NULLP;
4836    DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
4837    if(!pdschCfg->choice.setup)
4838    {
4839       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4840       return RFAILED;
4841    }
4842
4843    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4844    pdschCfg->choice.setup->xOverhead = NULLP;
4845    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
4846    DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
4847    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
4848    {
4849       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4850       return RFAILED;
4851    }
4852    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
4853    pdschCfg->choice.setup->pucch_Cell = NULLP;
4854    pdschCfg->choice.setup->ext1 = NULLP;
4855
4856    return ROK;
4857 }
4858
4859 /*******************************************************************
4860  *
4861  * @brief Builds CSI Meas config
4862  * @details
4863  *
4864  *    Function : BuildCsiMeasCfg
4865  *
4866  *    Functionality: Builds CSI Meas config in spCellCfgDed
4867  *
4868  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
4869  *
4870  * @return ROK     - success
4871  *         RFAILED - failure
4872  *
4873  * ****************************************************************/
4874 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
4875 {
4876
4877    return ROK;
4878 }
4879
4880 /*******************************************************************
4881  *
4882  * @brief Builds Spcell config dedicated
4883  * @details
4884  *
4885  *    Function : BuildSpCellCfgDed
4886  *
4887  *    Functionality: Builds sp cell config dedicated in spCellCfg
4888  *
4889  * @params[in] ServingCellConfig_t srvCellCfg
4890  *
4891  * @return ROK     - success
4892  *         RFAILED - failure
4893  *
4894  * ****************************************************************/
4895 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
4896 {
4897    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
4898    DU_ALLOC(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
4899    if(!srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
4900    {
4901       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4902       return RFAILED;
4903    }
4904
4905    srvCellCfg->initialDownlinkBWP = NULLP;
4906    DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
4907    if(!srvCellCfg->initialDownlinkBWP)
4908    {
4909       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4910       return RFAILED;
4911    }
4912
4913    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
4914    {
4915       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
4916       return RFAILED;
4917    }
4918    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
4919    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
4920
4921    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
4922    DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
4923    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
4924    {
4925       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4926       return RFAILED;
4927    }
4928    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4929
4930    srvCellCfg->bwp_InactivityTimer = NULLP;
4931
4932    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
4933    DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
4934    if(!srvCellCfg->defaultDownlinkBWP_Id)
4935    {
4936       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4937       return RFAILED;
4938    }
4939    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4940
4941    srvCellCfg->uplinkConfig = NULLP;
4942    DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
4943    if(!srvCellCfg->uplinkConfig)
4944    {
4945       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4946       return RFAILED;
4947    }
4948
4949    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
4950    {
4951       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
4952       return RFAILED;
4953    }
4954    srvCellCfg->supplementaryUplink = NULLP;
4955    srvCellCfg->pdcch_ServingCellConfig = NULLP;
4956
4957    srvCellCfg->pdsch_ServingCellConfig = NULLP;
4958    DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
4959    if(!srvCellCfg->pdsch_ServingCellConfig)
4960    {
4961       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4962       return RFAILED;
4963    }
4964
4965    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
4966    {
4967       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
4968       return RFAILED;
4969    }
4970
4971    srvCellCfg->csi_MeasConfig = NULLP;
4972 #if 0
4973    DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
4974       if(!srvCellCfg->csi_MeasConfig)
4975       {
4976          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4977          return RFAILED;
4978       }
4979
4980    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
4981    {
4982       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
4983       return RFAILED;
4984    }
4985 #endif
4986    srvCellCfg->sCellDeactivationTimer = NULLP;
4987    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
4988    srvCellCfg->tag_Id = TAG_ID;
4989    srvCellCfg->dummy = NULLP;
4990    srvCellCfg->pathlossReferenceLinking = NULLP;
4991    srvCellCfg->servingCellMO = NULLP;
4992    srvCellCfg->ext1 = NULLP;
4993
4994    return ROK;
4995 }
4996 /*******************************************************************
4997  *
4998  * @brief Builds Spcell config
4999  *
5000  * @details
5001  *
5002  *    Function : BuildSpCellCfg
5003  *
5004  *    Functionality: Builds sp cell config in DuToCuRrcContainer
5005  *
5006  * @params[in] SpCellConfig_t spCellCfg
5007  *
5008  * @return ROK     - success
5009  *         RFAILED - failure
5010  *
5011  * ****************************************************************/
5012 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
5013 {
5014
5015    spCellCfg->servCellIndex = NULLP;
5016    DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
5017    if(!spCellCfg->servCellIndex)
5018    {
5019       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5020       return RFAILED;
5021    }
5022    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
5023
5024    spCellCfg->reconfigurationWithSync = NULLP;
5025    spCellCfg->rlf_TimersAndConstants = NULLP;
5026    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
5027    DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5028    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
5029    {
5030       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5031       return RFAILED;
5032    }
5033    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
5034
5035    spCellCfg->spCellConfigDedicated = NULLP;
5036    DU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5037    if(!spCellCfg->spCellConfigDedicated)
5038    {
5039       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5040       return RFAILED;
5041    }
5042    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
5043    {
5044       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
5045       return RFAILED;
5046    }
5047    return ROK;
5048 }
5049 /*******************************************************************
5050  *
5051  * @brief Builds Phy cell group config
5052  *
5053  * @details
5054  *
5055  *    Function : BuildPhyCellGrpCfg
5056  *
5057  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
5058  *
5059  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
5060  *
5061  * @return ROK     - success
5062  *         RFAILED - failure
5063  *
5064  * ****************************************************************/
5065 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
5066 {
5067    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
5068    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
5069
5070    phyCellGrpCfg->p_NR_FR1 = NULLP;
5071    DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5072    if(!phyCellGrpCfg->p_NR_FR1)
5073    {
5074       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
5075       return RFAILED;
5076    }
5077    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
5078    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
5079    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
5080    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
5081    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
5082    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
5083    phyCellGrpCfg->cs_RNTI = NULLP;
5084    phyCellGrpCfg->ext1 = NULLP;
5085    phyCellGrpCfg->ext2 = NULLP;
5086
5087    return ROK;
5088 }
5089 /*******************************************************************
5090  *
5091  * @brief Builds Mac cell group config
5092  *
5093  * @details
5094  *
5095  *    Function : BuildMacCellGrpCfg
5096  *
5097  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
5098  *
5099  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
5100  *
5101  * @return ROK     - success
5102  *         RFAILED - failure
5103  *
5104  * ****************************************************************/
5105 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
5106 {
5107    macCellGrpCfg->drx_Config = NULLP;
5108    macCellGrpCfg->schedulingRequestConfig = NULLP;
5109    DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5110    if(!macCellGrpCfg->schedulingRequestConfig)
5111    {
5112       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5113       return RFAILED;
5114    }
5115
5116    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
5117    {
5118       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
5119       return RFAILED;
5120    }
5121
5122    macCellGrpCfg->bsr_Config = NULLP;
5123    DU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5124    if(!macCellGrpCfg->bsr_Config)
5125    {
5126       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5127       return RFAILED;
5128    }
5129
5130    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
5131    {
5132       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
5133       return RFAILED;
5134    }
5135
5136    macCellGrpCfg->tag_Config = NULLP;
5137    DU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
5138    if(!macCellGrpCfg->tag_Config)
5139    {
5140       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5141       return RFAILED;
5142    }
5143
5144    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
5145    {
5146       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
5147       return RFAILED;
5148    }
5149
5150    macCellGrpCfg->phr_Config = NULLP;
5151    DU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
5152    if(!macCellGrpCfg->phr_Config)
5153    {
5154       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5155       return RFAILED;
5156    }
5157
5158    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
5159    {
5160       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
5161       return RFAILED;
5162    }
5163
5164    macCellGrpCfg->skipUplinkTxDynamic = false;
5165    macCellGrpCfg->ext1 = NULLP;
5166
5167    return ROK;
5168 }
5169 /*******************************************************************
5170  *
5171  * @brief Frees memeory allocated for SearchSpcToAddModList
5172  *
5173  * @details
5174  *
5175  *    Function : FreeSearchSpcToAddModList
5176  *
5177  *    Functionality: Deallocating memory of SearchSpcToAddModList
5178  *
5179  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
5180  *
5181  * @return void
5182  *
5183  4221 * ****************************************************************/
5184 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
5185 {
5186    uint8_t idx1=0;
5187    uint8_t idx2=0;
5188    struct  SearchSpace *searchSpc=NULLP;
5189
5190    if(searchSpcList->list.array)
5191    {
5192       if(searchSpcList->list.array[idx2])
5193       {
5194          searchSpc = searchSpcList->list.array[idx2];
5195          if(searchSpc->controlResourceSetId)
5196          {
5197             if(searchSpc->monitoringSlotPeriodicityAndOffset)
5198             {
5199                if(searchSpc->monitoringSymbolsWithinSlot)
5200                {
5201                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
5202                   {
5203                      if(searchSpc->nrofCandidates)
5204                      {
5205                         if(searchSpc->searchSpaceType)
5206                         {
5207                            DU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
5208                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
5209                            DU_FREE(searchSpc->searchSpaceType, sizeof(struct
5210                                     SearchSpace__searchSpaceType));
5211                         }
5212                         DU_FREE(searchSpc->nrofCandidates,
5213                               sizeof(struct SearchSpace__nrofCandidates));
5214                      }
5215                      DU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
5216                            searchSpc->monitoringSymbolsWithinSlot->size);
5217                   }
5218                   DU_FREE(searchSpc->monitoringSymbolsWithinSlot,
5219                         sizeof(BIT_STRING_t));
5220                }
5221                DU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
5222                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
5223             }
5224             DU_FREE(searchSpc->controlResourceSetId,
5225                   sizeof(ControlResourceSetId_t));
5226          }
5227       }
5228       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
5229       {
5230          DU_FREE(searchSpcList->list.array[idx1],
5231                sizeof(struct SearchSpace));
5232       }
5233       DU_FREE(searchSpcList->list.array,searchSpcList->list.size);
5234    }
5235 }
5236 /*******************************************************************
5237  *
5238  * @brief Frees memory allocated for PdschTimeDomAllocList
5239  *
5240  * @details
5241  *
5242  *    Function : FreePdschTimeDomAllocList
5243  *
5244  *    Functionality: Deallocating memory of PdschTimeDomAllocList
5245  *
5246  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
5247  *
5248  * @return void
5249  *
5250  * ****************************************************************/
5251 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
5252 {
5253    uint8_t idx1=0;
5254
5255    if(timeDomAllocList->choice.setup)
5256    {
5257       if(timeDomAllocList->choice.setup->list.array)
5258       {
5259          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
5260          {
5261             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1]->k0, sizeof(long));
5262             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
5263                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
5264          }
5265          DU_FREE(timeDomAllocList->choice.setup->list.array, \
5266                timeDomAllocList->choice.setup->list.size);
5267       }
5268       DU_FREE(timeDomAllocList->choice.setup,\
5269             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
5270    }
5271 }
5272 /*******************************************************************
5273  *
5274  * @brief Frees memory allocated for PuschTimeDomAllocList
5275  *
5276  *@details
5277  *
5278  *    Function : FreePuschTimeDomAllocList
5279  *
5280  *    Functionality: Deallocating memory of PuschTimeDomAllocList
5281  *
5282  * @params[in] PUSCH_Config_t *puschCfg
5283  *
5284  * @return void
5285  *
5286  * ****************************************************************/
5287 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
5288 {
5289    uint8_t rsrcListIdx=0;
5290    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
5291
5292    if(puschCfg->pusch_TimeDomainAllocationList)
5293    {
5294       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
5295       if(timeDomAllocList_t->choice.setup)
5296       {
5297          if(timeDomAllocList_t->choice.setup->list.array)
5298          {
5299             for(rsrcListIdx = 0; rsrcListIdx<timeDomAllocList_t->choice.setup->list.count; rsrcListIdx++)
5300             {
5301                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx]->k2, sizeof(long));
5302                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx],\
5303                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
5304             }
5305             DU_FREE(timeDomAllocList_t->choice.setup->list.array, \
5306                   timeDomAllocList_t->choice.setup->list.size);
5307          }
5308          DU_FREE(timeDomAllocList_t->choice.setup, \
5309                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
5310       }
5311       DU_FREE(puschCfg->transformPrecoder, sizeof(long));
5312       DU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
5313             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
5314    }
5315
5316 }
5317 /*******************************************************************
5318  *
5319  * @brief Frees memory allocated for InitialUlBWP
5320  *
5321  * @details
5322  *
5323  *    Function : FreeInitialUlBWP
5324  *
5325  *    Functionality: Deallocating memory of InitialUlBWP
5326  *
5327  * @params[in] BWP_UplinkDedicated_t *ulBwp
5328  *
5329  * @return void
5330  *
5331  * ****************************************************************/
5332 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5333 {
5334    uint8_t  rSetIdx, rsrcIdx, k1Idx;
5335    SRS_Config_t   *srsCfg = NULLP;
5336    PUSCH_Config_t *puschCfg = NULLP;
5337    PUCCH_Config_t *pucchCfg = NULLP;
5338    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
5339    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
5340    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
5341    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
5342
5343    if(ulBwp->pucch_Config)
5344    {
5345       if(ulBwp->pucch_Config->choice.setup)
5346       {
5347           pucchCfg = ulBwp->pucch_Config->choice.setup;
5348           if(pucchCfg->dl_DataToUL_ACK)
5349           {
5350              if(pucchCfg->dl_DataToUL_ACK->list.array)
5351              {
5352                 for(k1Idx = 0; k1Idx < pucchCfg->dl_DataToUL_ACK->list.count; k1Idx++)
5353                 {
5354                    DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[k1Idx], sizeof(long));
5355                 }
5356                 DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
5357              }
5358              DU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
5359           }
5360           DU_FREE(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
5361       }
5362       DU_FREE(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
5363    }
5364
5365    if(ulBwp->pusch_Config)
5366    {
5367       if(ulBwp->pusch_Config->choice.setup)
5368       {
5369          puschCfg=ulBwp->pusch_Config->choice.setup;
5370          if(puschCfg->dataScramblingIdentityPUSCH)
5371          {
5372             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
5373             {
5374                FreePuschTimeDomAllocList(puschCfg);
5375                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
5376                if(dmrsUlCfg->choice.setup)
5377                {
5378                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
5379                   {
5380                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
5381                      {
5382                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
5383                               sizeof(long));
5384                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
5385                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
5386                      }
5387                      DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
5388                            sizeof(long));
5389                   }
5390                   DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
5391                }
5392                DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
5393                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
5394             }
5395             DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
5396          }
5397          DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5398       }
5399       DU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5400
5401       /* Free SRS-Config */
5402       if(ulBwp->srs_Config)
5403       {
5404          if(ulBwp->srs_Config->choice.setup)
5405          {
5406             srsCfg = ulBwp->srs_Config->choice.setup;
5407
5408             /* Free Resource Set to add/mod list */
5409             if(srsCfg->srs_ResourceSetToAddModList)
5410             {
5411                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
5412                if(rsrcSetList->list.array)
5413                {
5414                   rSetIdx = 0;
5415
5416                   /* Free SRS resource Id list in this SRS resource set */
5417                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5418                   {
5419                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5420
5421                      if(rsrcIdList->list.array)
5422                      {
5423                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5424                         {
5425                            DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5426                         }
5427                         DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
5428                      }
5429                      DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5430                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5431                   }
5432
5433                   /* Free resource type info for this SRS resource set */
5434                   DU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5435                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5436
5437                   /* Free memory for each resource set */
5438                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5439                   {
5440                      DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5441                   }
5442                   DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
5443                }
5444                DU_FREE(srsCfg->srs_ResourceSetToAddModList, \
5445                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5446             }
5447
5448             /* Free resource to add/modd list */
5449             if(srsCfg->srs_ResourceToAddModList)
5450             {
5451                resourceList = srsCfg->srs_ResourceToAddModList;
5452                if(resourceList->list.array)
5453                {
5454                   rsrcIdx = 0;
5455                   DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
5456                         sizeof(struct SRS_Resource__transmissionComb__n2));
5457                   DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
5458                         sizeof(struct SRS_Resource__resourceType__aperiodic));
5459
5460                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5461                   {
5462                      DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5463                   }
5464                   DU_FREE(resourceList->list.array, resourceList->list.size);
5465                }
5466                DU_FREE(srsCfg->srs_ResourceToAddModList, \
5467                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
5468             }
5469
5470             DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5471          }
5472          DU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5473       }
5474    }
5475 }
5476 /*******************************************************************
5477  *
5478  * @brief Frees memory allocated for initialUplinkBWP
5479  *
5480  * @details
5481  *
5482  *    Function : FreeinitialUplinkBWP
5483  *
5484  *    Functionality: Deallocating memory of initialUplinkBWP
5485  *
5486  * @params[in] UplinkConfig_t *ulCfg
5487  *
5488  * @return void
5489  *
5490  *
5491  * ****************************************************************/
5492 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
5493 {
5494    BWP_UplinkDedicated_t *ulBwp=NULLP;
5495    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
5496
5497    if(ulCfg->initialUplinkBWP)
5498    {
5499       ulBwp=ulCfg->initialUplinkBWP;
5500       if(ulCfg->firstActiveUplinkBWP_Id)
5501       {
5502          if(ulCfg->pusch_ServingCellConfig)
5503          {
5504             puschCfg=ulCfg->pusch_ServingCellConfig;
5505             if(puschCfg->choice.setup)
5506             {
5507                if(puschCfg->choice.setup->ext1)
5508                {
5509                   DU_FREE(puschCfg->choice.setup->ext1->\
5510                         processingType2Enabled,sizeof(BOOLEAN_t));
5511                   DU_FREE(puschCfg->choice.setup->ext1->\
5512                         maxMIMO_Layers,sizeof(long));
5513                   DU_FREE(puschCfg->choice.setup->ext1, \
5514                         sizeof(struct PUSCH_ServingCellConfig__ext1));
5515                }
5516                DU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5517             }
5518             DU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5519          }
5520          DU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5521       }
5522       FreeInitialUlBWP(ulBwp);
5523       DU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5524    }
5525 }
5526 /*******************************************************************
5527  *
5528  * @brief Frees emmory allocated for BWPDlDedPdschCfg
5529  *
5530  * @details
5531  *
5532  *    Function : FreeBWPDlDedPdschCfg
5533  *
5534  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
5535  *
5536  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5537  *
5538  * @return void
5539  *
5540  *
5541  * ****************************************************************/
5542 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
5543 {
5544    struct PDSCH_Config *pdschCfg=NULLP;
5545    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
5546    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
5547    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
5548
5549    if(dlBwp->pdsch_Config->choice.setup)
5550    {
5551       pdschCfg=dlBwp->pdsch_Config->choice.setup;
5552       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
5553       {
5554          if(pdschCfg->pdsch_TimeDomainAllocationList)
5555          {
5556             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
5557             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
5558             {
5559                prbBndlType=&pdschCfg->prb_BundlingType;
5560                DU_FREE(prbBndlType->choice.staticBundling,\
5561                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
5562                DU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
5563             }
5564             FreePdschTimeDomAllocList(timeDomAllocList);
5565             DU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
5566                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
5567          }
5568          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
5569          if(dmrsDlCfg->choice.setup)
5570          {
5571             DU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
5572                   sizeof(long));
5573             DU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
5574          }
5575          DU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
5576                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
5577       }
5578       DU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
5579    }
5580 }
5581 /*******************************************************************
5582  *
5583  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
5584  *
5585  * @details
5586  *
5587  *    Function : FreeBWPDlDedPdcchCfg
5588  *
5589  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
5590  *
5591  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5592  *
5593  * @return void
5594  *
5595  *
5596  * ****************************************************************/
5597 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
5598 {
5599    uint8_t idx1=0;
5600    uint8_t idx2=0;
5601    struct PDCCH_Config *pdcchCfg=NULLP;
5602    struct ControlResourceSet *controlRSet=NULLP;
5603    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
5604
5605    if(dlBwp->pdcch_Config->choice.setup)
5606    {
5607       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
5608       if(pdcchCfg->controlResourceSetToAddModList)
5609       {
5610          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
5611          if(controlRSetList->list.array)
5612          {
5613             controlRSet = controlRSetList->list.array[idx2];
5614             if(controlRSet)
5615             {
5616                if(controlRSet->frequencyDomainResources.buf)
5617                {
5618                   if(controlRSet->pdcch_DMRS_ScramblingID)
5619                   {
5620                      if(pdcchCfg->searchSpacesToAddModList)
5621                      {
5622                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
5623                         DU_FREE(pdcchCfg->searchSpacesToAddModList, \
5624                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
5625                      }
5626                      DU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
5627                   }
5628                   DU_FREE(controlRSet->frequencyDomainResources.buf, \
5629                         controlRSet->frequencyDomainResources.size);
5630                }
5631             }
5632             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
5633             {
5634                DU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
5635             }
5636             DU_FREE(controlRSetList->list.array, controlRSetList->list.size);
5637          }
5638          DU_FREE(pdcchCfg->controlResourceSetToAddModList, \
5639                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
5640       }
5641       DU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
5642    }
5643 }
5644
5645 /*******************************************************************
5646  *
5647  * @brief Frees emmory allocated for DUToCURRCContainer
5648  *
5649  * @details
5650  *
5651  *    Function : FreeMemDuToCuRrcCont
5652  *
5653  *    Functionality: Deallocating memory of DuToCuRrcContainer
5654  *
5655  * @params[in] DuToCuRRCContainer, DuToCuRRCContainer
5656  *
5657  * @return ROK     - success
5658  *         RFAILED - failure
5659  *
5660  * ****************************************************************/
5661 uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg)
5662 {
5663    uint8_t idx=0;
5664    SpCellConfig_t *spCellCfg=NULLP;
5665    ServingCellConfig_t *srvCellCfg=NULLP;
5666    BWP_DownlinkDedicated_t *dlBwp=NULLP;
5667    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
5668    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
5669    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
5670    struct RLC_Config *rlcConfig=NULLP;
5671    struct LogicalChannelConfig *macLcConfig=NULLP;
5672    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
5673    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
5674    struct TAG_Config *tagConfig=NULLP;
5675    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
5676    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
5677    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
5678
5679    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
5680    if(rlcBearerList)
5681    {
5682       if(rlcBearerList->list.array)
5683       {
5684          for(idx=0; idx<rlcBearerList->list.count; idx++)
5685          {
5686             if(rlcBearerList->list.array[idx])
5687             {
5688                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
5689                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
5690                if(rlcConfig)
5691                {
5692                   if(rlcConfig->choice.am)
5693                   {
5694                      DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5695                      DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5696                      DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
5697                   }
5698                   DU_FREE(rlcConfig, sizeof(struct RLC_Config));
5699                }
5700                DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
5701                if(macLcConfig)
5702                {
5703                   if(macLcConfig->ul_SpecificParameters)
5704                   {
5705                      DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
5706                      DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
5707                      DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
5708                   }
5709                   DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
5710                }
5711                DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
5712             }
5713          }
5714          DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
5715       }
5716       DU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5717    }
5718
5719    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
5720    if(macCellGrpCfg)
5721    {
5722       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
5723       if(schedulingRequestConfig)
5724       {
5725          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
5726          if(schReqList)
5727          {
5728             if(schReqList->list.array)
5729             {
5730                for(idx=0;idx<schReqList->list.count; idx++)
5731                {
5732                   if(schReqList->list.array[idx])
5733                   {
5734                      DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
5735                      DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
5736                   }
5737                }
5738                DU_FREE(schReqList->list.array, schReqList->list.size);
5739             }
5740             DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
5741                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
5742             DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5743       }
5744       if(macCellGrpCfg->bsr_Config)
5745       {
5746          DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5747       }
5748       tagConfig = macCellGrpCfg->tag_Config;
5749       if(tagConfig)
5750       {
5751          tagList = tagConfig->tag_ToAddModList;
5752          if(tagList)
5753          {
5754             if(tagList->list.array)
5755             {
5756                for(idx=0; idx<tagList->list.count; idx++)
5757                {
5758                   DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
5759                }
5760                DU_FREE(tagList->list.array, tagList->list.size);
5761             }
5762             DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
5763          }
5764          DU_FREE(tagConfig, sizeof(struct TAG_Config));
5765       }
5766
5767       phrConfig = macCellGrpCfg->phr_Config;
5768       if(phrConfig)
5769       {
5770          DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
5771          DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
5772       }
5773
5774       DU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
5775    }
5776
5777    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
5778    if(phyCellGrpCfg)
5779    {
5780       DU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5781       DU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
5782    }
5783
5784    spCellCfg = cellGrpCfg->spCellConfig;
5785    if(spCellCfg)
5786    {
5787       if(spCellCfg->servCellIndex)
5788       {
5789          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
5790          {
5791             if(spCellCfg->spCellConfigDedicated)
5792             {
5793                srvCellCfg = spCellCfg->spCellConfigDedicated;
5794                if(srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
5795                {
5796                   if(srvCellCfg->initialDownlinkBWP)
5797                   {
5798                      dlBwp = srvCellCfg->initialDownlinkBWP;
5799                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
5800                      {
5801                         if(srvCellCfg->defaultDownlinkBWP_Id)
5802                         {
5803                            if(srvCellCfg->uplinkConfig)
5804                            {
5805                               if(srvCellCfg->pdsch_ServingCellConfig)
5806                               {
5807                                  pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
5808                                  if(pdschCfg->choice.setup)
5809                                  {
5810                                     DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
5811                                     DU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5812                                  }
5813                                  DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
5814                                           ServingCellConfig__pdsch_ServingCellConfig));
5815                               }
5816                               FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
5817                               DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
5818                            }
5819                            DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
5820                         }
5821                         DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
5822                      }
5823                      if(dlBwp->pdcch_Config)
5824                      {
5825                         if(dlBwp->pdsch_Config)
5826                         {
5827                            FreeBWPDlDedPdschCfg(dlBwp);
5828                            DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
5829                         }
5830                         FreeBWPDlDedPdcchCfg(dlBwp);
5831                         DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
5832                      }
5833                      DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
5834                   }
5835                   DU_FREE(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
5836                }
5837                DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5838             }
5839             DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5840          }
5841          DU_FREE(spCellCfg->servCellIndex, sizeof(long));
5842       }
5843       DU_FREE(spCellCfg,sizeof(SpCellConfig_t));
5844    }
5845    return ROK;
5846 }
5847 /*******************************************************************
5848  *
5849  * @brief Builds DU To CU RRC Container
5850  *
5851  * @details
5852  *
5853  *    Function : BuildDuToCuRrcContainer
5854  *
5855  *    Functionality: Builds DuToCuRrcContainer
5856  *
5857  * @params[in] idx, index in F1AP msg
5858  *             DuToCuRRCContainer, DuToCuRRCContainer
5859  *
5860  * @return ROK     - success
5861  *         RFAILED - failure
5862  *
5863  * ****************************************************************/
5864 uint8_t BuildDuToCuRrcContainer(DUtoCURRCContainer_t *duToCuRrcContainer)
5865 {
5866    uint8_t  ret = ROK;
5867    CellGroupConfigRrc_t  cellGrpCfg;
5868    asn_enc_rval_t        encRetVal;
5869    memset(&cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
5870    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
5871
5872    while(true)
5873    {
5874       cellGrpCfg.cellGroupId = CELL_GRP_ID;
5875
5876       cellGrpCfg.rlc_BearerToAddModList = NULLP;
5877       DU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5878       if(!cellGrpCfg.rlc_BearerToAddModList)
5879       {
5880          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5881          ret = RFAILED;
5882          break;
5883       }
5884       if(BuildRlcBearerToAddModList(cellGrpCfg.rlc_BearerToAddModList) != ROK)
5885       {
5886          DU_LOG("\nERROR  -->  F1AP : BuildRlcBearerToAddModList failed");
5887          ret = RFAILED;
5888          break;
5889       }
5890
5891       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
5892       cellGrpCfg.mac_CellGroupConfig = NULLP;
5893       DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
5894       if(!cellGrpCfg.mac_CellGroupConfig)
5895       {
5896          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5897          ret = RFAILED;
5898          break;
5899       }
5900       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
5901       {
5902          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
5903          ret = RFAILED;
5904          break;
5905       }
5906
5907       cellGrpCfg.physicalCellGroupConfig = NULLP;
5908       DU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
5909       if(!cellGrpCfg.physicalCellGroupConfig)
5910       {
5911          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5912          ret = RFAILED;
5913          break;
5914       }
5915       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
5916       {
5917          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
5918          ret = RFAILED;
5919          break;
5920       }
5921
5922       cellGrpCfg.spCellConfig = NULLP;
5923       DU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
5924       if(!cellGrpCfg.spCellConfig)
5925       {
5926          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5927          ret = RFAILED;
5928          break;
5929       }
5930       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
5931       {
5932          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
5933          ret = RFAILED;
5934          break;
5935       }
5936
5937       cellGrpCfg.sCellToAddModList = NULLP;
5938       cellGrpCfg.sCellToReleaseList = NULLP;
5939       cellGrpCfg.ext1 = NULLP;
5940
5941       /* encode cellGrpCfg into duToCuRrcContainer */
5942       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
5943       memset(encBuf, 0, ENC_BUF_MAX_LEN);
5944       encBufSize = 0;
5945       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
5946       /* Encode results */
5947       if(encRetVal.encoded == ENCODE_FAIL)
5948       {
5949          DU_LOG( "\nERROR  --> F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
5950                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5951          ret = RFAILED;
5952          break;
5953       }
5954       else
5955       {
5956          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
5957          for(int i=0; i< encBufSize; i++)
5958          {
5959             printf("%x",encBuf[i]);
5960          }
5961       }
5962
5963       duToCuRrcContainer->size = encBufSize;
5964       DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
5965       if(!duToCuRrcContainer->buf)
5966       {
5967          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
5968          ret = RFAILED;
5969          break;
5970       }
5971       if(ret == ROK)
5972       {
5973          memcpy(duToCuRrcContainer->buf, encBuf, duToCuRrcContainer->size);
5974       }
5975       break;
5976    }
5977    FreeMemDuToCuRrcCont(&cellGrpCfg);
5978    return ret;
5979 }
5980
5981 /*******************************************************************
5982  *
5983  * @brief Free memory allocated in InitialULRRCMessage
5984  *
5985  * @details
5986  *
5987  *    Function : freeInitUlRrcMsgTransfer
5988  *
5989  *    Functionality: Free memory allocated in InitialULRRCMessage
5990  *
5991  * @params[in]F1AP_PDU_t  *f1apMsg)
5992  *
5993  * @return ROK     - success
5994  *         RFAILED - failure
5995  *
5996  * ****************************************************************/
5997
5998 uint8_t freeInitUlRrcMsgTransfer(F1AP_PDU_t  *f1apMsg)
5999 {
6000    uint8_t ieIdx, arrIdx;
6001    InitialULRRCMessageTransfer_t *initULRRCMsg=NULLP;
6002
6003    if(f1apMsg)
6004    {
6005       if(f1apMsg->choice.initiatingMessage)
6006       {
6007          initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.\
6008             choice.InitialULRRCMessageTransfer;
6009          if(initULRRCMsg->protocolIEs.list.array)
6010          {
6011             for(ieIdx = 0; ieIdx < initULRRCMsg->protocolIEs.list.count; ieIdx++)
6012             {
6013                switch(initULRRCMsg->protocolIEs.list.array[ieIdx]->id)
6014                {
6015                   case ProtocolIE_ID_id_NRCGI:
6016                   {
6017                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf)
6018                      {
6019                         if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf)
6020                         {
6021                            DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf,\
6022                            initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.size);
6023                         }
6024                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf,\
6025                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.size);
6026                      }
6027                      break;
6028                   }
6029                   case ProtocolIE_ID_id_RRCContainer:
6030                   {
6031                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
6032                      {
6033                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,\
6034                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
6035                      }
6036                      break;
6037                   }
6038                   case ProtocolIE_ID_id_DUtoCURRCContainer:
6039                   {
6040                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf)
6041                      {
6042                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf,
6043                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.size);
6044                      }
6045                      break;
6046                   }
6047                   default:
6048                      break;
6049                }
6050              }
6051              for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
6052              {
6053                 if(initULRRCMsg->protocolIEs.list.array[arrIdx])
6054                 {
6055                    DU_FREE(initULRRCMsg->protocolIEs.list.array[arrIdx],\
6056                       sizeof(InitialULRRCMessageTransferIEs_t));
6057                 }
6058              }
6059              DU_FREE(initULRRCMsg->protocolIEs.list.array, initULRRCMsg->protocolIEs.list.size);
6060           }
6061          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
6062       }
6063       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
6064    }
6065    else
6066    {
6067       DU_LOG("\nERROR  -->  DU_APP : Recevied F1ap Pdu is null at freeInitUlRrcMsgTransfer()");
6068       return RFAILED;
6069    }
6070    return ROK;
6071 }
6072
6073 /*******************************************************************
6074  *
6075  * @brief Builds and sends the InitialULRRCMessage
6076  *
6077  * @details
6078  *
6079  *    Function : BuildAndSendInitialRrcMsgTransfer
6080  *
6081  *    Functionality: Constructs the Initial UL RRC Message Transfer and sends
6082  *                   it to the CU through SCTP.
6083  *
6084  * @params[in]
6085  *
6086  * @return ROK     - success
6087  *         RFAILED - failure
6088  *
6089  * ****************************************************************/
6090 uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti,
6091       uint16_t rrcContSize, uint8_t *rrcContainer)
6092 {
6093    uint8_t   ret;
6094    uint8_t   elementCnt;
6095    uint8_t   ieIdx;
6096    asn_enc_rval_t  encRetVal;
6097    F1AP_PDU_t  *f1apMsg = NULLP;
6098    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
6099    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
6100
6101    while(true)
6102    {
6103       DU_LOG("\n INFO   -->  F1AP : Building RRC Setup Request\n");
6104       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
6105       if(f1apMsg == NULLP)
6106       {
6107          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
6108          break;
6109       }
6110       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
6111       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
6112       if(f1apMsg->choice.initiatingMessage == NULLP)
6113       {
6114          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
6115          break;
6116       }
6117       f1apMsg->choice.initiatingMessage->procedureCode =\
6118                                                         ProcedureCode_id_InitialULRRCMessageTransfer;
6119       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
6120       f1apMsg->choice.initiatingMessage->value.present = \
6121                                                          InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
6122       initULRRCMsg =\
6123                     &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
6124       elementCnt = 5;
6125       initULRRCMsg->protocolIEs.list.count = elementCnt;
6126       initULRRCMsg->protocolIEs.list.size = \
6127                                             elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *);
6128       /* Initialize the F1Setup members */
6129       DU_ALLOC(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
6130       if(initULRRCMsg->protocolIEs.list.array == NULLP)
6131       {
6132          DU_LOG(" ERROR  -->  F1AP : Memory allocation for\
6133                RRCSetupRequestMessageTransferIEs failed");
6134          break;
6135       }
6136       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
6137       {
6138          DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx],\
6139                sizeof(InitialULRRCMessageTransferIEs_t));
6140          if(initULRRCMsg->protocolIEs.list.array[ieIdx] == NULLP)
6141          {
6142             break;
6143          }
6144       }
6145       ieIdx = 0;
6146       /*GNB DU UE F1AP ID*/
6147       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6148                                                         ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
6149       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  = Criticality_reject;
6150       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
6151                                                                   InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
6152       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
6153
6154
6155       /*NRCGI*/
6156       ieIdx++;
6157       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6158                                                         ProtocolIE_ID_id_NRCGI;
6159       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  =Criticality_reject;
6160       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
6161                                                                   InitialULRRCMessageTransferIEs__value_PR_NRCGI;
6162
6163       ret =\
6164            BuildNrcgi(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
6165       if(ret!=ROK)
6166       {
6167          break;
6168       }
6169
6170       /*CRNTI*/
6171       ieIdx++;
6172       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6173                                                         ProtocolIE_ID_id_C_RNTI;
6174       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6175       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6176                                                                  InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
6177       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.C_RNTI = crnti;
6178
6179       /*RRCContainer*/
6180       ieIdx++;
6181       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6182                                                         ProtocolIE_ID_id_RRCContainer;
6183       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6184       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6185                                                                  InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
6186
6187       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = rrcContSize;
6188       DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
6189             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size)
6190       if(!initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
6191       {
6192          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
6193          break;
6194
6195       }
6196       memcpy(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, rrcContainer,
6197             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
6198
6199
6200       /*DUtoCURRCContainer*/
6201       ieIdx++;
6202       initULRRCMsg->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCContainer;
6203       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6204       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6205                                                                  InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
6206
6207       ret = BuildDuToCuRrcContainer(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer);
6208       if(ret != ROK)
6209       {
6210          break;
6211       }
6212
6213       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
6214
6215       /* Encode the F1SetupRequest type as APER */
6216       memset(encBuf, 0, ENC_BUF_MAX_LEN);
6217       encBufSize = 0;
6218       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
6219       /* Encode results */
6220       if(encRetVal.encoded == ENCODE_FAIL)
6221       {
6222          DU_LOG( "\nERROR  --> F1AP : Could not encode Initial UL RRC Message Transfer\
6223                structure (at %s)\n",encRetVal.failed_type ? \
6224                encRetVal.failed_type->name : "unknown");
6225          ret = RFAILED;
6226          break;
6227       }
6228       else
6229       {
6230
6231          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for Initial UL RRC\
6232                Message transfer\n");
6233          for(int i=0; i< encBufSize; i++)
6234          {
6235             printf("%x",encBuf[i]);
6236          }
6237       }
6238       /* Sending  msg  */
6239       if(sendF1APMsg() != ROK)
6240       {
6241          DU_LOG("\nERROR  -->  F1AP : Sending Initial UL RRC Message Transfer Failed");
6242          ret = RFAILED;
6243          break;
6244       }
6245       break;
6246    }
6247    freeInitUlRrcMsgTransfer(f1apMsg);
6248    return ret;
6249 }/* End of BuildAndSendInitialRrcMsgTransfer*/
6250
6251 /*****  UE SETUP REQUEST *****/
6252
6253 /*******************************************************************
6254  *
6255  * @brief Free Qos And Snssai Drb Info
6256  *
6257  * @details
6258  *
6259  *    Function : freeDrbQosAndSnssaiInfo
6260  *
6261  *    Functionality: Free Qos And Snssai Drb Info
6262  *
6263  * @params[in] LcCfg *lcCfg,
6264  * @return void
6265  *
6266  * ****************************************************************/
6267 void freeDrbQosAndSnssaiInfo(LcCfg *lcCfg)
6268 {
6269    if(lcCfg->snssai)
6270    {
6271       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6272    }
6273    if(lcCfg->drbQos)
6274    {
6275       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
6276    }
6277 }
6278
6279 /******************************************************************
6280 *
6281 * @brief Function to delete the RLC Lc cfg from UE APP DB
6282 *
6283 * @details
6284 *
6285 *  Function : freeRlcLcCfg
6286 *
6287 *  Functionality: Function to delete the RLC Lc cfg from UE APP DB
6288 *
6289 *
6290  *****************************************************************/
6291
6292 void freeRlcLcCfg(RlcBearerCfg *lcCfg)
6293 {
6294    switch(lcCfg->rlcMode)
6295    {
6296       case RLC_AM :
6297          {
6298             if(lcCfg->u.amCfg)
6299             {
6300                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.amCfg, sizeof(AmBearerCfg));
6301             }
6302             break;
6303          }
6304       case RLC_UM_BI_DIRECTIONAL :
6305          {
6306             if(lcCfg->u.umBiDirCfg)
6307             {
6308                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
6309             }
6310             break;
6311          }
6312       case RLC_UM_UNI_DIRECTIONAL_UL :
6313          {
6314             if(lcCfg->u.umUniDirUlCfg)
6315             {
6316                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
6317             }
6318             break;
6319
6320          }
6321       case RLC_UM_UNI_DIRECTIONAL_DL :
6322          {
6323             if(lcCfg->u.umUniDirDlCfg)
6324             {
6325                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
6326             }
6327             break;
6328          }
6329       default:
6330          DU_LOG("\nERROR  -->  DU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
6331          break;
6332    }
6333 }
6334
6335 /*******************************************************************
6336  *
6337  * @brief Function to free MacLcCfg
6338  *
6339  * @details
6340  *
6341  *    Function : freeMacLcCfg
6342  *
6343  *    Functionality: Function to free MacLcCfg
6344  *
6345  * @params[in] LcCfg *lcCfg,
6346  * @return void
6347  *
6348  * ****************************************************************/
6349
6350 void  freeMacLcCfg(LcCfg *lcCfg)
6351 {
6352     /* Deleting DRBQOS */
6353    if(lcCfg->drbQos)
6354    {
6355       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
6356    }
6357    /* Deleting SNSSAI */
6358    if(lcCfg->snssai)
6359    {
6360       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6361    }
6362 }
6363 /*******************************************************************
6364  *
6365  * @brief Free UE NR Capability received in UE Context setup request
6366  *
6367  * @details
6368  *
6369  *    Function : freeAperDecodeUeNrCapability
6370  *
6371  *    Functionality:
6372  *       Free UE NR Capability received in UE Context setup request
6373  *
6374  * @params[in]
6375  * @return ROK     - success
6376  *         RFAILED - failure
6377  *
6378  * ****************************************************************/
6379 void freeAperDecodeUeNrCapability(void *ueNrCapability)
6380 {
6381    uint8_t arrIdx =0;
6382    FeatureSets_t *featureSets =NULLP;
6383    UE_NR_Capability_t *ueNrCap = (UE_NR_Capability_t *)ueNrCapability;
6384
6385    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
6386    {
6387       for(arrIdx = 0; arrIdx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; arrIdx++)
6388       {
6389          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx])
6390             free(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx]);
6391       }
6392       free(ueNrCap->rf_Parameters.supportedBandListNR.list.array);
6393    }
6394
6395    if(ueNrCap->featureSets)
6396    {
6397       featureSets = ueNrCap->featureSets;
6398       if(featureSets->featureSetsDownlinkPerCC)
6399       {
6400          if(featureSets->featureSetsDownlinkPerCC->list.array)
6401          {
6402             for(arrIdx = 0; arrIdx < featureSets->featureSetsDownlinkPerCC->list.count; arrIdx++)
6403             {
6404                if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx])
6405                {
6406                   if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL)
6407                      free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL);
6408                   free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]);
6409                }
6410             }
6411             free(featureSets->featureSetsDownlinkPerCC->list.array);
6412          }
6413          free(featureSets->featureSetsDownlinkPerCC);
6414       }
6415       if(featureSets->featureSetsUplinkPerCC)
6416       {
6417          if(featureSets->featureSetsUplinkPerCC->list.array)
6418          {
6419             for(arrIdx = 0; arrIdx < featureSets->featureSetsUplinkPerCC->list.count; arrIdx++)
6420             {
6421                if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx])
6422                {
6423                   if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL)
6424                      free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL);
6425                   free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]);
6426                }
6427             }
6428             free(featureSets->featureSetsUplinkPerCC->list.array);
6429          }
6430          free(featureSets->featureSetsUplinkPerCC);
6431       }
6432       free(ueNrCap->featureSets);
6433    }
6434 }
6435
6436 /*******************************************************************
6437 *
6438 * @brief Function to free PdcchSearchSpcToAddModList
6439          where memory allocated by aper_decoder
6440 *
6441 * @details
6442 *
6443 *    Function : freeAperDecodePdcchSearchSpcToAddModList
6444 *
6445 *    Functionality: Function to free PdcchSearchSpcToAddModList
6446 *
6447 * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
6448 * @return void
6449 *
6450 * ****************************************************************/
6451
6452 void freeAperDecodePdcchSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
6453 {
6454    uint8_t searchSpcArrIdx=0;
6455    uint8_t searchSpcArrIdx1=0;
6456    struct  SearchSpace *searchSpc=NULLP;
6457
6458
6459    if(searchSpcList->list.array)
6460    {
6461       if(searchSpcList->list.array[searchSpcArrIdx1])
6462       {
6463          searchSpc = searchSpcList->list.array[searchSpcArrIdx1];
6464          if(searchSpc->controlResourceSetId)
6465          {
6466             if(searchSpc->monitoringSlotPeriodicityAndOffset)
6467             {
6468                if(searchSpc->monitoringSymbolsWithinSlot)
6469                {
6470                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
6471                   {
6472                      if(searchSpc->nrofCandidates)
6473                      {
6474                         if(searchSpc->searchSpaceType)
6475                         {
6476                            free(searchSpc->searchSpaceType->choice.ue_Specific);
6477                            free(searchSpc->searchSpaceType);
6478                         }
6479                         free(searchSpc->nrofCandidates);
6480                      }
6481                      free(searchSpc->monitoringSymbolsWithinSlot->buf);
6482                   }
6483                   free(searchSpc->monitoringSymbolsWithinSlot);
6484                }
6485                free(searchSpc->monitoringSlotPeriodicityAndOffset);
6486             }
6487             free(searchSpc->controlResourceSetId);
6488          }
6489       }
6490       for(searchSpcArrIdx = 0; searchSpcArrIdx < searchSpcList->list.count; searchSpcArrIdx++)
6491       {
6492          free(searchSpcList->list.array[searchSpcArrIdx]);
6493       }
6494       free(searchSpcList->list.array);
6495    }
6496 }
6497 /*******************************************************************
6498 *
6499 * @brief Function for free part for the memory allocated by aper_decoder
6500 *
6501 * @details
6502 *
6503 *    Function : freeAperDecodeBWPDlDedPdcchConfig
6504 *
6505 *    Functionality: Function to free BWPDlDedPdcchConfig
6506 *
6507 * @params[in]
6508 * @return void
6509 *
6510 * ****************************************************************/
6511
6512
6513 void freeAperDecodeBWPDlDedPdcchConfig(BWP_DownlinkDedicated_t *dlBwp)
6514 {
6515    uint8_t arrIdx1=0;
6516    uint8_t arrIdx2=0;
6517    struct PDCCH_Config *pdcchCfg=NULLP;
6518    struct ControlResourceSet *controlRSet=NULLP;
6519    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
6520
6521    if(dlBwp->pdcch_Config->choice.setup)
6522    {
6523       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
6524       if(pdcchCfg->controlResourceSetToAddModList)
6525       {
6526          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
6527          if(controlRSetList->list.array)
6528          {
6529             controlRSet = controlRSetList->list.array[arrIdx2];
6530             if(controlRSet)
6531             {
6532                if(controlRSet->frequencyDomainResources.buf)
6533                {
6534                   if(controlRSet->pdcch_DMRS_ScramblingID)
6535                   {
6536                      if(pdcchCfg->searchSpacesToAddModList)
6537                      {
6538                         freeAperDecodePdcchSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
6539                         free(pdcchCfg->searchSpacesToAddModList);
6540                      }
6541                      free(controlRSet->pdcch_DMRS_ScramblingID);
6542                   }
6543                   free(controlRSet->frequencyDomainResources.buf);
6544                }
6545             }
6546             for(arrIdx1 = 0; arrIdx1 <controlRSetList->list.count; arrIdx1++)
6547             {
6548                free(controlRSetList->list.array[arrIdx1]);
6549             }
6550             free(controlRSetList->list.array);
6551          }
6552          free(pdcchCfg->controlResourceSetToAddModList);
6553       }
6554       free(dlBwp->pdcch_Config->choice.setup);
6555    }
6556 }
6557 /*******************************************************************
6558 *
6559 * @brief Function to free PdschTimeDomAllocationList
6560 *     where the memory allocated by aper_decoder
6561 *
6562 * @details
6563 *
6564 *    Function : freeAperDecodePdschTimeDomAllocationList
6565 *
6566 *    Functionality: Function to free PdschTimeDomAllocationList
6567 *
6568 * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
6569 * @return void
6570 *
6571 * ****************************************************************/
6572
6573
6574 void freeAperDecodePdschTimeDomAllocationList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
6575 {
6576    uint8_t arrIdx=0;
6577
6578    if(timeDomAllocList->choice.setup)
6579    {
6580       if(timeDomAllocList->choice.setup->list.array)
6581       {
6582          for(arrIdx = 0; arrIdx <timeDomAllocList->choice.setup->list.count ; arrIdx++)
6583          {
6584             free(timeDomAllocList->choice.setup->list.array[arrIdx]);
6585          }
6586          free(timeDomAllocList->choice.setup->list.array);
6587       }
6588       free(timeDomAllocList->choice.setup);
6589    }
6590 }
6591
6592 /*******************************************************************
6593 *
6594 * @brief Function to free BWPDlDedPdschConfig
6595 *        where the memory allocated by aper_decoder
6596 *
6597 * @details
6598 *
6599 *    Function : freeAperDecodeBWPDlDedPdschConfig
6600 *
6601 *    Functionality: Function to free BWPDlDedPdschConfig
6602 *
6603 * @params[in] BWP_DownlinkDedicated_t *dlBwp
6604 * @return void
6605 *
6606 * ****************************************************************/
6607
6608
6609 void freeAperDecodeBWPDlDedPdschConfig(BWP_DownlinkDedicated_t *dlBwp)
6610 {
6611    struct PDSCH_Config *pdschCfg=NULLP;
6612    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
6613    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
6614    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
6615
6616    if(dlBwp->pdsch_Config->choice.setup)
6617    {
6618       pdschCfg=dlBwp->pdsch_Config->choice.setup;
6619       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
6620       {
6621          if(pdschCfg->pdsch_TimeDomainAllocationList)
6622          {
6623             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
6624             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
6625             {
6626                prbBndlType=&pdschCfg->prb_BundlingType;
6627                free(prbBndlType->choice.staticBundling);
6628                free(pdschCfg->maxNrofCodeWordsScheduledByDCI);
6629             }
6630             freeAperDecodePdschTimeDomAllocationList(timeDomAllocList);
6631             free(pdschCfg->pdsch_TimeDomainAllocationList);
6632          }
6633          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
6634          if(dmrsDlCfg->choice.setup)
6635          {
6636             free(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition);
6637             free(dmrsDlCfg->choice.setup);
6638          }
6639          free(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA);
6640       }
6641       free(dlBwp->pdsch_Config->choice.setup);
6642    }
6643 }
6644 /*******************************************************************
6645 *
6646 * @brief Function to free PuschTimeDomAllocListCfg
6647                  where the memory allocated by aper_decoder
6648 *
6649 * @details
6650 *
6651 *    Function : freeAperDecodePuschTimeDomAllocListCfg
6652 *
6653 *    Functionality: Function to free PuschTimeDomAllocListCfg
6654 *
6655 * @params[in] PUSCH_Config_t *puschCfg
6656 * @return void
6657 *
6658 * ****************************************************************/
6659
6660
6661 void freeAperDecodePuschTimeDomAllocListCfg(PUSCH_Config_t *puschCfg)
6662 {
6663    uint8_t arrIdx=0;
6664    uint8_t arrIdx1=0;
6665    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
6666
6667    if(puschCfg->pusch_TimeDomainAllocationList)
6668    {
6669       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
6670       if(timeDomAllocList_t->choice.setup)
6671       {
6672          if(timeDomAllocList_t->choice.setup->list.array)
6673          {
6674             free(timeDomAllocList_t->choice.setup->list.array[arrIdx1]->k2);
6675             for(arrIdx = 0; arrIdx<timeDomAllocList_t->choice.setup->list.count; arrIdx++)
6676             {
6677                free(timeDomAllocList_t->choice.setup->list.array[arrIdx]);
6678             }
6679             free(timeDomAllocList_t->choice.setup->list.array);
6680          }
6681          free(timeDomAllocList_t->choice.setup);
6682       }
6683       free(puschCfg->transformPrecoder);
6684       free(puschCfg->pusch_TimeDomainAllocationList);
6685    }
6686 }
6687 /*******************************************************************
6688 *
6689 * @brief Function to free InitialUlBWPConfig where memory allocated by aper_decoder
6690 *
6691 * @details
6692 *
6693 *    Function : freeAperDecodeInitialUlBWPConfig
6694 *
6695 *    Functionality: Function to free InitialUlBWPConfig
6696 *
6697 * @params[in]  BWP_UplinkDedicated_t *ulBwp
6698 * @return void
6699 *
6700 * ****************************************************************/
6701
6702
6703 void freeAperDecodeInitialUlBWPConfig(BWP_UplinkDedicated_t *ulBwp)
6704 {
6705    uint8_t  rSetIdx =0;
6706    uint8_t  rsrcIdx =0;
6707    SRS_Config_t   *srsCfg = NULLP;
6708    PUSCH_Config_t *puschCfg = NULLP;
6709    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
6710    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
6711    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
6712    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
6713
6714    if(ulBwp->pusch_Config)
6715    {
6716       if(ulBwp->pusch_Config->choice.setup)
6717       {
6718          puschCfg=ulBwp->pusch_Config->choice.setup;
6719          if(puschCfg->dataScramblingIdentityPUSCH)
6720          {
6721             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
6722             {
6723                freeAperDecodePuschTimeDomAllocListCfg(puschCfg);
6724                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
6725                if(dmrsUlCfg->choice.setup)
6726                {
6727                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
6728                   {
6729                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
6730                      {
6731                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0);
6732                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled);
6733                      }
6734                      free(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition);
6735                   }
6736                   free(dmrsUlCfg->choice.setup);
6737                }
6738                free(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA);
6739             }
6740             free(puschCfg->dataScramblingIdentityPUSCH);
6741          }
6742          free(ulBwp->pusch_Config->choice.setup);
6743       }
6744       free(ulBwp->pusch_Config);
6745
6746       /* Free SRS-Config */
6747       if(ulBwp->srs_Config)
6748       {
6749          if(ulBwp->srs_Config->choice.setup)
6750          {
6751             srsCfg = ulBwp->srs_Config->choice.setup;
6752
6753             /* Free Resource Set to add/mod list */
6754             if(srsCfg->srs_ResourceSetToAddModList)
6755             {
6756                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
6757                if(rsrcSetList->list.array)
6758                {
6759                   rSetIdx = 0;
6760
6761                   /* Free SRS resource Id list in this SRS resource set */
6762                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
6763                   {
6764                      rsrcIdList =
6765                         rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
6766
6767                      if(rsrcIdList->list.array)
6768                      {
6769                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count;
6770                               rsrcIdx++)
6771                         {
6772                            free(rsrcIdList->list.array[rsrcIdx]);
6773                         }
6774                         free(rsrcIdList->list.array);
6775                      }
6776                      free(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList);
6777                   }
6778
6779                   /* Free resource type info for this SRS resource set */
6780
6781                   free(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic);
6782
6783                   /* Free memory for each resource set */
6784                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
6785                   {
6786                      free(rsrcSetList->list.array[rSetIdx]);
6787                   }
6788                   free(rsrcSetList->list.array);
6789                }
6790                free(srsCfg->srs_ResourceSetToAddModList);
6791             }
6792
6793             /* Free resource to add/modd list */
6794             if(srsCfg->srs_ResourceToAddModList)
6795             {
6796                resourceList = srsCfg->srs_ResourceToAddModList;
6797                if(resourceList->list.array)
6798                {
6799                   rsrcIdx = 0;
6800
6801                   free(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2);
6802                   free(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic);
6803
6804                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
6805                   {
6806                      free(resourceList->list.array[rsrcIdx]);
6807                   }
6808                   free(resourceList->list.array);
6809                }
6810                free(srsCfg->srs_ResourceToAddModList);
6811             }
6812
6813             free(ulBwp->srs_Config->choice.setup);
6814          }
6815          free(ulBwp->srs_Config);
6816       }
6817    }
6818 }
6819 /*******************************************************************
6820 *
6821 * @brief Function to free initialUplinkBWPConfig where memory allocated by aper_decoder
6822 *
6823 * @details
6824 *
6825 *    Function : freeAperDecodeinitialUplinkBWPConfig
6826 *
6827 *    Functionality: Function to free initialUplinkBWPConfig
6828 *
6829 * @params[in] UplinkConfig_t *ulCfg
6830 * @return void
6831 *
6832 * ****************************************************************/
6833
6834
6835 void freeAperDecodeinitialUplinkBWPConfig(UplinkConfig_t *ulCfg)
6836 {
6837    BWP_UplinkDedicated_t *ulBwp=NULLP;
6838    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
6839
6840    if(ulCfg->initialUplinkBWP)
6841    {
6842       ulBwp=ulCfg->initialUplinkBWP;
6843       if(ulCfg->firstActiveUplinkBWP_Id)
6844       {
6845          if(ulCfg->pusch_ServingCellConfig)
6846          {
6847             puschCfg=ulCfg->pusch_ServingCellConfig;
6848             if(puschCfg->choice.setup)
6849             {
6850                if(puschCfg->choice.setup->ext1)
6851                {
6852                   free(puschCfg->choice.setup->ext1->processingType2Enabled);
6853                   free(puschCfg->choice.setup->ext1->maxMIMO_Layers);
6854                   free(puschCfg->choice.setup->ext1);
6855                }
6856                free(puschCfg->choice.setup);
6857             }
6858             free(ulCfg->pusch_ServingCellConfig);
6859          }
6860          free(ulCfg->firstActiveUplinkBWP_Id);
6861       }
6862       freeAperDecodeInitialUlBWPConfig(ulBwp);
6863       free(ulCfg->initialUplinkBWP);
6864    }
6865 }
6866
6867 /*******************************************************************
6868  *
6869  * @brief Function to free DuUeCfg
6870  *
6871  * @details
6872  *
6873  *    Function : freeDuUeCfg
6874  *
6875  *    Functionality: Function to free DuUeCfg
6876  *
6877  * @params[in] DuUeCfg *ueCfg
6878  * @return void
6879  *
6880  * ****************************************************************/
6881 void freeDuUeCfg(DuUeCfg *ueCfg)
6882 {
6883    uint8_t lcIdx = 0;
6884    uint8_t arrIdx = 0;
6885    SpCellConfig_t *spCellCfg = NULLP;
6886    ServingCellConfig_t *srvCellCfg = NULLP;
6887    BWP_DownlinkDedicated_t *dlBwp = NULLP;
6888    MAC_CellGroupConfig_t *macCellGrpCfg = NULLP;
6889    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
6890    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList = NULLP;
6891    struct RLC_Config *rlcConfig = NULLP;
6892    struct LogicalChannelConfig *macLcConfig = NULLP;
6893    struct SchedulingRequestConfig *schedulingRequestConfig = NULLP;
6894    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList = NULLP;
6895    struct TAG_Config *tagConfig = NULLP;
6896    struct TAG_Config__tag_ToAddModList *tagList = NULLP;
6897    struct MAC_CellGroupConfig__phr_Config *phrConfig = NULLP;
6898    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg = NULLP;
6899    CellGroupConfigRrc_t *cellGrpCfg = ueCfg->cellGrpCfg;
6900
6901    if(ueCfg->ueNrCapability)
6902    {
6903       freeAperDecodeUeNrCapability(ueCfg->ueNrCapability);
6904       DU_FREE(ueCfg->ueNrCapability, sizeof(UE_NR_Capability_t));
6905       ueCfg->ueNrCapability = NULLP;
6906    }
6907
6908    if(ueCfg->cellGrpCfg)
6909    {
6910
6911       rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6912       if(rlcBearerList)
6913       {
6914          if(rlcBearerList->list.array)
6915          {
6916             for(arrIdx=0; arrIdx<rlcBearerList->list.count; arrIdx++)
6917             {
6918                if(rlcBearerList->list.array[arrIdx])
6919                {
6920                   rlcConfig   = rlcBearerList->list.array[arrIdx]->rlc_Config;
6921                   macLcConfig = rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig;
6922
6923                   if(rlcBearerList->list.array[arrIdx]->servedRadioBearer)
6924                   {
6925                      free(rlcBearerList->list.array[arrIdx]->servedRadioBearer);
6926                   }
6927                   if(rlcConfig)
6928                   {
6929                      if(rlcConfig->choice.am)
6930                      {
6931                         free(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength);
6932                         free(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength);
6933                         free(rlcConfig->choice.am);
6934                      }
6935                      free(rlcBearerList->list.array[arrIdx]->rlc_Config);
6936                   }
6937                   if(macLcConfig)
6938                   {
6939                      if(macLcConfig->ul_SpecificParameters)
6940                      {
6941                         free(macLcConfig->ul_SpecificParameters->schedulingRequestID);
6942                         free(macLcConfig->ul_SpecificParameters->logicalChannelGroup);
6943                         free(macLcConfig->ul_SpecificParameters);
6944                      }
6945                      free(rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig);
6946                   }
6947                   free(rlcBearerList->list.array[arrIdx]);
6948                }
6949             }
6950             free(rlcBearerList->list.array);
6951          }
6952          free(cellGrpCfg->rlc_BearerToAddModList);
6953       }
6954
6955       macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
6956       if(macCellGrpCfg)
6957       {
6958          schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
6959          if(schedulingRequestConfig)
6960          {
6961             schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
6962             if(schReqList)
6963             {
6964                if(schReqList->list.array)
6965                {
6966                   for(arrIdx=0;arrIdx<schReqList->list.count; arrIdx++)
6967                   {
6968                      if(schReqList->list.array[arrIdx])
6969                      {
6970                         free(schReqList->list.array[arrIdx]->sr_ProhibitTimer);
6971                         free(schReqList->list.array[arrIdx]);
6972                      }
6973                   }
6974                   free(schReqList->list.array);
6975                }
6976                free(schedulingRequestConfig->schedulingRequestToAddModList);
6977             }
6978             free(macCellGrpCfg->schedulingRequestConfig);
6979          }
6980          if(macCellGrpCfg->bsr_Config)
6981          {
6982             free(macCellGrpCfg->bsr_Config);
6983          }
6984          tagConfig = macCellGrpCfg->tag_Config;
6985          if(tagConfig)
6986          {
6987             tagList = tagConfig->tag_ToAddModList;
6988             if(tagList)
6989             {
6990                if(tagList->list.array)
6991                {
6992                   for(arrIdx=0; arrIdx<tagList->list.count; arrIdx++)
6993                   {
6994                      free(tagList->list.array[arrIdx]);
6995                   }
6996                   free(tagList->list.array);
6997                }
6998                free(tagConfig->tag_ToAddModList);
6999             }
7000             free(tagConfig);
7001          }
7002
7003          phrConfig = macCellGrpCfg->phr_Config;
7004          if(phrConfig)
7005          {
7006             free(phrConfig->choice.setup);
7007             free(phrConfig);
7008          }
7009
7010          free(macCellGrpCfg);
7011       }
7012
7013       phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
7014       if(phyCellGrpCfg)
7015       {
7016          free(phyCellGrpCfg->p_NR_FR1);
7017          free(phyCellGrpCfg);
7018       }
7019
7020       spCellCfg = cellGrpCfg->spCellConfig;
7021       if(spCellCfg)
7022       {
7023          if(spCellCfg->servCellIndex)
7024          {
7025             if(spCellCfg->rlmInSyncOutOfSyncThreshold)
7026             {
7027                if(spCellCfg->spCellConfigDedicated)
7028                {
7029                   srvCellCfg = spCellCfg->spCellConfigDedicated;
7030                   if(srvCellCfg->initialDownlinkBWP)
7031                   {
7032                      dlBwp = srvCellCfg->initialDownlinkBWP;
7033                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
7034                      {
7035                         if(srvCellCfg->defaultDownlinkBWP_Id)
7036                         {
7037                            if(srvCellCfg->uplinkConfig)
7038                            {
7039
7040                               if(srvCellCfg->pdsch_ServingCellConfig)
7041                               {
7042                                  pdschCfg=
7043                                     srvCellCfg->pdsch_ServingCellConfig;
7044                                  if(pdschCfg->choice.setup)
7045                                  {
7046
7047                                     free(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH);
7048                                     free(pdschCfg->choice.setup);
7049                                  }
7050
7051                                  free(srvCellCfg->pdsch_ServingCellConfig);
7052                               }
7053
7054                               freeAperDecodeinitialUplinkBWPConfig(srvCellCfg->uplinkConfig);
7055                               free(srvCellCfg->uplinkConfig);
7056                            }
7057                            free(srvCellCfg->defaultDownlinkBWP_Id);
7058                         }
7059
7060                         free(srvCellCfg->firstActiveDownlinkBWP_Id);
7061                      }
7062                      if(dlBwp->pdcch_Config)
7063                      {
7064                         if(dlBwp->pdsch_Config)
7065                         {
7066                            freeAperDecodeBWPDlDedPdschConfig(dlBwp);
7067                            free(dlBwp->pdsch_Config);
7068                         }
7069                         freeAperDecodeBWPDlDedPdcchConfig(dlBwp);
7070                         free(dlBwp->pdcch_Config);
7071                      }
7072                      free(srvCellCfg->initialDownlinkBWP);
7073                   }
7074
7075                   free(spCellCfg->spCellConfigDedicated);
7076                }
7077                free(spCellCfg->rlmInSyncOutOfSyncThreshold);
7078             }
7079             free(spCellCfg->servCellIndex);
7080          }
7081          free(spCellCfg);
7082       }
7083       DU_FREE(ueCfg->cellGrpCfg, sizeof(CellGroupConfigRrc_t));
7084       ueCfg->cellGrpCfg = NULLP;
7085    }
7086    if(ueCfg->ambrCfg)
7087    {
7088       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->ambrCfg, sizeof(AmbrCfg));
7089    }
7090    for(lcIdx = 0; lcIdx < ueCfg->numRlcLcs; lcIdx++)
7091    {
7092       freeRlcLcCfg(&ueCfg->rlcLcCfg[lcIdx]);
7093    }
7094    for(lcIdx = 0; lcIdx < ueCfg->numMacLcs; lcIdx++)
7095    {
7096       freeMacLcCfg(&ueCfg->macLcCfg[lcIdx]);
7097    }
7098    for(lcIdx = 0; lcIdx < ueCfg->numDrb; lcIdx++)
7099    {
7100       DU_FREE(ueCfg->upTnlInfo[lcIdx].tnlCfg1, sizeof(GtpTnlCfg));
7101    }
7102 }
7103
7104 /*******************************************************************
7105  *
7106  * @brief Function to free UecontextSetupDb
7107  *
7108  * @details
7109  *
7110  *    Function : freeF1UeDb
7111  *
7112  *    Functionality: Function to free UecontextSetupDb
7113  *
7114  * @params[in] UecontextSetupDb *
7115  * @return void
7116  *
7117  * ****************************************************************/
7118
7119 void freeF1UeDb(F1UeContextSetupDb *f1UeDb)
7120 {
7121
7122    if(f1UeDb->dlRrcMsg)
7123    {
7124       if(f1UeDb->dlRrcMsg->rrcMsgPdu)
7125       {
7126         //DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,\
7127                f1UeDb->dlRrcMsg->rrcMsgPdu, f1UeDb->dlRrcMsg->rrcMsgSize);
7128       }
7129       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
7130    }
7131    freeDuUeCfg(&f1UeDb->duUeCfg);
7132    memset(f1UeDb, 0, sizeof(F1UeContextSetupDb));
7133    DU_FREE(f1UeDb, sizeof(F1UeContextSetupDb));
7134 }
7135
7136 /*******************************************************************
7137  *
7138  * @brief Function to build Am cfg Info
7139  *
7140  * @details
7141  *
7142  *    Function : extractRlcAmCfg
7143  *
7144  *    Functionality: Function to build Am cfg Info
7145  *
7146  * @params[in] AmBearerCfg *
7147  *             void *
7148  *
7149  * @return ROK/RFAILED
7150  *
7151  * ****************************************************************/
7152
7153 void extractRlcAmCfg(AmBearerCfg *amCfgToSet, struct RLC_Config__am *rlcAmCfg)
7154 {
7155    if(rlcAmCfg)
7156    {
7157       /* UL AM */
7158       if(rlcAmCfg->dl_AM_RLC.sn_FieldLength)
7159       {
7160          amCfgToSet->ulAmCfg.snLenUl = *(rlcAmCfg->dl_AM_RLC.sn_FieldLength);
7161          /*TODO: Check the timer value when sent by real CU */
7162          amCfgToSet->ulAmCfg.reAssemTmr = rlcAmCfg->dl_AM_RLC.t_Reassembly;
7163          amCfgToSet->ulAmCfg.statProhTmr = rlcAmCfg->dl_AM_RLC.t_StatusProhibit;
7164       }
7165
7166       /* DL AM */
7167       if(rlcAmCfg->ul_AM_RLC.sn_FieldLength)
7168       {
7169          amCfgToSet->dlAmCfg.snLenDl = *(rlcAmCfg->ul_AM_RLC.sn_FieldLength);
7170          amCfgToSet->dlAmCfg.pollRetxTmr = rlcAmCfg->ul_AM_RLC.t_PollRetransmit;
7171          amCfgToSet->dlAmCfg.pollPdu   = rlcAmCfg->ul_AM_RLC.pollPDU;
7172          amCfgToSet->dlAmCfg.pollByte  = rlcAmCfg->ul_AM_RLC.pollByte;
7173          amCfgToSet->dlAmCfg.maxRetxTh = rlcAmCfg->ul_AM_RLC.maxRetxThreshold;
7174       }
7175    }
7176 }
7177
7178 /*******************************************************************
7179  *
7180  * @brief Function to build Um Bi Info
7181  *
7182  * @details
7183  *
7184  *    Function : extractRlcUmBiCfg
7185  *
7186  *    Functionality: Function to build Um Bi Info
7187  *
7188  * @params[in] UmBiDirBearerCfg *
7189  *             void *
7190  *
7191  * @return ROK/RFAILED
7192  *
7193  * ****************************************************************/
7194
7195 void extractRlcUmBiCfg(UmBiDirBearerCfg *umBiCfgToSet, struct RLC_Config__um_Bi_Directional *rlcBiCfg)
7196 {
7197    if(rlcBiCfg)
7198    {
7199       /* UL UM BI DIR Cfg */
7200       if(rlcBiCfg->dl_UM_RLC.sn_FieldLength)
7201       {
7202          umBiCfgToSet->ulUmCfg.snLenUlUm  = *(rlcBiCfg->dl_UM_RLC.sn_FieldLength);
7203          umBiCfgToSet->ulUmCfg.reAssemTmr = rlcBiCfg->dl_UM_RLC.t_Reassembly;
7204       }
7205
7206       /* DL UM BI DIR Cfg */
7207       if(rlcBiCfg->ul_UM_RLC.sn_FieldLength)
7208          umBiCfgToSet->dlUmCfg.snLenDlUm  = *(rlcBiCfg->ul_UM_RLC.sn_FieldLength);
7209    }
7210 }
7211
7212 /*******************************************************************
7213  *
7214  * @brief Function to build Um Ul Info
7215  *
7216  * @details
7217  *
7218  *    Function : extractRlcUmUlCfg
7219  *
7220  *    Functionality: Function to build Um Ul Info
7221  *
7222  * @params[in] UmUniDirUlBearerCfg *
7223  *             void *
7224  *
7225  * @return ROK/RFAILED
7226  *
7227  * ****************************************************************/
7228
7229 void extractRlcUmUlCfg(UmUniDirUlBearerCfg *umUlCfgToSet, struct RLC_Config__um_Uni_Directional_DL *umUlCfg)
7230 {
7231    if(umUlCfg)
7232    {
7233       if(umUlCfg->dl_UM_RLC.sn_FieldLength)
7234       {
7235          umUlCfgToSet->ulUmCfg.snLenUlUm  = *(umUlCfg->dl_UM_RLC.sn_FieldLength);
7236          umUlCfgToSet->ulUmCfg.reAssemTmr = umUlCfg->dl_UM_RLC.t_Reassembly;
7237       }
7238    }
7239 }
7240
7241 /*******************************************************************
7242  *
7243  * @brief Function to build Um Uni Dl Info
7244  *
7245  * @details
7246  *
7247  *    Function : extractRlcUmDlCfg
7248  *
7249  *    Functionality: Function to build Um Uni Dl Info
7250  *
7251  * @params[in] UmUniDirDlBearerCfg *
7252  *             void *
7253  *
7254  * @return ROK/RFAILED
7255  *
7256  * ****************************************************************/
7257 void extractRlcUmDlCfg(UmUniDirDlBearerCfg *umDlCfgToSet, struct RLC_Config__um_Uni_Directional_UL *umDlCfg)
7258 {
7259    if(umDlCfg)
7260    {
7261       if(umDlCfg->ul_UM_RLC.sn_FieldLength)
7262          umDlCfgToSet->dlUmCfg.snLenDlUm  = *(umDlCfg->ul_UM_RLC.sn_FieldLength);
7263    }
7264 }
7265
7266 /*******************************************************************
7267  *
7268  * @brief Function to extractRlcModeCfg
7269  *
7270  * @details
7271  *
7272  *    Function : extractRlcModeCfg
7273  *
7274  *    Functionality: Function to extractRlcModeCfg
7275  *
7276  * @params[in] RLC_Config_t *
7277  *             RlcBearerCfg *
7278  *             void  *
7279  * @return ROK/RFAILED
7280  *
7281  * ****************************************************************/
7282 void extractRlcModeCfg(uint8_t rlcMode, RlcBearerCfg *rlcDbCfg, RLC_Config_t *lcCfg)
7283 {
7284    if(lcCfg)
7285    {
7286       switch(rlcMode)
7287       {
7288          case RLC_AM :
7289             {
7290                if(lcCfg->choice.am)
7291                {
7292                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.amCfg, sizeof(AmBearerCfg));
7293                   if(rlcDbCfg->u.amCfg)
7294                      extractRlcAmCfg(rlcDbCfg->u.amCfg, lcCfg->choice.am);
7295                }
7296                break;
7297             }
7298          case RLC_UM_BI_DIRECTIONAL :
7299             {
7300                if(lcCfg->choice.um_Bi_Directional)
7301                {
7302                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
7303                   if(rlcDbCfg->u.umBiDirCfg)
7304                      extractRlcUmBiCfg(rlcDbCfg->u.umBiDirCfg, lcCfg->choice.um_Bi_Directional);
7305                }
7306                break;
7307             }
7308          case RLC_UM_UNI_DIRECTIONAL_UL :
7309             {
7310                if(lcCfg->choice.um_Uni_Directional_DL)
7311                {
7312                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
7313                   if(rlcDbCfg->u.umUniDirUlCfg)
7314                      extractRlcUmUlCfg(rlcDbCfg->u.umUniDirUlCfg, lcCfg->choice.um_Uni_Directional_DL);
7315                }
7316                break;
7317             }
7318          case RLC_UM_UNI_DIRECTIONAL_DL :
7319             {
7320                if(lcCfg->choice.um_Uni_Directional_UL)
7321                {
7322                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
7323                   if(rlcDbCfg->u.umUniDirDlCfg)
7324                      extractRlcUmDlCfg(rlcDbCfg->u.umUniDirDlCfg, lcCfg->choice.um_Uni_Directional_UL);
7325                }
7326                break;
7327             }
7328          default:
7329             DU_LOG("\nERROR  -->  DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
7330             break;
7331       }
7332    }
7333 }
7334
7335 /*******************************************************************
7336  *
7337  * @brief Function to extract extractUlLcCfg
7338  *
7339  * @details
7340  *
7341  *    Function : extractUlLcCfg
7342  *
7343  *    Functionality: Function to extract extractUlLcCfg
7344  *
7345  * @params[in] UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg
7346  * @return void
7347  *
7348  * ****************************************************************/
7349
7350 void extractUlLcCfg(UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg)
7351 {
7352    if(ulLcCfg)
7353    {
7354       if(ulLcCfg->ul_SpecificParameters)
7355       {
7356          f1UlLcCfg->priority = \
7357             ulLcCfg->ul_SpecificParameters->priority;
7358       if(ulLcCfg->ul_SpecificParameters->logicalChannelGroup)
7359       {
7360          f1UlLcCfg->lcGroup = \
7361            *(ulLcCfg->ul_SpecificParameters->logicalChannelGroup);
7362       }
7363       if(ulLcCfg->ul_SpecificParameters->schedulingRequestID)
7364       {
7365          f1UlLcCfg->schReqId = \
7366            *(ulLcCfg->ul_SpecificParameters->schedulingRequestID);
7367       }
7368       f1UlLcCfg->pbr = \
7369          ulLcCfg->ul_SpecificParameters->prioritisedBitRate;
7370       f1UlLcCfg->bsd = \
7371          ulLcCfg->ul_SpecificParameters->bucketSizeDuration;
7372       }
7373    }
7374 }
7375
7376 /*******************************************************************
7377  *
7378  * @brief Function to procRlcLcCfg
7379  *
7380  * @details
7381  *
7382  *    Function : procRlcLcCfg
7383  *
7384  *    Functionality: Function to procRlcLcCfg
7385  *
7386  * @params[in] rbId, lcId, rbType, rlcMod
7387  *             RLC_Config_t *, RlcBearerCfg * ,
7388  * @return void
7389  *
7390  * ****************************************************************/
7391
7392 void procRlcLcCfg(uint8_t rbId, uint8_t lcId, uint8_t rbType, uint8_t rlcMode,\
7393    uint8_t configType, RLC_Config_t *f1RlcCfg, RlcBearerCfg *lcCfg)
7394 {
7395
7396    lcCfg->rbId   = rbId;
7397    lcCfg->configType = configType;
7398
7399    if(rbType == RB_TYPE_SRB)
7400    {
7401       lcCfg->rbType = RB_TYPE_SRB;
7402       lcCfg->lcId   = rbId;
7403       lcCfg->lcType = LCH_DCCH;
7404       lcCfg->rlcMode = RLC_AM;
7405    }
7406    else if(rbType == RB_TYPE_DRB)
7407    {
7408       lcCfg->rbType = RB_TYPE_DRB;
7409       lcCfg->lcId   = lcId;
7410       lcCfg->lcType = LCH_DTCH;
7411       lcCfg->rlcMode = rlcMode;
7412    }
7413    if(f1RlcCfg) /* rlc mode config recived */
7414    {
7415       extractRlcModeCfg(lcCfg->rlcMode, lcCfg, f1RlcCfg);
7416    }
7417 }
7418
7419
7420
7421 /*******************************************************************
7422  *
7423  * @brief Fills DrbQos Info received by CU
7424  *
7425  * @details
7426  *
7427  *    Function : extractQosInfo
7428  *
7429  *    Functionality: Fills DrbQos Info received  by CU
7430  *
7431  * @params[in] DrbQosInfo *qosToAdd,
7432  *             QoSFlowLevelQoSParameters_t *qosFlowCfg
7433  * @return void
7434  *
7435  * ****************************************************************/
7436
7437 void extractQosInfo(DrbQosInfo *qosToAdd, QoSFlowLevelQoSParameters_t *qosFlowCfg)
7438 {
7439    uint8_t qosCntIdx = 0;
7440    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
7441
7442    qosToAdd->fiveQiType = qosFlowCfg->qoS_Characteristics.present;
7443    qosToAdd->u.nonDyn5Qi.fiveQi     =\
7444                                      qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
7445    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow)
7446    {
7447       qosToAdd->u.nonDyn5Qi.avgWindow = \
7448                                         *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
7449    }
7450    qosToAdd->u.nonDyn5Qi.maxDataBurstVol = \
7451                                            *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
7452    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel)
7453    {
7454       qosToAdd->u.nonDyn5Qi.priorLevel = \
7455                                          *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel);
7456    }
7457    qosToAdd->ngRanRetPri.priorityLevel = \
7458                                          qosFlowCfg->nGRANallocationRetentionPriority.priorityLevel;
7459    qosToAdd->ngRanRetPri.preEmptionCap = \
7460                                          qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionCapability;
7461    qosToAdd->ngRanRetPri.preEmptionVul = \
7462                                          qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionVulnerability;
7463    if(qosFlowCfg->gBR_QoS_Flow_Information)
7464    {
7465       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateDl, \
7466             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.buf, \
7467             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.size);
7468       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateUl, \
7469             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.buf, \
7470             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.size);
7471       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateDl,\
7472             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.buf, \
7473             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.size);
7474       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateUl,\
7475             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.buf, \
7476             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.size);
7477    }
7478    /*Extracting PDU_SESSION_ID*/
7479    qosIeExt = (ProtocolExtensionContainer_4624P74_t *)qosFlowCfg->iE_Extensions;
7480    if(qosIeExt)
7481    {
7482       for(qosCntIdx = 0; qosCntIdx < qosIeExt->list.count; qosCntIdx++)
7483       {
7484          if(qosIeExt->list.array[qosCntIdx]->extensionValue.present == \
7485                QoSFlowLevelQoSParameters_ExtIEs__extensionValue_PR_PDUSessionID)
7486          {
7487             qosToAdd->pduSessionId = qosIeExt->list.array[qosCntIdx]->extensionValue.choice.PDUSessionID;
7488             DU_LOG("\nDEBUG -->  DU_F1AP : extractQosInfo: PDU SessionID:%d",qosToAdd->pduSessionId);
7489          }
7490       }
7491    }
7492    qosToAdd->ulPduSessAggMaxBitRate = 0;
7493 }
7494
7495 /*******************************************************************
7496  *
7497  * @brief Function to extract GTP Tunnel Info from CU
7498  *
7499  * @details
7500  *
7501  *    Function : extractUpTnlInfo
7502  *
7503  *    Functionality: Function to extract GTP Tunnel Info from CU
7504  *
7505  * @params[in] F1AP message
7506  * @return ROK/RFAILED
7507  *
7508  * ****************************************************************/
7509
7510 uint8_t extractUpTnlInfo(uint8_t drbId, uint8_t configType,\
7511    ULUPTNLInformation_ToBeSetup_List_t *tnlInfo, UpTnlCfg *upTnlInfo)
7512 {
7513    uint8_t tnlIdx;
7514    uint32_t ipv4_du = 0;
7515    GTPTunnel_t *gtpTunnel = NULLP;
7516
7517    upTnlInfo->drbId = drbId;
7518    upTnlInfo->configType = configType;
7519 #ifdef O1_ENABLE
7520    cmInetAddr((S8*)g_cfg.DU_IPV4_Addr, &ipv4_du);
7521 #else
7522    cmInetAddr((char *)DU_IP_V4_ADDR, &ipv4_du);
7523 #endif
7524
7525    for(tnlIdx=0; tnlIdx < tnlInfo->list.count; tnlIdx++)
7526    {
7527       if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
7528       {
7529          if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel)
7530          {
7531             gtpTunnel = tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel;
7532             DU_ALLOC(upTnlInfo->tnlCfg1, sizeof(GtpTnlCfg));
7533             if(upTnlInfo->tnlCfg1 == NULLP)
7534             {
7535                DU_LOG("\nERROR  -->  F1AP : extractUpTnlInfo: Failed to allocate mmeory for tunnel cfg 1");
7536                return RFAILED;
7537             }
7538             bitStringToInt(&gtpTunnel->transportLayerAddress, &upTnlInfo->tnlCfg1->ulTnlAddress);
7539             upTnlInfo->tnlCfg1->dlTnlAddress = ipv4_du;
7540             if(gtpTunnel->gTP_TEID.size > 0)
7541             {
7542                teIdStringToInt(gtpTunnel->gTP_TEID.buf, &upTnlInfo->tnlCfg1->teId);
7543             }
7544          }
7545          break;
7546       }
7547    }
7548    return ROK;
7549 }
7550 /*******************************************************************
7551 *
7552 * @brief Function to extract Drb Qos Cfg Info from CU
7553 *
7554 * @details
7555 *
7556 *    Function : extractDrbQosCfg
7557 *
7558 *    Functionality: Function to extract Drb Qos Cfg Info from CU
7559 *
7560 * @params[in] DRB_Information_t *drbInfo, LcCfg *macLcToAdd
7561 * @return ROK/RFAILED
7562 *
7563 * ****************************************************************/
7564
7565 uint8_t extractDrbQosCfg(DRB_Information_t *drbInfo, LcCfg *macLcToAdd )
7566 {
7567    if(!macLcToAdd->drbQos)
7568    {
7569       DU_ALLOC_SHRABL_BUF(macLcToAdd->drbQos, sizeof(DrbQosInfo));
7570       if(macLcToAdd->drbQos == NULLP)
7571       {
7572          DU_LOG("\nERROR  -->  DUAPP:Memory failed at allocating DrbQos at extractDrbQosCfg()");
7573          return RFAILED;
7574       }
7575
7576    }
7577    if(drbInfo->dRB_QoS.qoS_Characteristics.present == QoS_Characteristics_PR_non_Dynamic_5QI)
7578    {
7579       extractQosInfo(macLcToAdd->drbQos, &drbInfo->dRB_QoS);
7580       macLcToAdd->dlLcCfg.lcp = macLcToAdd->drbQos->ngRanRetPri.priorityLevel;
7581    }
7582    if(!macLcToAdd->snssai)
7583    {
7584       DU_ALLOC_SHRABL_BUF(macLcToAdd->snssai, sizeof(Snssai));
7585       if(macLcToAdd->snssai == NULLP)
7586       {
7587          DU_LOG("\nERROR  -->  DUAPP : Memory failed at allocating SNSSAI at extractDrbQosCfg()");
7588          return RFAILED;
7589       }
7590    }
7591    memcpy(&macLcToAdd->snssai->sst, drbInfo->sNSSAI.sST.buf, \
7592          drbInfo->sNSSAI.sST.size);
7593    if(drbInfo->sNSSAI.sD)
7594    {
7595       memcpy(macLcToAdd->snssai->sd, drbInfo->sNSSAI.sD->buf, \
7596             drbInfo->sNSSAI.sD->size);
7597    }
7598    return ROK;
7599 }
7600 /*******************************************************************
7601  *
7602  * @brief Function to extract DRB info received from CU
7603  *
7604  * @details
7605  *
7606  *    Function : extractDrbCfg
7607  *
7608  *    Functionality: Function to extract DRB info received from CU
7609  *
7610  * @params[in] F1AP message
7611  * @return void
7612  *
7613  * ****************************************************************/
7614 uint8_t extractDrbCfg(DRBs_ToBeSetup_Item_t *drbItem, DRBs_ToBeSetupMod_Item_t *drbSetupModItem,\
7615 DRBs_ToBeModified_Item_t *drbModItem,  LcCfg *macLcToAdd, UpTnlCfg *upTnlInfo)
7616 {
7617    DRB_Information_t *drbInfo = NULLP;
7618
7619    if(drbItem != NULLP)
7620    {
7621       if(extractUpTnlInfo(drbItem->dRBID, CONFIG_ADD, &drbItem->uLUPTNLInformation_ToBeSetup_List, upTnlInfo) != ROK)
7622       {
7623          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7624          return RFAILED;
7625       }
7626       if(drbItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7627       {
7628          if(drbItem->qoSInformation.choice.choice_extension->value.present == QoSInformation_ExtIEs__value_PR_DRB_Information)
7629          {
7630             drbInfo = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7631             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7632             {
7633                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7634                return RFAILED;
7635             }
7636          }
7637       }
7638    }
7639    else if(drbSetupModItem != NULLP)
7640    {
7641       if(extractUpTnlInfo(drbSetupModItem->dRBID, CONFIG_ADD, &drbSetupModItem->uLUPTNLInformation_ToBeSetup_List,\
7642       upTnlInfo) != ROK)
7643       {
7644          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7645          return RFAILED;
7646       }
7647       if(drbSetupModItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7648       {
7649          if(drbSetupModItem->qoSInformation.choice.choice_extension->value.present ==\
7650          QoSInformation_ExtIEs__value_PR_DRB_Information)
7651          {
7652             drbInfo = &drbSetupModItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7653             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7654             {
7655                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7656                return RFAILED;
7657             }
7658
7659          }
7660       }
7661    }
7662    else if(drbModItem != NULLP)
7663    {
7664       if(extractUpTnlInfo(drbModItem->dRBID, CONFIG_MOD, &drbModItem->uLUPTNLInformation_ToBeSetup_List,\
7665       upTnlInfo) != ROK)
7666       {
7667          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7668          return RFAILED;
7669       }
7670       if(drbModItem->qoSInformation != NULLP)
7671       {
7672          if(drbModItem->qoSInformation->present == QoSInformation_PR_choice_extension)
7673          {
7674             if(drbModItem->qoSInformation->choice.choice_extension->value.present ==\
7675                   QoSInformation_ExtIEs__value_PR_DRB_Information)
7676             {
7677                drbInfo = &drbModItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information;
7678                if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7679                {
7680                   DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7681                   return RFAILED;
7682                }
7683
7684             }
7685          }
7686       }
7687    }
7688    return ROK;
7689 }
7690
7691 /*******************************************************************
7692  *
7693  * @brief Function to extract RB info received from CU
7694  *
7695  * @details
7696  *
7697  *    Function : extractMacRbCfg
7698  *
7699  *    Functionality: Function to extract RB info received from CU
7700  *
7701  * @params[in] F1AP message
7702  * @return ROK/RFAILED
7703  *
7704  * ****************************************************************/
7705
7706 uint8_t extractMacRbCfg(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbCfg,\
7707 DRBs_ToBeSetupMod_Item_t *drbSetupModCfg,  DRBs_ToBeModified_Item_t *drbModCfg, LogicalChannelConfig_t *ulLcCfg, LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7708 {
7709    if(drbCfg != NULLP)
7710    {
7711       if(extractDrbCfg(drbCfg, NULL, NULL, lcCfg, upTnlInfo) != ROK)
7712       {
7713          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7714          return RFAILED;
7715       }
7716    }
7717    else if(drbSetupModCfg != NULLP)
7718    {
7719       if(extractDrbCfg(NULL, drbSetupModCfg, NULL, lcCfg, upTnlInfo) != ROK)
7720       {
7721          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7722          return RFAILED;
7723       }
7724    }
7725    else if(drbModCfg != NULLP)
7726    {
7727       if(extractDrbCfg(NULL, NULL, drbModCfg, lcCfg, upTnlInfo) != ROK)
7728       {
7729          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7730          return RFAILED;
7731       }
7732    }
7733    else
7734    {
7735       lcCfg->drbQos = NULLP;
7736       lcCfg->snssai = NULLP;
7737       if(lcCfg->lcId == SRB2_LCID)
7738          lcCfg->dlLcCfg.lcp = LC_PRIORITY_3;
7739       else
7740          lcCfg->dlLcCfg.lcp = LC_PRIORITY_1;
7741    }
7742    if(ulLcCfg)
7743    {
7744       lcCfg->ulLcCfgPres = true;
7745       extractUlLcCfg(&lcCfg->ulLcCfg, ulLcCfg);
7746    }
7747    else
7748       lcCfg->ulLcCfgPres = false;
7749    return ROK;
7750 }
7751
7752 /*******************************************************************
7753  *
7754  * @brief Function processing LC config info received from CU
7755  *
7756  * @details
7757  *
7758  *    Function : procMacLcCfg
7759  *
7760  *    Functionality: Function processing LC config info received from CU
7761  *
7762  * @params[in] F1AP message
7763  * @return ROK/RFAILED
7764  *
7765  * ****************************************************************/
7766
7767 uint8_t procMacLcCfg(uint8_t lcId, uint8_t rbType, uint8_t configType, DRBs_ToBeSetup_Item_t *drbItem,\
7768 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, LogicalChannelConfig_t *ulLcCfg,\
7769 LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7770 {
7771    uint8_t ret = ROK;
7772
7773    lcCfg->lcId = lcId;
7774    lcCfg->configType = configType;
7775    if(rbType == RB_TYPE_SRB)
7776    {
7777       ret = extractMacRbCfg(lcId, NULL, NULL, NULL, ulLcCfg, lcCfg, NULL);
7778    }
7779    else if(rbType == RB_TYPE_DRB)
7780    {
7781       if(drbItem != NULL)
7782         ret = extractMacRbCfg(lcId, drbItem, NULL, NULL, ulLcCfg, lcCfg, upTnlInfo);
7783       else if(drbSetupModItem != NULL)
7784         ret = extractMacRbCfg(lcId, NULL, drbSetupModItem, NULL, ulLcCfg, lcCfg, upTnlInfo);
7785       else if(drbModItem != NULL)
7786         ret = extractMacRbCfg(lcId, NULL, NULL, drbModItem, ulLcCfg, lcCfg, upTnlInfo);
7787    }
7788    return ret;
7789 }
7790
7791 /*******************************************************************
7792  *
7793  * @brief Function to extract Rlc cfg To Add/Mod in CellGrp Info
7794  *
7795  * @details
7796  *
7797  *    Function : extractRlcCfgToAddMod
7798  *
7799  *    Functionality: Function to extract Rlc cfg To Add/Mod in CellGrp Info
7800  *
7801  * @params[in] CellGroupConfigRrc__rlc_BearerTo pointer
7802  *             DuUeCfg Pointer
7803  * @return ROK/RFAILED
7804  *
7805  * ****************************************************************/
7806
7807 uint8_t extractRlcCfgToAddMod(struct CellGroupConfigRrc__rlc_BearerToAddModList *lcCfg, DuUeCfg *ueCfgDb)
7808 {
7809   uint8_t idx, rbId, lcId, rlcMode, rbType;
7810   RLC_Config_t *f1RlcCfg = NULLP;
7811   LogicalChannelConfig_t *macUlLcCfg = NULLP;
7812
7813   for(idx = 0; idx < lcCfg->list.count; idx++)
7814   {
7815      lcId = lcCfg->list.array[idx]->logicalChannelIdentity;
7816      if(lcCfg->list.array[idx]->servedRadioBearer)
7817      {
7818         /* RadioBearer for SRB/DRB */
7819         if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7820         RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
7821         {
7822            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.srb_Identity;
7823            rbType = RB_TYPE_SRB;
7824         }
7825         else if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7826         RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
7827         {
7828            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.drb_Identity;
7829            rbType = RB_TYPE_DRB;
7830         }
7831         else
7832         {
7833            DU_LOG("\nERROR  -->  No components present in Bearer config to ADD/MOD");
7834            return RFAILED;
7835         }
7836         /* MAC UL LC Config */
7837         if(lcCfg->list.array[idx]->mac_LogicalChannelConfig)
7838         {
7839            macUlLcCfg = lcCfg->list.array[idx]->mac_LogicalChannelConfig;
7840         }
7841      }
7842      else
7843      {
7844         DU_LOG("\nERROR  -->  DUAPP: Received RadioBearer config is NULL");
7845         return RFAILED;
7846      }
7847      /* RLC Mode Config */
7848      if(lcCfg->list.array[idx]->rlc_Config)
7849      {
7850         rlcMode  = lcCfg->list.array[idx]->rlc_Config->present;
7851         f1RlcCfg = lcCfg->list.array[idx]->rlc_Config;
7852      }
7853
7854      /* Filling RLC/MAC Config*/
7855      memset(&ueCfgDb->macLcCfg[idx], 0, sizeof(LcCfg));
7856      memset(&ueCfgDb->rlcLcCfg[idx], 0, sizeof(RlcBearerCfg));
7857      procRlcLcCfg(rbId, lcId, rbType, rlcMode, CONFIG_UNKNOWN, f1RlcCfg, &(ueCfgDb->rlcLcCfg[idx]));
7858      if(procMacLcCfg(lcId, rbType, CONFIG_UNKNOWN, NULL, NULL, NULL, macUlLcCfg, &ueCfgDb->macLcCfg[idx], NULL) != ROK)
7859      {
7860         DU_LOG("\nERROR  -->  DU APP : Failed while filling MAC LC config at extractRlcCfgToAddMod()");
7861         return RFAILED;
7862      }
7863      (ueCfgDb->numRlcLcs)++;
7864      (ueCfgDb->numMacLcs)++;
7865          DU_LOG("\nDEBUG  -> DUAPP: extractRlcCfgToAddMod:RBType:%d, DrbID: %d,lcId:%d, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
7866                             rbType, rbId, lcId, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
7867   }
7868   //TODO: To send the failure cause in UeContextSetupRsp
7869   return ROK;
7870 }
7871
7872 /*******************************************************************
7873  *
7874  * @brief DeAlloc pdsch serv cell config info
7875  *
7876  * @details
7877  *
7878  *    Function : freeMacPdschServCellInfo
7879  *
7880  *    Functionality: DeAlloc pdsch serv cell config info
7881  *
7882  * @params[in] PdschServCellCfg pointer
7883  * @return void
7884  *
7885  * ****************************************************************/
7886
7887 void freeMacPdschServCellInfo(PdschServCellCfg *pdsch)
7888 {
7889    if(pdsch->xOverhead)
7890    {
7891       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->xOverhead, sizeof(PdschXOverhead));
7892    }
7893    if(pdsch->codeBlkGrpFlushInd)
7894    {
7895       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->codeBlkGrpFlushInd, sizeof(bool));
7896    }
7897    if(pdsch->maxCodeBlkGrpPerTb)
7898    {
7899       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
7900    }
7901    if(pdsch->maxMimoLayers)
7902    {
7903       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxMimoLayers, sizeof(uint8_t));
7904    }
7905 }
7906
7907 /*******************************************************************
7908  *
7909  * @brief Free Serving cell Info
7910  *
7911  * @details
7912  *
7913  *    Function : freeMacServingCellInfo
7914  *
7915  *    Functionality: Free Serving cell Info
7916  *
7917  * @params[in] ServCellCfgInfo *srvCellCfg
7918  * @return void
7919  *
7920  * ****************************************************************/
7921 void freeMacServingCellInfo(ServCellCfgInfo *srvCellCfg)
7922 {
7923    uint8_t timeDomRsrcIdx;
7924
7925    if(srvCellCfg->initDlBwp.pdschPresent)
7926    {
7927       for(timeDomRsrcIdx = 0; timeDomRsrcIdx < srvCellCfg->initDlBwp.pdschCfg.numTimeDomRsrcAlloc; timeDomRsrcIdx++)
7928       {
7929          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, \
7930             srvCellCfg->initDlBwp.pdschCfg.timeDomRsrcAllociList[timeDomRsrcIdx].k0, sizeof(uint8_t));
7931       }
7932    }
7933
7934    freeMacPdschServCellInfo(&srvCellCfg->pdschServCellCfg);
7935    if(srvCellCfg->bwpInactivityTmr)
7936    {
7937       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
7938    }
7939
7940    if(srvCellCfg->initUlBwp.pucchPresent)
7941    {
7942       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->initUlBwp.pucchCfg.dlDataToUlAck, sizeof(PucchDlDataToUlAck));
7943    }
7944 }
7945
7946 /*******************************************************************
7947  *
7948  * @brief Free cell Grp Cfg Info
7949  *
7950  * @details
7951  *
7952  *    Function : freeUeReCfgCellGrpInfo
7953  *
7954  *    Functionality: Free cell Grp Cfg Info
7955  *
7956  * @params[in] MacUeCfg*  duUeCfg
7957  * @return void
7958  *
7959  * ****************************************************************/
7960
7961 void freeUeReCfgCellGrpInfo(MacUeCfg *macUeCfg)
7962 {
7963    freeMacServingCellInfo(&macUeCfg->spCellCfg.servCellCfg);
7964 }
7965
7966 /*******************************************************************
7967  *
7968  * @brief Fills Reconfig SchReqReConfig
7969  *
7970  * @details
7971  *
7972  *    Function : extractSchReqReConfig
7973  *
7974  *    Functionality: Fills Reconfig SchReqReConfig
7975  *
7976  * @params[in] SchedulingRequestConfig_t *cuSchedReq
7977  *             SchedReqCfg*  macSchedReq
7978  * @return void
7979  *
7980  * ****************************************************************/
7981 void extractSchReqReConfig(SchedulingRequestConfig_t *cuSchedReq, SchedReqCfg *macSchedReq)
7982 {
7983    uint8_t schReqIdx = 0;
7984    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqListToAdd = NULLP;
7985    struct SchedulingRequestConfig__schedulingRequestToReleaseList *schReqListToRel = NULLP;
7986
7987    if(cuSchedReq->schedulingRequestToAddModList)
7988    {
7989       schReqListToAdd = cuSchedReq->schedulingRequestToAddModList;
7990       if(schReqListToAdd->list.count)
7991       {
7992          macSchedReq->addModListCount = schReqListToAdd->list.count;
7993          for(schReqIdx = 0; schReqIdx < schReqListToAdd->list.count; schReqIdx++)
7994          {
7995             macSchedReq->addModList[schReqIdx].schedReqId = \
7996                schReqListToAdd->list.array[schReqIdx]->schedulingRequestId;
7997             macSchedReq->addModList[schReqIdx].srProhibitTmr = \
7998                *(schReqListToAdd->list.array[schReqIdx]->sr_ProhibitTimer);
7999             macSchedReq->addModList[schReqIdx].srTransMax    =\
8000                schReqListToAdd->list.array[schReqIdx]->sr_TransMax;
8001          }
8002       }
8003    }
8004    /* Scheduling Req To release */
8005    if(cuSchedReq->schedulingRequestToReleaseList)
8006    {
8007       schReqListToRel = cuSchedReq->schedulingRequestToReleaseList;
8008       if(schReqListToRel->list.count)
8009       {
8010          macSchedReq->relListCount = schReqListToRel->list.count;
8011          for(schReqIdx = 0; schReqIdx < schReqListToRel->list.count; schReqIdx++)
8012          {
8013             macSchedReq->relList[schReqIdx] = \
8014                *schReqListToRel->list.array[schReqIdx];
8015          }
8016       }
8017    }
8018 }
8019
8020 /*******************************************************************
8021  *
8022  * @brief Fills TagReconfig
8023  *
8024  * @details
8025  *
8026  *    Function : extractTagReconfig
8027  *
8028  *    Functionality: Fills extractTagReconfig
8029  *
8030  * @params[in] TAG_Config_t *cuTagCfg
8031  *             TagCfg *macTagCfg
8032  * @return void
8033  *
8034  * ****************************************************************/
8035
8036 void extractTagReconfig(TAG_Config_t *cuTagCfg, TagCfg *macTagCfg)
8037 {
8038   uint8_t tagIdx = 0;
8039   struct TAG_Config__tag_ToAddModList  *tagListToAddMod = NULLP;
8040   struct TAG_Config__tag_ToReleaseList *tagListToRel = NULLP;
8041
8042   /* Tag config to AddMod */
8043   if(cuTagCfg->tag_ToAddModList)
8044   {
8045      tagListToAddMod = cuTagCfg->tag_ToAddModList;
8046      if(tagListToAddMod->list.count)
8047      {
8048         macTagCfg->addModListCount = tagListToAddMod->list.count;
8049         for(tagIdx = 0; tagIdx < tagListToAddMod->list.count; tagIdx++)
8050         {
8051            macTagCfg->addModList[tagIdx].tagId =\
8052               tagListToAddMod->list.array[tagIdx]->tag_Id;
8053            macTagCfg->addModList[tagIdx].timeAlignTimer = \
8054
8055               tagListToAddMod->list.array[tagIdx]->timeAlignmentTimer;
8056         }
8057      }
8058   }
8059   /* Tag config to release */
8060   if(cuTagCfg->tag_ToReleaseList)
8061   {
8062      tagListToRel = cuTagCfg->tag_ToReleaseList;
8063      if(tagListToRel->list.count)
8064      {
8065         macTagCfg->relListCount = tagListToRel->list.count;
8066         for(tagIdx = 0; tagIdx < tagListToRel->list.count; tagIdx++)
8067         {
8068            macTagCfg->relList[tagIdx] = *tagListToRel->list.array[tagIdx];
8069         }
8070      }
8071   }
8072 }
8073
8074 /*******************************************************************
8075  *
8076  * @brief Fills PdcchCfg received by CU
8077  *
8078  * @details
8079  *
8080  *    Function : extractPdcchCfg
8081  *
8082  *    Functionality: Fills PdcchCfg received  by CU
8083  *
8084  * @params[in] PDCCH_Config_t *cuPdcchCfg,
8085  *             PdcchConfig *duPdcchCfg
8086  * @return void
8087  *
8088  * ****************************************************************/
8089
8090 void extractPdcchCfg(PDCCH_Config_t *cuPdcchCfg, PdcchConfig *macPdcchCfg)
8091 {
8092    uint8_t cRsetIdx = 0;
8093    uint8_t srchSpcIdx = 0;
8094
8095    struct PDCCH_Config__controlResourceSetToAddModList *cRsetToAddModList = NULLP;
8096    struct PDCCH_Config__controlResourceSetToReleaseList *cRsetToRelList = NULLP;
8097    struct PDCCH_Config__searchSpacesToAddModList *srchSpcToAddModList = NULLP;
8098    struct PDCCH_Config__searchSpacesToReleaseList *srchSpcToRelList = NULLP;
8099
8100
8101    /* Control Resource Set To Add/Mod List */
8102    if(cuPdcchCfg->controlResourceSetToAddModList)
8103    {
8104       cRsetToAddModList = cuPdcchCfg->controlResourceSetToAddModList;
8105       if(cRsetToAddModList->list.count)
8106       {
8107          macPdcchCfg->numCRsetToAddMod = cRsetToAddModList->list.count;
8108          for(cRsetIdx = 0; cRsetIdx < cRsetToAddModList->list.count; cRsetIdx++)
8109          {
8110             macPdcchCfg->cRSetToAddModList[cRsetIdx].cRSetId = \
8111               cRsetToAddModList->list.array[cRsetIdx]->controlResourceSetId;
8112             bitStringToInt(&cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources,\
8113                macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc);
8114             macPdcchCfg->cRSetToAddModList[cRsetIdx].duration = \
8115               cRsetToAddModList->list.array[cRsetIdx]->duration;
8116
8117             macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType = \
8118               cRsetToAddModList->list.array[cRsetIdx]->cce_REG_MappingType.present;
8119             if(macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType == CCE_REG_MAPPINGTYPE_PR_INTERLEAVED)
8120             {
8121                //TODO: handle the case for Interleaved
8122             }
8123             macPdcchCfg->cRSetToAddModList[cRsetIdx].precoderGranularity = \
8124               cRsetToAddModList->list.array[cRsetIdx]->precoderGranularity;
8125             if(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID)
8126             {
8127                macPdcchCfg->cRSetToAddModList[cRsetIdx].dmrsScramblingId= \
8128                   *(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID);
8129             }
8130          }
8131       }
8132
8133    }
8134    /* Control Resource Set To Release List */
8135    if(cuPdcchCfg->controlResourceSetToReleaseList)
8136    {
8137       cRsetToRelList = cuPdcchCfg->controlResourceSetToReleaseList;
8138       if(cRsetToRelList->list.count)
8139       {
8140          macPdcchCfg->numCRsetToRel = cRsetToRelList->list.count;
8141          for(cRsetIdx = 0; cRsetIdx < cRsetToRelList->list.count; cRsetIdx++)
8142          {
8143             macPdcchCfg->cRSetToRelList[cRsetIdx] = *(cRsetToRelList->list.array[cRsetIdx]);
8144          }
8145       }
8146    }
8147
8148    /* Search space To Add/Mod List */
8149    if(cuPdcchCfg->searchSpacesToAddModList)
8150    {
8151       srchSpcToAddModList = cuPdcchCfg->searchSpacesToAddModList;
8152       if(srchSpcToAddModList->list.count)
8153       {
8154          macPdcchCfg->numSearchSpcToAddMod = srchSpcToAddModList->list.count;
8155          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToAddModList->list.count; srchSpcIdx++)
8156          {
8157             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceId =\
8158                srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceId;
8159             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].cRSetId =\
8160                *(srchSpcToAddModList->list.array[srchSpcIdx]->controlResourceSetId);
8161             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset)
8162             {
8163                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset =\
8164                   srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset->present;
8165             }
8166             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot)
8167             {
8168                bitStringToInt(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot,\
8169                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSymbolsWithinSlot);
8170             }
8171             if(srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates)
8172             {
8173               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel1 = \
8174                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel1;
8175               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel2 = \
8176                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel2;
8177               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel4 = \
8178                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel4;
8179
8180               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel8 = \
8181                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel8;
8182
8183               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel16 = \
8184                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel16;
8185             }
8186             if(srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType)
8187             {
8188                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType =\
8189                   srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->present;
8190                if(macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType == SEARCHSPACETYPE_PR_UE_SPECIFIC)
8191                {
8192                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].ueSpecificDciFormat =\
8193                      srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->choice.ue_Specific->dci_Formats;
8194                }
8195
8196             }
8197          }
8198       }
8199    }
8200    /* Search space To Rel List */
8201    if(cuPdcchCfg->searchSpacesToReleaseList)
8202    {
8203       srchSpcToRelList = cuPdcchCfg->searchSpacesToReleaseList;
8204       if(srchSpcToRelList->list.count)
8205       {
8206          macPdcchCfg->numSearchSpcToRel = srchSpcToRelList->list.count;
8207          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToRelList->list.count; srchSpcIdx++)
8208          {
8209             macPdcchCfg->searchSpcToRelList[srchSpcIdx] =\
8210                *(srchSpcToRelList->list.array[srchSpcIdx]);
8211          }
8212       }
8213    }
8214 }
8215
8216 /*******************************************************************
8217  *
8218  * @brief Fills PdschCfg received by CU
8219  *
8220  * @details
8221  *
8222  *    Function : extractPdschCfg
8223  *
8224  *    Functionality: Fills PdschCfg received  by CU
8225  *
8226  * @params[in] PDSCH_Config_t *cuPdschCfg = Information which is send by CU,
8227  *                   which we have stored in F1UeContextSetupDb,
8228  *             PdschConfig *macPdschCfg = Used to Store the information which
8229  *                   needs to send in other layer, as well as this can be the variable
8230  *                   which stores the information in DuCb,
8231  *             PdschConfig *storedPdschCfg =  Null in case of sending the
8232  *                   information to other layer else it will have stored pdsch
8233  *                   configuration in copyOfmacUeCfg.
8234  * @return void
8235  *
8236  * ****************************************************************/
8237
8238 void extractPdschCfg(PDSCH_Config_t *cuPdschCfg, PdschConfig *macPdschCfg, PdschConfig *storedPdschCfg)
8239 {
8240    uint8_t timeDomIdx;
8241    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAlloc = NULLP;
8242
8243    if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
8244    {
8245       if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->present == \
8246             PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup)
8247       {
8248          if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup)
8249          {
8250             macPdschCfg->dmrsDlCfgForPdschMapTypeA.addPos = \
8251                *(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_AdditionalPosition);
8252          }
8253       }
8254    }
8255    macPdschCfg->resourceAllocType = cuPdschCfg->resourceAllocation;
8256    if(cuPdschCfg->pdsch_TimeDomainAllocationList)
8257    {
8258       timeDomAlloc = cuPdschCfg->pdsch_TimeDomainAllocationList;
8259       if(timeDomAlloc->present ==\
8260             PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup)
8261       {
8262          if(timeDomAlloc->choice.setup)
8263          {
8264             macPdschCfg->numTimeDomRsrcAlloc  = timeDomAlloc->choice.setup->list.count;
8265             for(timeDomIdx = 0; timeDomIdx < timeDomAlloc->choice.setup->list.count; timeDomIdx++)
8266             {
8267                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 = NULLP;
8268                if(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0)
8269                {
8270                   if(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 == NULL)
8271                   {
8272                      if(storedPdschCfg)
8273                      {
8274                         if(storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
8275                         {
8276                            macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 =\
8277                            storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0;
8278                         }
8279                         else
8280                         {
8281                            DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
8282                         }
8283                      }
8284                      else
8285                      {
8286                         DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
8287                      }
8288                      if(!macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
8289                      {
8290                         DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for k0 at extractPdschCfg()");
8291                         return RFAILED;
8292                      }
8293                   }
8294                   *(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0) = \
8295                   *(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0);
8296                }
8297                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
8298                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
8299                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
8300                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8301             }
8302          }
8303       }
8304    }
8305    macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
8306    if(cuPdschCfg->maxNrofCodeWordsScheduledByDCI)
8307       macPdschCfg->numCodeWordsSchByDci = *(cuPdschCfg->maxNrofCodeWordsScheduledByDCI);
8308    if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_staticBundling)
8309    {
8310       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
8311       if(cuPdschCfg->prb_BundlingType.choice.staticBundling)
8312       {
8313          if(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize)
8314          {
8315             macPdschCfg->bundlingInfo.StaticBundling.size = \
8316                *(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize);
8317          }
8318       }
8319    }
8320    else if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_dynamicBundling)
8321    {
8322       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
8323    }
8324
8325 }
8326
8327 /*******************************************************************
8328  *
8329  * @brief Fills PdschServingCellCfg received by CU
8330  *
8331  * @details
8332  *
8333  *    Function : extractPdschServingCellCfg
8334  *
8335  *    Functionality: Fills PdschCfg received  by CU
8336  *
8337  * @params[in] PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg,
8338  *             PdschServCellCfg *macUePdschSrvCellCfg
8339  * @return ROK/RFAILED
8340  *
8341  * ****************************************************************/
8342
8343 uint8_t extractPdschServingCellCfg(PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg, PdschServCellCfg *macUePdschSrvCellCfg)
8344 {
8345    if(cuPdschSrvCellCfg->codeBlockGroupTransmission)
8346    {
8347       if(cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup)
8348       {
8349          if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
8350          {
8351             *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
8352                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
8353          }
8354          else
8355          {
8356             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
8357             if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
8358             {
8359                *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
8360                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
8361             }
8362             else
8363             {
8364                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
8365                return RFAILED;
8366             }
8367          }
8368          if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
8369          {
8370             *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
8371                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
8372          }
8373          else
8374          {
8375             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->codeBlkGrpFlushInd , sizeof(bool));
8376             if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
8377             {
8378                *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
8379                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
8380             }
8381             else
8382             {
8383                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
8384                return RFAILED;
8385             }
8386          }
8387       }
8388    }
8389    if(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH)
8390    {
8391       macUePdschSrvCellCfg->numHarqProcForPdsch = *(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH);
8392    }
8393    if(cuPdschSrvCellCfg->ext1)
8394    {
8395       if(cuPdschSrvCellCfg->ext1->maxMIMO_Layers)
8396       {
8397         if(macUePdschSrvCellCfg->maxMimoLayers)
8398         {
8399            *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
8400         }
8401         else
8402         {
8403            DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxMimoLayers, sizeof(uint8_t));
8404            if(macUePdschSrvCellCfg->maxMimoLayers)
8405            {
8406               *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
8407            }
8408            else
8409            {
8410               DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
8411               return RFAILED;
8412            }
8413         }
8414       }
8415    }
8416    if(cuPdschSrvCellCfg->xOverhead)
8417    {
8418       if(macUePdschSrvCellCfg->xOverhead)
8419       {
8420          *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
8421       }
8422       else
8423       {
8424          DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->xOverhead, sizeof(PdschXOverhead));
8425          if(macUePdschSrvCellCfg->xOverhead)
8426          {
8427             *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
8428          }
8429          else
8430          {
8431             DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
8432             return RFAILED;
8433          }
8434       }
8435    }
8436    return ROK;
8437 }
8438
8439 /*******************************************************************
8440  *
8441  * @brief Fills PuschCfg received by CU
8442  *
8443  * @details
8444  *
8445  *    Function : extractPuschCfg
8446  *
8447  *    Functionality: Fills PuschCfg received  by CU
8448  *
8449  * @params[in] BWP_UplinkDedicated__pusch_Config *cuPuschCfg,
8450  *             PuschCfg *macPuschCfg
8451  * @return void
8452  *
8453  * ****************************************************************/
8454
8455 void extractPuschCfg(struct BWP_UplinkDedicated__pusch_Config *cuPuschCfg, PuschCfg *macPuschCfg)
8456 {
8457    uint8_t timeDomIdx = 0;
8458    DMRS_UplinkConfig_t *dmrsUlCfg = NULLP;
8459    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList = NULLP;
8460
8461    if(cuPuschCfg->present == BWP_UplinkDedicated__pusch_Config_PR_setup)
8462    {
8463       if(cuPuschCfg->choice.setup)
8464       {
8465          if(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH)
8466          {
8467              macPuschCfg->dataScramblingId = \
8468                 *(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH);
8469          }
8470          if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA)
8471          {
8472             if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->present == PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup)
8473             {
8474                if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup)
8475                {
8476                   dmrsUlCfg = (cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup);
8477                   if(dmrsUlCfg->dmrs_AdditionalPosition)
8478                   {
8479                      macPuschCfg->dmrsUlCfgForPuschMapTypeA.addPos =\
8480                         *(dmrsUlCfg->dmrs_AdditionalPosition);
8481                   }
8482                   if(dmrsUlCfg->transformPrecodingDisabled)
8483                   {
8484                      if(dmrsUlCfg->transformPrecodingDisabled->scramblingID0)
8485                      {
8486                         macPuschCfg->dmrsUlCfgForPuschMapTypeA.transPrecodDisabled.scramblingId0 = \
8487                            *(dmrsUlCfg->transformPrecodingDisabled->scramblingID0);
8488                      }
8489                   }
8490                }
8491             }
8492          }
8493          /*Res Alloc Type for UL */
8494          if(cuPuschCfg->choice.setup->resourceAllocation)
8495          {
8496             macPuschCfg->resourceAllocType = \
8497                cuPuschCfg->choice.setup->resourceAllocation;
8498          }
8499          if(cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList)
8500          {
8501             timeDomAllocList = cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList;
8502             if(timeDomAllocList->present == PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup)
8503             {
8504                if(timeDomAllocList->choice.setup)
8505                {
8506                   macPuschCfg->numTimeDomRsrcAlloc = timeDomAllocList->choice.setup->list.count;
8507                   for(timeDomIdx = 0; timeDomIdx <timeDomAllocList->choice.setup->list.count; timeDomIdx++)
8508                   {
8509                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].k2 = \
8510                         *(timeDomAllocList->choice.setup->list.array[timeDomIdx]->k2);
8511                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].mappingType = \
8512                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->mappingType;
8513                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbolAndLength = \
8514                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8515                   }
8516                }
8517             }
8518          }
8519          if(cuPuschCfg->choice.setup->transformPrecoder)
8520             macPuschCfg->transformPrecoder = *(cuPuschCfg->choice.setup->transformPrecoder);
8521       }
8522    }
8523 }
8524
8525 /*******************************************************************
8526  *
8527  * @brief Function to fill pucch Power Control
8528  *
8529  * @details
8530  *
8531  *    Function : extractPucchPowerControl
8532  *
8533  *    Functionality: Function to fill pucch Power Control
8534  *
8535  * @params[in] PucchPowerControl *pwrCtrl,
8536  *             struct PUCCH_PowerControl *cuPwrCtrlCfg
8537  * @return void
8538  *
8539  * ****************************************************************/
8540
8541 void extractPucchPowerControl(PucchPowerControl *pwrCtrl, struct PUCCH_PowerControl *cuPwrCtrlCfg)
8542 {
8543    uint8_t arrIdx;
8544
8545    if(cuPwrCtrlCfg->deltaF_PUCCH_f0)
8546       pwrCtrl->deltaF_Format0 = *cuPwrCtrlCfg->deltaF_PUCCH_f0;
8547    if(cuPwrCtrlCfg->deltaF_PUCCH_f1)
8548       pwrCtrl->deltaF_Format1 = *cuPwrCtrlCfg->deltaF_PUCCH_f1;
8549    if(cuPwrCtrlCfg->deltaF_PUCCH_f2)
8550       pwrCtrl->deltaF_Format2 = *cuPwrCtrlCfg->deltaF_PUCCH_f2;
8551    if(cuPwrCtrlCfg->deltaF_PUCCH_f3)
8552       pwrCtrl->deltaF_Format3 = *cuPwrCtrlCfg->deltaF_PUCCH_f3;
8553    if(cuPwrCtrlCfg->deltaF_PUCCH_f4)
8554       pwrCtrl->deltaF_Format4 = *cuPwrCtrlCfg->deltaF_PUCCH_f4;
8555    if(cuPwrCtrlCfg->p0_Set)
8556    {
8557       pwrCtrl->p0SetCount = cuPwrCtrlCfg->p0_Set->list.count;
8558       for(arrIdx=0; arrIdx < pwrCtrl->p0SetCount; arrIdx++)
8559       {
8560          pwrCtrl->p0Set[arrIdx].p0PucchId =\
8561             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Id;
8562          pwrCtrl->p0Set[arrIdx].p0PucchVal =\
8563             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Value;
8564       }
8565    }
8566    if(cuPwrCtrlCfg->pathlossReferenceRSs)
8567    {
8568       pwrCtrl->pathLossRefRSListCount = cuPwrCtrlCfg->pathlossReferenceRSs->list.count;
8569       for(arrIdx = 0; arrIdx < pwrCtrl->pathLossRefRSListCount; arrIdx++)
8570       {
8571          pwrCtrl->pathLossRefRSList[arrIdx].pathLossRefRSId =\
8572             cuPwrCtrlCfg->pathlossReferenceRSs->list.array[arrIdx]->pucch_PathlossReferenceRS_Id;
8573       }
8574    }
8575 }
8576
8577  /*******************************************************************
8578  *
8579  * @brief Function to extractResrcSetToAddModList sent by CU
8580  *
8581  * @details
8582  *
8583  *    Function : extractResrcSetToAddModList
8584  *
8585  *    Functionality: Fucntion to extractResrcSetToAddModList
8586  *
8587  * @params[in] PucchResrcSetCfg pointer,
8588  *             struct PUCCH_Config__resourceSetToAddModList pointer
8589  * @return void
8590  *
8591  * ****************************************************************/
8592
8593 void extractResrcSetToAddModList(PucchResrcSetCfg *macRsrcSetList, struct PUCCH_Config__resourceSetToAddModList *cuRsrcSetList)
8594 {
8595    uint8_t arrIdx, rsrcListIdx;
8596
8597    macRsrcSetList->resrcSetToAddModListCount = cuRsrcSetList->list.count;
8598    for(arrIdx = 0; arrIdx < macRsrcSetList->resrcSetToAddModListCount; arrIdx++)
8599    {
8600       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcSetId     =\
8601          cuRsrcSetList->list.array[arrIdx]->pucch_ResourceSetId;
8602       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount =\
8603          cuRsrcSetList->list.array[arrIdx]->resourceList.list.count;
8604       for(rsrcListIdx = 0; rsrcListIdx < macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount; rsrcListIdx++)
8605       {
8606          macRsrcSetList->resrcSetToAddModList[arrIdx].resrcList[rsrcListIdx] =\
8607             *cuRsrcSetList->list.array[arrIdx]->resourceList.list.array[rsrcListIdx];
8608       }
8609       macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize =\
8610          *cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1;
8611    }
8612 }/* End of extractResrcSetToAddModList */
8613
8614 /*******************************************************************
8615  *
8616  * @brief Fills extractResrcToAddModList sent by CU
8617  *
8618  * @details
8619  *
8620  *    Function : extractResrcToAddModList
8621  *
8622  *    Functionality: Fills extractResrcToAddModList
8623  *
8624  * @params[in] PucchResrcCfg pointer,
8625  *             struct PUCCH_Config__resourceToAddModList pointer
8626  * @return ROk/RFAILED
8627  *
8628  * ****************************************************************/
8629
8630 uint8_t extractResrcToAddModList(PucchResrcCfg *macResrcList, struct PUCCH_Config__resourceToAddModList *cuResrcList)
8631 {
8632    uint8_t arrIdx;
8633
8634    macResrcList->resrcToAddModListCount = cuResrcList->list.count;
8635    for(arrIdx = 0; arrIdx < macResrcList->resrcToAddModListCount; arrIdx++)
8636    {
8637       macResrcList->resrcToAddModList[arrIdx].resrcId      =\
8638         cuResrcList->list.array[arrIdx]->pucch_ResourceId;
8639       macResrcList->resrcToAddModList[arrIdx].startPrb     =\
8640         cuResrcList->list.array[arrIdx]->startingPRB;
8641       if(cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping)
8642       {
8643          macResrcList->resrcToAddModList[arrIdx].intraFreqHop =\
8644            *cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping;
8645       }
8646       if(cuResrcList->list.array[arrIdx]->secondHopPRB)
8647       {
8648          macResrcList->resrcToAddModList[arrIdx].secondPrbHop =\
8649            *cuResrcList->list.array[arrIdx]->secondHopPRB;
8650       }
8651       /* PUCCH RSRC FORMAT */
8652       if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format0)
8653       {
8654          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_0;
8655          if(cuResrcList->list.array[arrIdx]->format.choice.format0)
8656          {
8657             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0, sizeof(PucchFormat0));
8658             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0 == NULLP)
8659             {
8660                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
8661                return RFAILED;
8662             }
8663             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->initialCyclicShift =\
8664                cuResrcList->list.array[arrIdx]->format.choice.format0->initialCyclicShift;
8665             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->numSymbols =\
8666                cuResrcList->list.array[arrIdx]->format.choice.format0->nrofSymbols;
8667             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->startSymbolIdx =\
8668                cuResrcList->list.array[arrIdx]->format.choice.format0->startingSymbolIndex;
8669          }
8670       }
8671       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format1)
8672       {
8673          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_1;
8674          if(cuResrcList->list.array[arrIdx]->format.choice.format1)
8675          {
8676             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1, sizeof(PucchFormat1));
8677             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1 == NULLP)
8678             {
8679                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
8680                return RFAILED;
8681             }
8682             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->initialCyclicShift =\
8683                 cuResrcList->list.array[arrIdx]->format.choice.format1->initialCyclicShift;
8684             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->numSymbols =\
8685                 cuResrcList->list.array[arrIdx]->format.choice.format1->nrofSymbols;
8686             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->startSymbolIdx =\
8687                 cuResrcList->list.array[arrIdx]->format.choice.format1->startingSymbolIndex;
8688             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->timeDomOCC =\
8689                 cuResrcList->list.array[arrIdx]->format.choice.format1->timeDomainOCC;
8690          }
8691       }
8692       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format2)
8693       {
8694          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_2;
8695          if(cuResrcList->list.array[arrIdx]->format.choice.format2)
8696          {
8697             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
8698             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2 == NULLP)
8699             {
8700                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
8701                return RFAILED;
8702             }
8703             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numPrbs =\
8704                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofPRBs;
8705             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numSymbols =\
8706                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofSymbols;
8707             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->startSymbolIdx =\
8708                 cuResrcList->list.array[arrIdx]->format.choice.format2->startingSymbolIndex;
8709          }
8710       }
8711       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format3)
8712       {
8713          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_3;
8714          if(cuResrcList->list.array[arrIdx]->format.choice.format3)
8715          {
8716             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
8717             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3 == NULLP)
8718             {
8719                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
8720                return RFAILED;
8721             }
8722             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numPrbs =\
8723                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofPRBs;
8724             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numSymbols =\
8725                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofSymbols;
8726             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->startSymbolIdx =\
8727                 cuResrcList->list.array[arrIdx]->format.choice.format3->startingSymbolIndex;
8728          }
8729       }
8730       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format4)
8731       {
8732          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_4;
8733          if(cuResrcList->list.array[arrIdx]->format.choice.format4)
8734          {
8735             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4, sizeof(PucchFormat4));
8736             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4 == NULLP)
8737             {
8738                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
8739                return RFAILED;
8740             }
8741             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->numSymbols =\
8742                 cuResrcList->list.array[arrIdx]->format.choice.format4->nrofSymbols;
8743             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occLen =\
8744                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Length;
8745             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occIdx =\
8746                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Index;
8747             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->startSymbolIdx =\
8748                 cuResrcList->list.array[arrIdx]->format.choice.format4->startingSymbolIndex;
8749          }
8750       }
8751    }
8752    return ROK;
8753
8754 }/* End of extractResrcToAddModList */
8755
8756 /*******************************************************************
8757  *
8758  * @brief Fills fillPucchSchedReqPeriodAndOffset sent by CU
8759  *
8760  * @details
8761  *
8762  *    Function : fillPucchSchedReqPeriodAndOffset
8763  *
8764  *    Functionality: To fillPucchSchedReqPeriodAndOffset
8765  *
8766  * @params[in] macPeriodicty,
8767  *     SchedulingRequestResourceConfig__periodicityAndOffset pointer
8768  * @return void
8769  *
8770  * ****************************************************************/
8771
8772 void fillPucchSchedReqPeriodAndOffset(uint8_t macPeriodicty, uint16_t  macOffset,\
8773    struct SchedulingRequestResourceConfig__periodicityAndOffset *cuPeriodicty)
8774 {
8775    macPeriodicty = cuPeriodicty->present;
8776    switch(macPeriodicty)
8777    {
8778       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
8779          {
8780             macOffset     = cuPeriodicty->choice.sym2;
8781             break;
8782          }
8783       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
8784          {
8785             macOffset     = cuPeriodicty->choice.sym6or7;
8786             break;
8787          }
8788       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
8789          {
8790             macOffset     = cuPeriodicty->choice.sl1;
8791             break;
8792          }
8793       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
8794          {
8795             macOffset = cuPeriodicty->choice.sl2;
8796             break;
8797          }
8798       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
8799          {
8800             macOffset = cuPeriodicty->choice.sl4;
8801             break;
8802          }
8803       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
8804          {
8805             macOffset = cuPeriodicty->choice.sl5;
8806             break;
8807          }
8808       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
8809          {
8810             macOffset = cuPeriodicty->choice.sl8;
8811             break;
8812          }
8813       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
8814          {
8815             macOffset = cuPeriodicty->choice.sl10;
8816             break;
8817          }
8818       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
8819          {
8820             macOffset = cuPeriodicty->choice.sl16;
8821             break;
8822          }
8823       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
8824          {
8825             macOffset = cuPeriodicty->choice.sl20;
8826             break;
8827          }
8828       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
8829          {
8830             macOffset = cuPeriodicty->choice.sl40;
8831             break;
8832          }
8833       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
8834          {
8835             macOffset = cuPeriodicty->choice.sl80;
8836             break;
8837          }
8838       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
8839          {
8840             macOffset = cuPeriodicty->choice.sl160;
8841             break;
8842          }
8843       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
8844          {
8845             macOffset = cuPeriodicty->choice.sl320;
8846             break;
8847          }
8848       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
8849          {
8850             macOffset = cuPeriodicty->choice.sl640;
8851             break;
8852          }
8853       default :
8854          DU_LOG("\nERROR  -->  F1AP : Invalid periodicity %d", macPeriodicty);
8855    }
8856 }
8857
8858 /*******************************************************************
8859  *
8860  * @brief Function to extractPucchFormatCfg sent by CU
8861  *
8862  * @details
8863  *
8864  *    Function : extractPucchFormatCfg
8865  *
8866  *    Functionality: Function to extractPucchFormatCfg
8867  *
8868  * @params[in] PucchFormatCfg pointer,
8869  *             PUCCH_FormatConfig_t pointer
8870  * @return void
8871  *
8872  * ****************************************************************/
8873
8874 void extractPucchFormatCfg(PucchFormatCfg *macFormatCfg, PUCCH_FormatConfig_t *cuFormatCfg)
8875  {
8876     if(cuFormatCfg->interslotFrequencyHopping)
8877        macFormatCfg->interSlotFreqHop = *cuFormatCfg->interslotFrequencyHopping;
8878     if(cuFormatCfg->additionalDMRS)
8879        macFormatCfg->addDmrs = *cuFormatCfg->additionalDMRS;
8880     if(cuFormatCfg->maxCodeRate)
8881        macFormatCfg->maxCodeRate = *cuFormatCfg->maxCodeRate;
8882     if(cuFormatCfg->nrofSlots)
8883        macFormatCfg->numSlots = *cuFormatCfg->nrofSlots;
8884     if(cuFormatCfg->pi2BPSK)
8885        macFormatCfg->pi2BPSK = *cuFormatCfg->pi2BPSK;
8886     if(cuFormatCfg->simultaneousHARQ_ACK_CSI)
8887        macFormatCfg->harqAckCSI = *cuFormatCfg->simultaneousHARQ_ACK_CSI;
8888  }/* End of extractPucchFormatCfg */
8889
8890 /*******************************************************************
8891  *
8892  * @brief Function to extractSchedReqCfgToAddMod sent by CU
8893  *
8894  * @details
8895  *
8896  *    Function : extractSchedReqCfgToAddMod
8897  *
8898  *    Functionality: Function to extractSchedReqCfgToAddMod
8899  *
8900  * @params[in] PucchSchedReqCfg pointer,
8901  *      PUCCH_Config__schedulingRequestResourceToAddModList pointer
8902  * @return void
8903  *
8904  * ****************************************************************/
8905
8906 void extractSchedReqCfgToAddMod(PucchSchedReqCfg *macSchedReqCfg, struct PUCCH_Config__schedulingRequestResourceToAddModList *cuSchedReqList)
8907 {
8908    uint8_t arrIdx;
8909
8910    macSchedReqCfg->schedAddModListCount = cuSchedReqList->list.count;
8911    for(arrIdx = 0; arrIdx <  macSchedReqCfg->schedAddModListCount; arrIdx++)
8912    {
8913       macSchedReqCfg->schedAddModList[arrIdx].resrcId =\
8914          cuSchedReqList->list.array[arrIdx]->schedulingRequestResourceId;
8915       macSchedReqCfg->schedAddModList[arrIdx].requestId =\
8916          cuSchedReqList->list.array[arrIdx]->schedulingRequestID;
8917       if(cuSchedReqList->list.array[arrIdx]->periodicityAndOffset)
8918       {
8919          fillPucchSchedReqPeriodAndOffset(macSchedReqCfg->schedAddModList[arrIdx].periodicity,\
8920             macSchedReqCfg->schedAddModList[arrIdx].offset, cuSchedReqList->list.array[arrIdx]->periodicityAndOffset);
8921       }
8922       if(cuSchedReqList->list.array[arrIdx]->resource)
8923       {
8924          macSchedReqCfg->schedAddModList[arrIdx].resrc =\
8925             *cuSchedReqList->list.array[arrIdx]->resource;
8926       }
8927    }
8928
8929 }/* End of extractSchedReqCfgToAddMod */
8930
8931  /*******************************************************************
8932  *
8933  * @brief Fills PucchCfg received by CU
8934  *
8935  * @details
8936  *
8937  *    Function : extractPucchCfg
8938  *
8939  *    Functionality: Fills PucchCfg received  by CU
8940  *
8941  * @params[in] BWP_UplinkDedicated__pucch_Config *cuPucchCfg = Information which
8942  *                is send by CU, which we have stored in F1UeContextSetupDb,
8943  *             PucchCfg *macPucchCfg = Used to Store the information which
8944  *                needs to send in other layer, as well as this can be the variable
8945  *                which stores the information in DuCb,
8946  *             PucchCfg *storedPucchCfg = Null in case of sending the
8947  *                information to other layer else it will have Pucch Cfg which
8948  *                we have stored in copyOfmacUeCfg.
8949  * @return ROK/RFAILED
8950  *
8951  * ****************************************************************/
8952
8953 uint8_t extractPucchCfg(struct BWP_UplinkDedicated__pucch_Config *cuPucchCfg, PucchCfg *macPucchCfg,\
8954 PucchCfg *storedPucchCfg)
8955 {
8956    uint8_t arrIdx;
8957
8958    if(cuPucchCfg->present == BWP_UplinkDedicated__pucch_Config_PR_setup)
8959    {
8960       if(cuPucchCfg->choice.setup)
8961       {
8962          /* Resource Set Cfg */
8963          if(cuPucchCfg->choice.setup->resourceSetToAddModList)
8964          {
8965             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrcSet, sizeof(PucchResrcSetCfg));
8966             if(macPucchCfg->resrcSet == NULLP)
8967             {
8968                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
8969                return RFAILED;
8970             }
8971             memset(macPucchCfg->resrcSet, 0, sizeof(PucchResrcSetCfg));
8972             extractResrcSetToAddModList(macPucchCfg->resrcSet, cuPucchCfg->choice.setup->resourceSetToAddModList);
8973          }
8974
8975          /* Resource Cfg */
8976          if(cuPucchCfg->choice.setup->resourceToAddModList)
8977          {
8978             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrc, sizeof(PucchResrcCfg));
8979             if(macPucchCfg->resrc == NULLP)
8980             {
8981                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
8982                return RFAILED;
8983             }
8984             memset(macPucchCfg->resrc, 0, sizeof(PucchResrcCfg));
8985             extractResrcToAddModList(macPucchCfg->resrc, cuPucchCfg->choice.setup->resourceToAddModList);
8986          }
8987
8988          /* Format 1 Cfg */
8989          if(cuPucchCfg->choice.setup->format1)
8990          {
8991             DU_ALLOC_SHRABL_BUF(macPucchCfg->format1, sizeof(PucchFormatCfg));
8992             if(macPucchCfg->format1 == NULLP)
8993             {
8994                DU_LOG("\nERROR --> F1AP : Failed to extract format 1 Cfg in  extractPucchCfg()");
8995                return RFAILED;
8996             }
8997             memset(macPucchCfg->format1, 0, sizeof(PucchFormatCfg));
8998             extractPucchFormatCfg(macPucchCfg->format1,\
8999                cuPucchCfg->choice.setup->format1->choice.setup);
9000          }
9001
9002          /* Format 2 Cfg */
9003          if(cuPucchCfg->choice.setup->format2)
9004          {
9005             DU_ALLOC_SHRABL_BUF(macPucchCfg->format2, sizeof(PucchFormatCfg));
9006             if(macPucchCfg->format2 == NULLP)
9007             {
9008                DU_LOG("\nERROR --> F1AP : Failed to extract format 2 Cfg in  extractPucchCfg()");
9009                return RFAILED;
9010             }
9011             memset(macPucchCfg->format2, 0, sizeof(PucchFormatCfg));
9012             extractPucchFormatCfg(macPucchCfg->format2,\
9013                cuPucchCfg->choice.setup->format2->choice.setup);
9014          }
9015
9016          /* Format 3 Cfg */
9017          if(cuPucchCfg->choice.setup->format3)
9018          {
9019             DU_ALLOC_SHRABL_BUF(macPucchCfg->format3, sizeof(PucchFormatCfg));
9020             if(macPucchCfg->format3 == NULLP)
9021             {
9022                DU_LOG("\nERROR --> F1AP : Failed to extract format 3 Cfg in  extractPucchCfg()");
9023                return RFAILED;
9024             }
9025             memset(macPucchCfg->format3, 0, sizeof(PucchFormatCfg));
9026             extractPucchFormatCfg(macPucchCfg->format3,\
9027                cuPucchCfg->choice.setup->format3->choice.setup);
9028          }
9029
9030          /* Format 4 Cfg */
9031          if(cuPucchCfg->choice.setup->format4)
9032          {
9033             DU_ALLOC_SHRABL_BUF(macPucchCfg->format4, sizeof(PucchFormatCfg));
9034             if(macPucchCfg->format4 == NULLP)
9035             {
9036                DU_LOG("\nERROR --> F1AP : Failed to extract format 4 Cfg in  extractPucchCfg()");
9037                return RFAILED;
9038             }
9039             memset(macPucchCfg->format4, 0, sizeof(PucchFormatCfg));
9040             extractPucchFormatCfg(macPucchCfg->format4,\
9041                cuPucchCfg->choice.setup->format4->choice.setup);
9042          }
9043
9044          /* Sched Req List */
9045          if(cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList)
9046          {
9047             DU_ALLOC_SHRABL_BUF(macPucchCfg->schedReq, sizeof(PucchSchedReqCfg));
9048             if(macPucchCfg->schedReq == NULLP)
9049             {
9050                DU_LOG("\nERROR --> F1AP : Failed to extract schedReqCfg in  extractPucchCfg()");
9051                return RFAILED;
9052             }
9053             memset(macPucchCfg->schedReq, 0, sizeof(PucchSchedReqCfg));
9054             extractSchedReqCfgToAddMod(macPucchCfg->schedReq,\
9055             cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList);
9056          }
9057
9058          /*TODO: Add support for  Spatial Info */
9059
9060          /* MultiCsiCfg */
9061          if(cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList)
9062          {
9063             DU_ALLOC_SHRABL_BUF(macPucchCfg->multiCsiCfg, sizeof(PucchMultiCsiCfg));
9064             if(macPucchCfg->multiCsiCfg == NULLP)
9065             {
9066                DU_LOG("\nERROR --> F1AP : Failed to extract multiCsiCfg in  extractPucchCfg()");
9067                return RFAILED;
9068             }
9069             memset(macPucchCfg->multiCsiCfg, 0, sizeof(PucchMultiCsiCfg));
9070             macPucchCfg->multiCsiCfg->multiCsiResrcListCount = cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.count;
9071             for(arrIdx =0; arrIdx < macPucchCfg->multiCsiCfg->multiCsiResrcListCount; arrIdx++)
9072             {
9073                macPucchCfg->multiCsiCfg->multiCsiResrcList[arrIdx] =\
9074                  *cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.array[arrIdx];
9075             }
9076          }
9077
9078          /* Dl_DataToUL_ACK */
9079          if(cuPucchCfg->choice.setup->dl_DataToUL_ACK)
9080     {
9081        if(storedPucchCfg)
9082        {
9083           if(storedPucchCfg->dlDataToUlAck)
9084           {
9085              macPucchCfg->dlDataToUlAck = storedPucchCfg->dlDataToUlAck;
9086           }
9087           else
9088           {
9089             DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
9090           }
9091        }
9092        else
9093        {
9094           DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
9095        }
9096        if(macPucchCfg->dlDataToUlAck == NULLP)
9097        {
9098           DU_LOG("\nERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
9099           return RFAILED;
9100        }
9101        memset(macPucchCfg->dlDataToUlAck, 0, sizeof(PucchDlDataToUlAck));
9102        macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount = cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.count;
9103        for(arrIdx = 0; arrIdx < macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount; arrIdx++)
9104        {
9105           macPucchCfg->dlDataToUlAck->dlDataToUlAckList[arrIdx] =\
9106           *cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.array[arrIdx];
9107        }
9108          }
9109
9110          /* Power Control */
9111          if(cuPucchCfg->choice.setup->pucch_PowerControl)
9112          {
9113             DU_ALLOC_SHRABL_BUF(macPucchCfg->powerControl, sizeof(PucchPowerControl));
9114             if(macPucchCfg->powerControl == NULLP)
9115             {
9116                DU_LOG("\nERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
9117                return RFAILED;
9118             }
9119             extractPucchPowerControl(macPucchCfg->powerControl,\
9120                cuPucchCfg->choice.setup->pucch_PowerControl);
9121          }
9122       }
9123    }
9124    return ROK;
9125 }
9126
9127 /*******************************************************************
9128  *
9129  * @brief Fills ServingCellReconfig received by CU
9130  *
9131  * @details
9132  *
9133  *    Function : extractSpCellDedicatedCfg
9134  *
9135  *    Functionality: Fills ServingCellReconfig received  by CU
9136  *
9137  * @params[in] ServingCellConfig_t *cuSrvCellCfg = Information which is send by
9138  *                  CU, which we have stored in F1UeContextSetupDb,
9139  *             ServCellCfgInfo *macSrvCellCfg = Used to Store the information
9140  *                  which  needs to send in other layer, as well as this can be the
9141  *                  variable which stores the information in DuCb,
9142  *             ServCellCfgInfo *storedSrvCellCfg = Null in case of sending the
9143  *                  information to other layer else it will have ServCellCfgInfo which
9144  *                  we have stored in copyOfmacUeCfg.
9145  * @return ROK/RFAILD
9146  *
9147  * ****************************************************************/
9148 uint8_t extractSpCellDedicatedCfg(ServingCellConfig_t *cuSrvCellCfg, ServCellCfgInfo *macSrvCellCfg,\
9149 ServCellCfgInfo *storedSrvCellCfg)
9150 {
9151    uint8_t ret = ROK;
9152    BWP_DownlinkDedicated_t *dlBwp = NULLP;
9153    BWP_UplinkDedicated_t   *ulBwp = NULLP;
9154
9155    if(cuSrvCellCfg->initialDownlinkBWP)
9156    {
9157       dlBwp = ((BWP_DownlinkDedicated_t *)(cuSrvCellCfg->initialDownlinkBWP));
9158       if(dlBwp->pdcch_Config)
9159       {
9160          if(dlBwp->pdcch_Config->choice.setup)
9161          {
9162             macSrvCellCfg->initDlBwp.pdcchPresent = true;
9163             extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
9164          }
9165       }
9166       if(dlBwp->pdsch_Config)
9167       {
9168          if(dlBwp->pdsch_Config->choice.setup)
9169          {
9170             macSrvCellCfg->initDlBwp.pdschPresent = true;
9171
9172             if(storedSrvCellCfg)
9173             {
9174                if(!storedSrvCellCfg->initDlBwp.pdschPresent)
9175                {
9176                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
9177                }
9178                else
9179                {
9180                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg,\
9181                         &storedSrvCellCfg->initDlBwp.pdschCfg);
9182                }
9183             }
9184             else
9185             {
9186                extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
9187             }
9188          }
9189       }
9190    }
9191    if(cuSrvCellCfg->firstActiveDownlinkBWP_Id)
9192       macSrvCellCfg->firstActvDlBwpId = *(cuSrvCellCfg->firstActiveDownlinkBWP_Id);
9193    if(cuSrvCellCfg->defaultDownlinkBWP_Id)
9194       macSrvCellCfg->defaultDlBwpId = *(cuSrvCellCfg->defaultDownlinkBWP_Id);
9195    if(cuSrvCellCfg->bwp_InactivityTimer)
9196    {
9197       if(macSrvCellCfg->bwpInactivityTmr)
9198       {
9199          memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
9200       }
9201       else
9202       {
9203          macSrvCellCfg->bwpInactivityTmr = NULLP;
9204          DU_ALLOC_SHRABL_BUF(macSrvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
9205          if(macSrvCellCfg->bwpInactivityTmr)
9206          {
9207             memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
9208          }
9209          else
9210          {
9211             DU_LOG("\nERROR  --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
9212             return RFAILED;
9213          }
9214       }
9215    }
9216    if(cuSrvCellCfg->pdsch_ServingCellConfig)
9217    {
9218       if(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup)
9219       {
9220          ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
9221          if(ret == RFAILED)
9222          {
9223             DU_LOG("\nERROR --> F1AP : Failed at extractPdschServingCellCfg()");
9224             return RFAILED;
9225          }
9226       }
9227    }
9228    if(cuSrvCellCfg->uplinkConfig)
9229    {
9230       if(cuSrvCellCfg->uplinkConfig->initialUplinkBWP)
9231       {
9232          ulBwp = ((BWP_UplinkDedicated_t *)(cuSrvCellCfg->uplinkConfig->initialUplinkBWP));
9233          if(ulBwp->pusch_Config)
9234          {
9235             macSrvCellCfg->initUlBwp.puschPresent = true;
9236             extractPuschCfg(ulBwp->pusch_Config, &macSrvCellCfg->initUlBwp.puschCfg);
9237          }
9238          if(ulBwp->pucch_Config)
9239          {
9240             macSrvCellCfg->initUlBwp.pucchPresent = true;
9241             memset(&macSrvCellCfg->initUlBwp.pucchCfg, 0, sizeof(PucchCfg));
9242             if(storedSrvCellCfg)
9243             {
9244                if(!storedSrvCellCfg->initUlBwp.pucchPresent)
9245                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
9246                else
9247                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg,\
9248                   &storedSrvCellCfg->initUlBwp.pucchCfg);
9249             }
9250             else
9251             {
9252                extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
9253             }
9254          }
9255       }
9256       if(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id)
9257          macSrvCellCfg->firstActvUlBwpId = *(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id);
9258    }
9259    return ret;
9260 }
9261 /*******************************************************************
9262  *
9263  * @brief Fills Reconfig Cell group Info received by CU
9264  *
9265  * @details
9266  *
9267  *    Function : extractUeReCfgCellInfo
9268  *
9269  *    Functionality: Fills Reconfig Cell group Info received by CU
9270  *
9271  * @params[in] CellGroupConfigRrc_t *cellGrp = CellGroupConfigRrc_t information which
9272  *                       is send by CU, which we have stored in F1UeContextSetupDb
9273  *             MacUeCfg *MacUeCfg = Used to Store the information,
9274  *                      which needs to send in other layer, as well as this can be
9275  *                      the variable which stores the information in DuCb,
9276  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
9277  *                      information to other layer else it will have copyOfmacUeCfg
9278  *                      which we have stored in F1UeContextSetupDb.
9279  *
9280  * @return ROK/RFAILED
9281  *
9282  * ****************************************************************/
9283 uint8_t extractUeReCfgCellInfo(CellGroupConfigRrc_t *cellGrp, MacUeCfg *macUeCfg, MacUeCfg *storedMacUeCfg)
9284 {
9285    uint8_t ret = ROK;
9286    MAC_CellGroupConfig_t     *macCellGroup = NULLP;
9287    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
9288    SpCellConfig_t            *spcellCfg = NULLP;
9289    ServingCellConfig_t       *servCellCfg = NULLP;
9290
9291    if(cellGrp)
9292    {
9293       /* Fill MacCell Group Reconfig  */
9294       if(cellGrp->mac_CellGroupConfig)
9295       {
9296          macUeCfg->macCellGrpCfgPres = true;
9297          macCellGroup = ((MAC_CellGroupConfig_t *)(cellGrp->mac_CellGroupConfig));
9298          if(macCellGroup->schedulingRequestConfig)
9299          {
9300             extractSchReqReConfig(macCellGroup->schedulingRequestConfig, &macUeCfg->macCellGrpCfg.schReqCfg);
9301          }
9302          if(macCellGroup->tag_Config)
9303          {
9304             extractTagReconfig(macCellGroup->tag_Config, &macUeCfg->macCellGrpCfg.tagCfg);
9305          }
9306          if(macCellGroup->bsr_Config)
9307          {
9308             macUeCfg->macCellGrpCfg.bsrTmrCfg.periodicTimer = macCellGroup->bsr_Config->periodicBSR_Timer;
9309             macUeCfg->macCellGrpCfg.bsrTmrCfg.retxTimer     = macCellGroup->bsr_Config->retxBSR_Timer;
9310             if(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer)
9311             {
9312                macUeCfg->macCellGrpCfg.bsrTmrCfg.srDelayTimer  =\
9313                *(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer);
9314             }
9315          }
9316          if(macCellGroup->phr_Config)
9317          {
9318             if(macCellGroup->phr_Config->present == MAC_CellGroupConfig__phr_Config_PR_setup)
9319             {
9320                macUeCfg->macCellGrpCfg.phrCfgSetupPres = true;
9321                if(macCellGroup->phr_Config->choice.setup)
9322                {
9323                   macUeCfg->macCellGrpCfg.phrCfg.periodicTimer     = \
9324                   macCellGroup->phr_Config->choice.setup->phr_PeriodicTimer;
9325                   macUeCfg->macCellGrpCfg.phrCfg.prohibitTimer     = \
9326                   macCellGroup->phr_Config->choice.setup->phr_ProhibitTimer;
9327                   macUeCfg->macCellGrpCfg.phrCfg.txPowerFactor     = \
9328                   macCellGroup->phr_Config->choice.setup->phr_Tx_PowerFactorChange;
9329                   macUeCfg->macCellGrpCfg.phrCfg.multiplePHR       = \
9330                   macCellGroup->phr_Config->choice.setup->multiplePHR;
9331                   macUeCfg->macCellGrpCfg.phrCfg.dummy             = \
9332                   macCellGroup->phr_Config->choice.setup->dummy;
9333                   macUeCfg->macCellGrpCfg.phrCfg.phrType2OtherCell = \
9334                   macCellGroup->phr_Config->choice.setup->phr_Type2OtherCell;
9335                   macUeCfg->macCellGrpCfg.phrCfg.phrOtherCG        = \
9336                   macCellGroup->phr_Config->choice.setup->phr_ModeOtherCG;
9337                }
9338             }
9339          }
9340       }
9341       /* Fill Physical Cell Group Reconfig */
9342       if(cellGrp->physicalCellGroupConfig)
9343       {
9344          macUeCfg->phyCellGrpCfgPres = true;
9345          phyCellGrpCfg = ((PhysicalCellGroupConfig_t *)(cellGrp->physicalCellGroupConfig));
9346          if(phyCellGrpCfg->p_NR_FR1)
9347          {
9348             if(*(phyCellGrpCfg->p_NR_FR1) != macUeCfg->phyCellGrpCfg.pNrFr1)
9349                macUeCfg->phyCellGrpCfg.pNrFr1 = *(phyCellGrpCfg->p_NR_FR1);
9350          }
9351          macUeCfg->phyCellGrpCfg.pdschHarqAckCodebook = phyCellGrpCfg->pdsch_HARQ_ACK_Codebook;
9352       }
9353       /* Fill SpCell Reconfig */
9354       if(cellGrp->spCellConfig)
9355       {
9356          macUeCfg->spCellCfgPres = true;
9357          spcellCfg = ((SpCellConfig_t *)(cellGrp->spCellConfig));
9358          if(spcellCfg->servCellIndex)
9359          {
9360             macUeCfg->spCellCfg.servCellIdx = *(spcellCfg->servCellIndex);
9361          }
9362          /* Fill Serving cell Reconfig info */
9363          if(cellGrp->spCellConfig->spCellConfigDedicated)
9364          {
9365             servCellCfg = ((ServingCellConfig_t *)(cellGrp->spCellConfig->spCellConfigDedicated));
9366             if(storedMacUeCfg)
9367             {
9368                if(!storedMacUeCfg->spCellCfgPres)
9369                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
9370                else
9371                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg,\
9372                         &storedMacUeCfg->spCellCfg.servCellCfg);
9373             }
9374             else
9375             {
9376                ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
9377             }
9378             if(ret == RFAILED)
9379             {
9380                DU_LOG("\nERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
9381             }
9382          }
9383       }
9384    }
9385    return ret;
9386 }
9387 /*******************************************************************
9388 *
9389 * @brief free the memory allocated by decoder
9390 *
9391 * @details
9392 *
9393 *    Function : freeAperDecodeNrcgi
9394 *
9395 *    Functionality: Free Nrcgi values
9396 *
9397 * @params[in] NRCGI_t *nrcgi
9398 * @return void
9399 *
9400 * ****************************************************************/
9401
9402
9403 void freeAperDecodeNrcgi(NRCGI_t *nrcgi)
9404 {
9405     if(nrcgi->pLMN_Identity.buf != NULLP)
9406     {
9407        free(nrcgi->pLMN_Identity.buf);
9408     }
9409     if(nrcgi->nRCellIdentity.buf != NULLP)
9410     {
9411        free(nrcgi->nRCellIdentity.buf);
9412     }
9413 }
9414 /*******************************************************************
9415 *
9416 * @brief free the memory allocated by decoder
9417 *
9418 * @details
9419 *
9420 *    Function : freeAperDecodeCuToDuInfo
9421 *
9422 *    Functionality:  Free Cu To Du Information
9423 *
9424 * @params[in] CUtoDURRCInformation_t *rrcMsg
9425 * @return void
9426 *
9427 * ****************************************************************/
9428
9429
9430 void freeAperDecodeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
9431 {
9432    uint8_t ieIdx =0;
9433    uint8_t arrIdx =0;
9434
9435    if(rrcMsg->uE_CapabilityRAT_ContainerList)
9436    {
9437       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
9438          free(rrcMsg->uE_CapabilityRAT_ContainerList->buf);
9439       free(rrcMsg->uE_CapabilityRAT_ContainerList);
9440    }
9441
9442    if(rrcMsg->iE_Extensions)
9443    {
9444       if(rrcMsg->iE_Extensions->list.array)
9445       {
9446          for(ieIdx= 0; ieIdx < rrcMsg->iE_Extensions->list.count; ieIdx++)
9447          {
9448             if(rrcMsg->iE_Extensions->list.array[ieIdx])
9449             {
9450                switch(rrcMsg->iE_Extensions->list.array[ieIdx]->id)
9451                {
9452                   case ProtocolIE_ID_id_CellGroupConfig:
9453                      if(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
9454                      {
9455                         free(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf);
9456                      }
9457                      break;
9458                   default:
9459                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
9460                            rrcMsg->iE_Extensions->list.array[ieIdx]->id);
9461                      break;
9462                }
9463             }
9464          }
9465          for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
9466          {
9467             free(rrcMsg->iE_Extensions->list.array[arrIdx]);
9468          }
9469          free(rrcMsg->iE_Extensions->list.array);
9470
9471       }
9472
9473       free(rrcMsg->iE_Extensions);
9474    }
9475 }
9476 /*******************************************************************
9477 *
9478 * @brief free the memory allocated by decoder
9479 *
9480 * @details
9481 *
9482 *    Function : freeAperDecodeSplCellList
9483 *
9484 *    Functionality: Free Spl Cell List
9485                     where memory allocated by aper_decoder
9486 *
9487 * @params[in]  SCell_ToBeSetup_List_t *spCellLst
9488 * @return void
9489 *
9490 * ****************************************************************/
9491
9492
9493 void freeAperDecodeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
9494 {
9495     uint8_t  cellIdx =0;
9496
9497     if(spCellLst->list.array != NULLP)
9498     {
9499        for(cellIdx=0; cellIdx<spCellLst->list.count; cellIdx++)
9500        {
9501           if(cellIdx==0&&spCellLst->list.array[cellIdx]!=NULLP)
9502           {
9503              freeAperDecodeNrcgi(&spCellLst->list.array[cellIdx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
9504           }
9505           if(spCellLst->list.array[cellIdx]!=NULLP)
9506           {
9507              free(spCellLst->list.array[cellIdx]);
9508           }
9509        }
9510        free(spCellLst->list.array);
9511     }
9512 }
9513 /*******************************************************************
9514 *
9515 * @brief free the memory allocated by decoder
9516 *
9517 * @details
9518 *
9519 *    Function : freeAperDecodeSRBSetup
9520 *
9521 *    Functionality: added free part for the memory allocated by aper_decoder
9522 *
9523 * @params[in] SRBs_ToBeSetup_List_t *srbSet
9524 * @return void
9525 *
9526 ****************************************************************/
9527
9528
9529 void freeAperDecodeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
9530 {
9531     uint8_t srbIdx =0;
9532     if(srbSet->list.array != NULLP)
9533     {
9534        for(srbIdx=0; srbIdx<srbSet->list.count; srbIdx++)
9535        {
9536           if(srbSet->list.array[srbIdx]!=NULLP)
9537           {
9538              free(srbSet->list.array[srbIdx]);
9539           }
9540        }
9541        free(srbSet->list.array);
9542     }
9543 }
9544
9545 /*******************************************************************
9546 *
9547 * @brief free the memory allocated by decoder
9548 *
9549 * @details
9550 *
9551 *    Function : freeAperDecodeULTnlInfo
9552 *
9553 *    Functionality: added free part for the memory allocated by aper_decoder
9554 *
9555 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
9556 * @return void
9557 *
9558 * ****************************************************************/
9559
9560
9561 void freeAperDecodeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
9562 {
9563    uint8_t ulIdx=0;
9564    if(ulInfo->list.array != NULLP)
9565    {
9566       for(ulIdx=0; ulIdx<ulInfo->list.count; ulIdx++)
9567       {
9568          if(ulIdx==0&&ulInfo->list.array[ulIdx]!=NULLP)
9569          {
9570             if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
9571             {
9572                if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9573                      transportLayerAddress.buf != NULLP)
9574                {
9575                   if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
9576                         !=NULLP)
9577                   {
9578                      free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf);
9579                   }
9580                   free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9581                         transportLayerAddress.buf);
9582                }
9583                free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel);
9584             }
9585          }
9586          if(ulInfo->list.array[ulIdx]!=NULLP)
9587          {
9588             free(ulInfo->list.array[ulIdx]);
9589          }
9590       }
9591       free(ulInfo->list.array);
9592    }
9593 }
9594 /*******************************************************************
9595 *
9596 * @brief free the memory allocated by decoder
9597 *
9598 * @details
9599 *
9600 *    Function : freeAperDecodeDRBSetup
9601 *
9602 *    Functionality: free DRBSetup which is allocated by decoder
9603 *
9604 * @params[in]  DRBs_ToBeSetup_List_t *drbSet
9605 * @return void
9606 *
9607 * ****************************************************************/
9608
9609 void freeAperDecodeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
9610 {
9611    DRBs_ToBeSetup_Item_t *drbSetItem = NULLP;
9612    uint8_t  flowIdx =0;
9613    uint8_t  drbIdx =0;
9614
9615    if(drbSet->list.array != NULLP)
9616    {
9617       for(drbIdx=0; drbIdx<drbSet->list.count; drbIdx++)
9618       {
9619          if(drbIdx==0&&drbSet->list.array[drbIdx] != NULLP)
9620          {
9621             drbSetItem =&drbSet->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
9622             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
9623             {
9624                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9625                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
9626                {
9627                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9628                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9629                   {
9630                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9631                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9632                      {
9633
9634                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
9635                         {
9636
9637                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
9638                            {
9639
9640                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->\
9641                                     buf!=NULLP)
9642                               {
9643
9644                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
9645                                        flows_Mapped_To_DRB_List.list.array != NULLP)
9646                                  {
9647
9648                                     for(flowIdx=0;flowIdx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9649                                           DRB_Information.flows_Mapped_To_DRB_List.list.count; flowIdx++)
9650                                     {
9651
9652                                        if(flowIdx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9653                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9654                                        {
9655                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9656                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9657                                                 qoSFlowLevelQoSParameters.\
9658                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
9659                                           {
9660                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9661                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9662                                                    qoSFlowLevelQoSParameters.\
9663                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9664                                              {
9665
9666                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9667                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9668                                                       qoSFlowLevelQoSParameters.\
9669                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9670                                                 {
9671
9672
9673                                                    free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9674                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9675                                                          qoSFlowLevelQoSParameters.\
9676                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9677                                                 }
9678
9679                                                 free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9680                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9681                                                       qoSFlowLevelQoSParameters.\
9682                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9683                                              }
9684
9685                                              free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9686
9687                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9688                                                    qoSFlowLevelQoSParameters.\
9689                                                    qoS_Characteristics.choice.non_Dynamic_5QI);
9690                                           }
9691                                        }
9692                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9693                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9694                                        {
9695
9696                                           free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9697                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]);
9698                                        }
9699                                     }
9700
9701                                     free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9702                                           DRB_Information.flows_Mapped_To_DRB_List.list.array);
9703                                  }
9704
9705                                  free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9706                                        DRB_Information.sNSSAI.sD->buf);
9707                               }
9708
9709                               free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD);
9710                            }
9711
9712                            free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf);
9713
9714                         }
9715
9716                         free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9717
9718                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9719                      }
9720
9721                      free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9722                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9723                   }
9724
9725                   free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9726                         qoS_Characteristics.choice.non_Dynamic_5QI);
9727                }
9728                free(drbSetItem->qoSInformation.choice.choice_extension);
9729             }
9730             freeAperDecodeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
9731             if(drbSetItem->uLConfiguration)
9732             {
9733                free(drbSetItem->uLConfiguration);
9734             }
9735          }
9736          if(drbSet->list.array[drbIdx]!=NULLP)
9737          {
9738             free(drbSet->list.array[drbIdx]);
9739          }
9740       }
9741       free(drbSet->list.array);
9742    }
9743 }
9744
9745
9746 /*******************************************************************
9747  *
9748  * @brief builds Mac Cell Cfg
9749  *
9750  * @details
9751  *
9752  *    Function : procUeReCfgCellInfo
9753  *
9754  *    Functionality: builds Mac Cell Cfg
9755  *
9756  * @params[in] MacUeCfg *macUeCfgToSend = Used to Store the information which
9757  *                       needs to send in other layer, as well as this can be
9758  *                       the variable which stores the information in DuCb.
9759  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
9760  *                       information to other layer else it will have copyOfmacUeCfg
9761  *                       which we have stored in F1UeContextSetupDb
9762  *             void *cellInfo = CellGroupConfigRrc_t information which is send
9763  *                        by CU, which we have stored in F1UeContextSetupDb
9764  *
9765  * @return void
9766  *
9767  * ****************************************************************/
9768 uint8_t procUeReCfgCellInfo(MacUeCfg *macUeCfgToSend,MacUeCfg *storedMacUeCfg, void *cellInfo)
9769 {
9770    uint8_t ret = ROK;
9771    CellGroupConfigRrc_t *cellGrp = NULLP;
9772
9773    if(cellInfo)
9774    {
9775       cellGrp = (CellGroupConfigRrc_t *)cellInfo;
9776       ret = extractUeReCfgCellInfo(cellGrp, macUeCfgToSend, storedMacUeCfg);
9777       if(ret == RFAILED)
9778          DU_LOG("\nERROR  -->  F1AP : Failed at procUeReCfgCellInfo()");
9779    }
9780    if(ret == RFAILED)
9781    {
9782       freeUeReCfgCellGrpInfo(macUeCfgToSend);
9783    }
9784    return ret;
9785 }
9786
9787 /*******************************************************************
9788  *
9789  * @brief Filling modulation info in mac ue cfg
9790  *
9791  * @details
9792  *
9793  *    Function : duFillModulationDetails
9794  *
9795  *    Functionality: Filling modulation info in mac ue cfg
9796  *
9797  * @params[in] MAC UE Config to be updated
9798  *             Current UE configuration
9799  *             UE NR capability from CU
9800  * @return ROK     - success
9801  *         RFAILED - failure
9802  *
9803  * ****************************************************************/
9804 void duFillModulationDetails(MacUeCfg *ueCfg, MacUeCfg *oldUeCfg, void *ueCap)
9805 {
9806    UE_NR_Capability_t *ueNrCap=NULLP;
9807
9808    if(!ueCap)
9809    {
9810       memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9811       memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9812    }
9813    else
9814    {
9815       ueNrCap = (UE_NR_Capability_t *)ueCap;
9816
9817       /* Filling DL modulation info */
9818       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsDownlinkPerCC && \
9819          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0] && \
9820          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL)
9821       {
9822          switch(*(ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL))
9823          {
9824             case ModulationOrder_qpsk:
9825                {
9826                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
9827                   break;
9828                }
9829             case ModulationOrder_qam16:
9830                {
9831                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM16;
9832                   break;
9833                }
9834             case ModulationOrder_qam64:
9835                {
9836                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM64;
9837                   ueCfg->dlModInfo.mcsIndex = PDSCH_MCS_INDEX;
9838                   ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64;
9839                   break;
9840                }
9841             case ModulationOrder_qam256:
9842                {
9843                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM256;
9844                   break;
9845                }
9846             default:
9847                {
9848                   DU_LOG("\nERROR  -->  DU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
9849                   memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9850                   break;
9851                }
9852          }
9853       }
9854       else
9855       {
9856          memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9857       }
9858
9859       /* Filling UL modulation info */
9860       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsUplinkPerCC && \
9861          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0] && \
9862          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL)
9863       {
9864          switch(*(ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL))
9865          {
9866             case ModulationOrder_qpsk:
9867                {
9868                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
9869                   break;
9870                }
9871             case ModulationOrder_qam16:
9872                {
9873                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM16;
9874                   ueCfg->ulModInfo.mcsIndex = PUSCH_MCS_INDEX;
9875                   ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64;
9876                   break;
9877                }
9878             case ModulationOrder_qam64:
9879                {
9880                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM64;
9881                   break;
9882                }
9883             case ModulationOrder_qam256:
9884                {
9885                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM256;
9886                   break;
9887                }
9888             default:
9889                {
9890                   DU_LOG("\nERROR  -->  DU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
9891                   memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9892                   break;
9893                }
9894          }
9895       }
9896       else
9897       {
9898          memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9899       }
9900    }
9901 }
9902
9903 /*******************************************************************
9904  *
9905  * @brief Function to extract cellGrp Info present in cutoDu cont
9906  *
9907  * @details
9908  *
9909  *    Function : extractCellGrpInfo
9910  *
9911  *    Functionality: Function to extract cellGrp Info present
9912  *                   in cutoDu cont
9913  *
9914  * @params[in] ProtocolExtensionContainer_4624P16_t pointer
9915  *
9916  * @return CellGroupConfigRrc_t *
9917  *
9918  * ****************************************************************/
9919
9920 CellGroupConfigRrc_t *extractCellGrpInfo(ProtocolExtensionContainer_4624P16_t *protocolIeExtn,\
9921       DuUeCfg *ueCfgDb)
9922 {
9923    uint8_t idx2 =0;
9924    uint16_t id =0;
9925    uint16_t recvBufLen =0;
9926    CellGroupConfigRrc_t *cellGrpCfg = NULLP;
9927    CUtoDURRCInformation_ExtIEs_t *extIeInfo = NULLP;
9928    asn_dec_rval_t rval; /* Decoder return value */
9929    memset(&rval, 0, sizeof(asn_dec_rval_t));
9930
9931    if(protocolIeExtn)
9932    {
9933       for(idx2 = 0; idx2 < protocolIeExtn->list.count; idx2++)
9934       {
9935          extIeInfo = ((CUtoDURRCInformation_ExtIEs_t *)(protocolIeExtn->list.array[idx2]));
9936          id = extIeInfo->id;
9937          switch(id)
9938          {
9939             case ProtocolIE_ID_id_CellGroupConfig:
9940             {
9941                recvBufLen = extIeInfo->extensionValue.choice.CellGroupConfig.size;
9942                /* decoding the CellGroup Buf received */
9943                DU_ALLOC(cellGrpCfg, sizeof(CellGroupConfigRrc_t));
9944                if(cellGrpCfg)
9945                {
9946                   memset(cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
9947                   rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfg,
9948                      extIeInfo->extensionValue.choice.CellGroupConfig.buf, recvBufLen, 0, 0);
9949                   if(rval.code == RC_FAIL || rval.code == RC_WMORE)
9950                   {
9951                      DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
9952                      return NULLP;
9953                   }
9954                   xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfg);
9955                   if(extractRlcCfgToAddMod(cellGrpCfg->rlc_BearerToAddModList, ueCfgDb))
9956                      return NULLP;
9957                }
9958                break;
9959             }
9960             default:
9961                DU_LOG("\nERROR  -->  F1AP : Invalid IE received CUtoDURRCInformation:%d at decodeCellGrpCfg()", id);
9962                break;
9963          }
9964       }
9965    }
9966    return cellGrpCfg;
9967 }
9968
9969 /*******************************************************************
9970  *
9971  * @brief Fills Srb List received by CU
9972  *
9973  * @details
9974  *
9975  *    Function : procSrbListToSetup
9976  *
9977  *    Functionality: Fills Srb List received  by CU
9978  *
9979  * @params[in] SRBs_ToBeSetup_Item_t *cuSrbItem
9980  *             LcCfg pointer
9981  *             RlcBearerCfg pointer
9982  * @return void
9983  *
9984  * ****************************************************************/
9985 uint8_t procSrbListToSetup(SRBs_ToBeSetup_Item_t * srbItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd)
9986 {
9987    uint8_t ret = ROK;
9988
9989    /* Filling RLC INFO */
9990    procRlcLcCfg(srbItem->sRBID, srbItem->sRBID, RB_TYPE_SRB, RLC_AM, CONFIG_ADD, NULL, rlcLcToAdd);
9991
9992    /* Filling MAC INFO */
9993    ret = procMacLcCfg(srbItem->sRBID, RB_TYPE_SRB, CONFIG_ADD, NULL,NULL, NULL, NULL, macLcToAdd, NULL);
9994    if(ret == RFAILED)
9995    {
9996       DU_LOG("\nERROR  -->  F1AP : Failed at MAC LC Cfg in procSrbListToSetup()");
9997       return ret;
9998    }
9999    return ret;
10000 }
10001
10002
10003
10004 /*******************************************************************
10005  *
10006  * @brief extract Srb List received by CU
10007  *
10008  * @details
10009  *
10010  *    Function : extractSrbListToSetup
10011  *
10012  *    Functionality: extract Srb List received by CU
10013  *                   for both MAC and RLC
10014  *
10015  * @params[in] SRBs_ToBeSetup_Item_t pointer
10016  *             DuUeCfg pointer
10017  * @return ROK/RFAIED
10018  *
10019  * ****************************************************************/
10020
10021 uint8_t extractSrbListToSetup(SRBs_ToBeSetup_List_t *srbCfg, DuUeCfg *ueCfgDb)
10022 {
10023    uint8_t ret, srbIdx;
10024    SRBs_ToBeSetup_Item_t *srbItem = NULLP;
10025
10026    if(srbCfg)
10027    {
10028       for(srbIdx = 0; srbIdx < srbCfg->list.count; srbIdx++)
10029       {
10030          srbItem = &srbCfg->list.array[srbIdx]->value.choice.SRBs_ToBeSetup_Item;
10031          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
10032          {
10033             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in MAC");
10034             ret = RFAILED;
10035             break;
10036          }
10037          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
10038          {
10039             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in RLC");
10040             ret = RFAILED;
10041             break;
10042          }
10043          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
10044          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
10045          ret = procSrbListToSetup(srbItem, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
10046             &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs]);
10047          ueCfgDb->numRlcLcs++;
10048          ueCfgDb->numMacLcs++;
10049          DU_LOG("\nDEBUG --> DUAPP: extractSrbListToSetup: SRBID: %d [RLC,MAC,NumDrb]:[%x,%x,%x]",\
10050                             srbItem->sRBID, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
10051          if(ret == RFAILED)
10052          {
10053             DU_LOG("\nERROR  -->  F1AP:  Failed at extractSrbListToSetup()");
10054             break;
10055          }
10056       }
10057    }
10058    else
10059       ret = RFAILED;
10060
10061    return ret;
10062 }
10063
10064 /*******************************************************************
10065  *
10066  * @brief Fills Drb List received by CU
10067  *
10068  * @details
10069  *
10070  *    Function : procDrbListToSetupMod
10071  *
10072  *    Functionality: Fills Drb List received by CU
10073  *                   for both MAC and RLC
10074  *
10075  * @params[in] SRBs_ToBeSetup_Item_t pointer
10076  *             LcCfg pointer,
10077  *             RlcBearerCfg pointer
10078  * @return void
10079  *
10080  * ****************************************************************/
10081
10082 uint8_t procDrbListToSetupMod(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbItem,\
10083 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd, UpTnlCfg *upTnlInfo)
10084 {
10085
10086    if(drbItem != NULLP)
10087    {
10088       /* Filling RLC INFO */
10089       procRlcLcCfg(drbItem->dRBID, lcId, RB_TYPE_DRB, drbItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd);
10090
10091       /* Filling MAC INFO */
10092       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, drbItem, NULL, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
10093       {
10094          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
10095          return RFAILED;
10096       }
10097    }
10098    else if(drbSetupModItem != NULLP)
10099    {
10100       procRlcLcCfg(drbSetupModItem->dRBID, lcId, RB_TYPE_DRB, drbSetupModItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd);
10101
10102       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, NULL, drbSetupModItem, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
10103       {
10104          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
10105          return RFAILED;
10106       }
10107    }
10108    else if(drbModItem != NULLP)
10109    {
10110       /* Drb to Mod IEs doesnot have rlcMode to be modified
10111        * in ASN. Hence no change in RLC configurations */
10112       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_MOD, NULL, NULL, drbModItem, NULL, macLcToAdd, upTnlInfo) != ROK)
10113       {
10114          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
10115          return RFAILED;
10116       }
10117    }
10118    return ROK;
10119 }
10120
10121 /*******************************************************************
10122  *
10123  * @brief extract Drb List received by CU
10124  *
10125  * @details
10126  *
10127  *    Function : extractDrbListToSetupMod
10128  *
10129  *    Functionality: extract Drb List received by CU
10130  *                   for both MAC and RLC
10131  *
10132  * @params[in] DRBs_ToBeSetup_Item_t pointer
10133  *             DuUeCfg pointer
10134  * @return ROK/RFAIED
10135  *
10136  * ****************************************************************/
10137
10138 uint8_t extractDrbListToSetupMod(DRBs_ToBeSetup_List_t *drbCfg, DRBs_ToBeSetupMod_List_t *drbSetupModCfg,\
10139  DRBs_ToBeModified_List_t *drbModCfg, uint8_t drbCount, DuUeCfg *ueCfgDb, uint32_t *drbBitMap)
10140 {
10141    uint8_t ret, drbIdx, lcId = 0;
10142    DRBs_ToBeSetup_Item_t *drbItem = NULLP;
10143    DRBs_ToBeSetupMod_ItemIEs_t *drbSetupModItem = NULLP;
10144    DRBs_ToBeModified_ItemIEs_t *drbModItem = NULLP;
10145
10146    ret = ROK;
10147    if(drbCount > 0)
10148    {
10149       for(drbIdx = 0; drbIdx < drbCount; drbIdx++)
10150       {
10151          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
10152          {
10153             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in MAC at extractDrbListToSetupMod()");
10154             ret = RFAILED;
10155             break;
10156          }
10157          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
10158          {
10159             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in RLC at extractDrbListToSetupMod()");
10160             ret = RFAILED;
10161             break;
10162          }
10163          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
10164          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
10165
10166          if(drbModCfg != NULLP)
10167          {
10168             drbModItem = (DRBs_ToBeModified_ItemIEs_t *) drbModCfg->list.array[drbIdx];
10169             lcId = fetchLcId(drbModItem->value.choice.DRBs_ToBeModified_Item.dRBID);
10170             if(lcId < MIN_DRB_LCID)
10171             {
10172                DU_LOG("\nERROR  --> F1AP : Failed fetching LCID %d in extractDrbListToSetupMod() for Modified List", lcId);
10173                break;
10174             }
10175             ret = procDrbListToSetupMod(lcId, NULL, NULL, &(drbModItem->value.choice.DRBs_ToBeModified_Item),\
10176             &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs],\
10177             &ueCfgDb->upTnlInfo[ueCfgDb->numDrb]);
10178             if(ret == RFAILED)
10179             {
10180                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for Modified List");
10181                break;
10182             }
10183
10184          }
10185          else
10186          {
10187             lcId = getDrbLcId(drbBitMap);
10188             if(lcId == RFAILED)
10189             {
10190                DU_LOG("\nERROR  -->  F1AP :  InCorrect LCID extractDrbListToSetupMod()");
10191                ret = RFAILED;
10192                break;
10193             }
10194             if(drbCfg != NULL)
10195             {
10196                drbItem = &drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
10197                ret = procDrbListToSetupMod(lcId, drbItem, NULL, NULL, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
10198                      &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], &ueCfgDb->upTnlInfo[ueCfgDb->numDrb]);
10199                if(ret == RFAILED)
10200                {
10201                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetup List");
10202                   break;
10203                }
10204             }
10205             else if(drbSetupModCfg != NULL)
10206             {
10207                drbSetupModItem = (DRBs_ToBeSetupMod_ItemIEs_t *) drbSetupModCfg->list.array[drbIdx];
10208                ret = procDrbListToSetupMod(lcId, NULL, &(drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item), NULL,\
10209                      &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs],\
10210                      &ueCfgDb->upTnlInfo[ueCfgDb->numDrb]);
10211                if(ret == RFAILED)
10212                {
10213                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetupMod List");
10214                   break;
10215                }
10216             }
10217             ueCfgDb->numRlcLcs++;
10218          }
10219          ueCfgDb->numMacLcs++;
10220          ueCfgDb->numDrb++;
10221
10222          DU_LOG("\nDEBUG --> DUAPP: extractDrbListToSetupMod:lcId:%x ,BitMap:%x, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
10223                             lcId,*drbBitMap, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
10224          if(ret == RFAILED)
10225          {
10226             DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod()");
10227             break;
10228          }
10229       }
10230    }
10231    else
10232       ret = RFAILED;
10233
10234    return ret;
10235 }
10236
10237 /*******************************************************************
10238  *
10239  * @brief Function to extract Dl RRC Msg received from CU
10240  *
10241  * @details
10242  *
10243  *    Function : extractDlRrcMsg
10244  *
10245  *    Functionality: Function to extract Dl RRC Msg received from CU
10246  *
10247  * @params[in] F1AP message
10248  * @return ROK     - success
10249  *         RFAILED - failure
10250  *
10251  * ****************************************************************/
10252
10253 uint8_t extractDlRrcMsg(uint32_t gnbDuUeF1apId, uint32_t gnbCuUeF1apId, \
10254    F1DlRrcMsg *dlRrcMsg, RRCContainer_t *rrcContainer)
10255 {
10256    uint8_t ret = ROK;
10257    dlRrcMsg->rrcMsgSize = rrcContainer->size;
10258    if(dlRrcMsg->rrcMsgSize > 0)
10259    {
10260       DU_ALLOC_SHRABL_BUF(dlRrcMsg->rrcMsgPdu, dlRrcMsg->rrcMsgSize);
10261       if(!dlRrcMsg->rrcMsgPdu)
10262       {
10263          DU_LOG("\nERROR  --> DU APP : Memory allocation failed for RRC Msg in extractDlRrcMsg()");
10264          ret = RFAILED;
10265       }
10266       else
10267       {
10268          dlRrcMsg->gnbDuUeF1apId = gnbDuUeF1apId;
10269          dlRrcMsg->gnbCuUeF1apId = gnbCuUeF1apId;
10270          dlRrcMsg->srbId = SRB1_LCID;
10271          memcpy(dlRrcMsg->rrcMsgPdu, rrcContainer->buf, dlRrcMsg->rrcMsgSize);
10272       }
10273    }
10274    return ret;
10275 }
10276
10277 /*******************************************************************
10278  *
10279  * @brief Extract UE capability info
10280  *
10281  * @details
10282  *
10283  *    Function : extractUeCapability
10284  *
10285  *    Functionality: Extract UE capability info and stores in ue Cb
10286  *
10287  * @params[in] Octet string of UE capability RAT container list
10288  * @return ROK     - success
10289  *         RFAILED - failure
10290  *
10291  * ****************************************************************/
10292 UE_NR_Capability_t *extractUeCapability(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf, DuUeCb *ueCb)
10293 {
10294    uint8_t  idx;
10295    uint16_t recvBufLen;
10296    asn_dec_rval_t rval;
10297    UE_NR_Capability_t  *ueNrCap = NULLP;
10298    UE_CapabilityRAT_ContainerListRRC_t  *ueCapRatContList = NULLP;
10299
10300    /* Decoding UE Capability RAT Container List */
10301    recvBufLen = ueCapablityListBuf->size;
10302    DU_ALLOC(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10303    if(!ueCapRatContList)
10304    {
10305       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
10306       return NULLP;
10307    }
10308    memset(ueCapRatContList, 0, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10309    memset(&rval, 0, sizeof(asn_dec_rval_t));
10310    rval = aper_decode(0, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, (void **)&ueCapRatContList,
10311           ueCapablityListBuf->buf, recvBufLen, 0, 0);
10312    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10313    {
10314       DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
10315       return NULLP;
10316    }
10317    xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, ueCapRatContList);
10318
10319    /* Free encoded buffer after decoding */
10320
10321    for(idx = 0; idx < ueCapRatContList->list.count; idx++)
10322    {
10323       if(ueCapRatContList->list.array[idx]->rat_Type == RAT_Type_nr)
10324       {
10325          /* Decoding UE NR Capability */
10326           recvBufLen = ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.size;
10327           DU_ALLOC(ueNrCap, sizeof(UE_NR_Capability_t));
10328           if(!ueNrCap)
10329           {
10330              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
10331              DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10332              return NULLP;
10333           }
10334           memset(ueNrCap, 0, sizeof(UE_NR_Capability_t));
10335           memset(&rval, 0, sizeof(asn_dec_rval_t));
10336           rval = aper_decode(0, &asn_DEF_UE_NR_Capability, (void **)&ueNrCap,
10337                  ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf, recvBufLen, 0, 0);
10338           if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10339           {
10340              DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
10341              return NULLP;
10342           }
10343           xer_fprint(stdout, &asn_DEF_UE_NR_Capability, ueNrCap);
10344
10345           /* Free encoded buffer after decoding */
10346           free(ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf);
10347       }
10348       free(ueCapRatContList->list.array[idx]);
10349    }
10350
10351    /* Free Memory*/
10352    free(ueCapRatContList->list.array);
10353    DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10354    return ueNrCap;
10355 }
10356
10357 /*******************************************************************
10358 *
10359 * @brief free UE context setup request from CU
10360 *
10361 * @details
10362 *
10363 *    Function : freeAperDecodeF1UeContextSetupReq
10364 *
10365 *    Functionality: freeing part for the memory allocated by aper_decoder
10366 *
10367 * @params[in] F1AP message
10368 * @return ROK     - success
10369 *         RFAILED - failure
10370 *
10371 * ****************************************************************/
10372 void freeAperDecodeF1UeContextSetupReq(UEContextSetupRequest_t   *ueSetReq)
10373 {
10374    uint8_t ieIdx = 0;
10375
10376    if(ueSetReq->protocolIEs.list.array != NULLP)
10377    {
10378       for(ieIdx = 0; ieIdx < ueSetReq->protocolIEs.list.count; ieIdx++)
10379       {
10380          if(ueSetReq->protocolIEs.list.array[ieIdx])
10381          {
10382             switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
10383             {
10384                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10385                   break;
10386                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10387                   break;
10388                case ProtocolIE_ID_id_SpCell_ID:
10389                   freeAperDecodeNrcgi(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
10390                   break;
10391                case ProtocolIE_ID_id_ServCellIndex:
10392                   break;
10393                case ProtocolIE_ID_id_SpCellULConfigured:
10394                   break;
10395                case ProtocolIE_ID_id_CUtoDURRCInformation:
10396
10397                   freeAperDecodeCuToDuInfo(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation);
10398                   break;
10399                case ProtocolIE_ID_id_SCell_ToBeSetup_List:
10400
10401                   freeAperDecodeSplCellList(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SCell_ToBeSetup_List);
10402                   break;
10403                case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
10404
10405                   freeAperDecodeSRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List);
10406                   break;
10407                case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
10408
10409                   freeAperDecodeDRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List);
10410                   break;
10411                case ProtocolIE_ID_id_RRCContainer:
10412                   {
10413
10414                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf != NULLP)
10415                      {
10416
10417                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
10418                      }
10419                      break;
10420                   }
10421                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10422                   break;
10423                case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
10424                   {
10425                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf)
10426                      {
10427                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf);
10428                      }
10429                      break;
10430                   }
10431                default:
10432                   DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld " ,ueSetReq->protocolIEs.list.array[ieIdx]->id);
10433             }
10434             free(ueSetReq->protocolIEs.list.array[ieIdx]);
10435          }
10436       }
10437       free(ueSetReq->protocolIEs.list.array);
10438    }
10439 }
10440 /*******************************************************************
10441  *
10442  * @brief Process UE context setup request from CU
10443  *
10444  * @details
10445  *
10446  *    Function : procF1UeContextSetupReq
10447  *
10448  *    Functionality: Process UE context setup request from CU
10449  *
10450  * @params[in] F1AP message
10451  * @return ROK     - success
10452  *         RFAILED - failure
10453  *
10454  * ****************************************************************/
10455 uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
10456 {
10457    uint8_t  ret=0, ieIdx=0, ueIdx=0, cellIdx=0;
10458    bool ueCbFound = false;
10459    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0, bitRateSize=0;
10460    DuUeCb   *duUeCb = NULL;
10461    UEContextSetupRequest_t   *ueSetReq = NULL;
10462    DRBs_ToBeSetup_List_t *drbCfg = NULL;
10463
10464    ret = ROK;
10465
10466    ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
10467    for(ieIdx=0; (ieIdx < ueSetReq->protocolIEs.list.count && ret == ROK); ieIdx++)
10468    {
10469       switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
10470       {
10471          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10472             {
10473                gnbCuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
10474                break;
10475             }
10476          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10477             {
10478                gnbDuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
10479                break;
10480             }
10481          case ProtocolIE_ID_id_ServCellIndex:
10482             {
10483                cellIdx = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.ServCellIndex;
10484                for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
10485                {
10486                   if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
10487                         (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
10488                   {
10489                      ueCbFound = true;
10490                      duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
10491                      DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
10492                      if(duUeCb->f1UeDb)
10493                      {
10494                         memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
10495                         duUeCb->f1UeDb->actionType = UE_CTXT_SETUP;
10496                         duUeCb->f1UeDb->cellIdx = cellIdx;
10497                      }
10498                      else
10499                      {
10500                         DU_LOG("\nERROR  -->  F1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
10501                         ret = RFAILED;
10502                      }
10503                      break;
10504                   }
10505                   else
10506                      ueCbFound = false;
10507
10508                }
10509                if(!ueCbFound)
10510                {
10511                   DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
10512                   ret = RFAILED;
10513                }
10514                break;
10515             }
10516          case ProtocolIE_ID_id_SpCellULConfigured:
10517             /* Indicates whether the gNB-CU requests the gNB-DU to configure the uplink as no UL,
10518                UL, SUL or UL+SUL for the indicated cell for the UE */
10519             break;
10520          case ProtocolIE_ID_id_CUtoDURRCInformation:
10521             {
10522                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.uE_CapabilityRAT_ContainerList)
10523                {
10524                   duUeCb->f1UeDb->duUeCfg.ueNrCapability = \
10525                   extractUeCapability(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.\
10526                   uE_CapabilityRAT_ContainerList, duUeCb);
10527                }
10528                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.iE_Extensions)
10529                {
10530                   duUeCb->f1UeDb->duUeCfg.cellGrpCfg = extractCellGrpInfo(ueSetReq->protocolIEs.list.array[ieIdx]->\
10531                         value.choice.CUtoDURRCInformation.iE_Extensions, &duUeCb->f1UeDb->duUeCfg);
10532                   if(!duUeCb->f1UeDb->duUeCfg.cellGrpCfg)
10533                   {
10534                      DU_LOG("\nERROR  -->  F1AP: Failed to extract cell Grp Info");
10535                      //TODO: Update the failure cause in ue context Setup Response
10536                      ret = RFAILED;
10537                   }
10538                }
10539                break;
10540             }
10541          case ProtocolIE_ID_id_SCell_ToBeSetup_List:
10542             {
10543                DU_LOG("\nINFO   -->  DU_APP: Received SCell_ToBeSetup_List but  Not processing the list");
10544                break;
10545             }
10546          case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
10547             {
10548                if(extractSrbListToSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List,\
10549                &duUeCb->f1UeDb->duUeCfg))
10550                {
10551                   DU_LOG("\nERROR  -->  DU APP : Failed at extractSrbListToSetup()");
10552                   //TODO: Update the failure cause in ue context Setup Response
10553                   ret = RFAILED;
10554                }
10555                break;
10556             }
10557          case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
10558             {
10559                   drbCfg = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List;
10560
10561                   if(extractDrbListToSetupMod(drbCfg, NULL, NULL, drbCfg->list.count, &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap))
10562                   {
10563                      DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod()");
10564                      //TODO: Update the failure cause in ue context Setup Response
10565                      ret = RFAILED;
10566                   }
10567                break;
10568             }
10569          case ProtocolIE_ID_id_RRCContainer:
10570             {
10571                /* Filling Dl RRC Msg Info */
10572                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
10573                if(!duUeCb->f1UeDb->dlRrcMsg)
10574                {
10575                   DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
10576                   ret = RFAILED;
10577                }
10578                else
10579                {
10580                   duUeCb->f1UeDb->dlRrcMsgPres = true;
10581                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
10582                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
10583                         &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer);
10584                }
10585                break;
10586             }
10587          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10588             {
10589                if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
10590                {
10591                   duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
10592                }
10593                else
10594                {
10595                   DU_LOG("\nERROR  -->  Ignoring delivery report, since rrcContainer is not present");
10596                }
10597                break;
10598             }
10599          case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
10600             {
10601                /* MaximumBitRate Uplink */
10602                bitRateSize = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.size;
10603                if(bitRateSize > 0)
10604                {
10605                   DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.ambrCfg, bitRateSize);
10606                   if(!duUeCb->f1UeDb->duUeCfg.ambrCfg)
10607                   {
10608                      DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
10609                      ret = RFAILED;
10610                   }
10611                   else
10612                   {
10613                      memset(duUeCb->f1UeDb->duUeCfg.ambrCfg, 0, sizeof(AmbrCfg));
10614                      memcpy(&duUeCb->f1UeDb->duUeCfg.ambrCfg->ulBr,
10615                            ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf, bitRateSize);
10616                   }
10617                }
10618                else
10619                   ret = RFAILED;
10620                break;
10621             }
10622          default:
10623             {
10624                break;
10625             }
10626       }
10627    }
10628    if(ret == RFAILED)
10629    {
10630       /*TODO : Negative case*/
10631       // BuildAndSendUeContextSetupRsp(cellId,ueIdx);
10632       DU_LOG("\nERROR  -->  F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
10633    }
10634    else
10635       ret = duProcUeContextSetupRequest(duUeCb);
10636
10637    freeAperDecodeF1UeContextSetupReq(ueSetReq);
10638    return ret;
10639
10640 }
10641 /*******************************************************************
10642  * @brief Free the memory allocated for Dl Tunnel Info
10643  *
10644  * @details
10645  *
10646  *    Function : freeDlTnlInfo
10647  *
10648  *    Functionality:
10649  *       Free the memory allocated for Dl Tunnel Info
10650  *
10651  * @params[in] DLUPTNLInformation_ToBeSetup_List_t *
10652  * @return void
10653  *
10654  * ****************************************************************/
10655
10656 void freeDlTnlInfo(DLUPTNLInformation_ToBeSetup_List_t *tnlInfo)
10657 {
10658    uint8_t arrIdx = 0;
10659
10660    if(tnlInfo)
10661    {
10662       for(arrIdx=0; arrIdx < tnlInfo->list.count; arrIdx++)
10663       {
10664          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf,\
10665                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
10666          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf,\
10667                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
10668          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
10669          DU_FREE(tnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
10670       }
10671       DU_FREE(tnlInfo->list.array, tnlInfo->list.size);
10672    }
10673 }
10674
10675 /*******************************************************************
10676  * @brief Free the memory allocated for DRB setup List
10677  *
10678  * @details
10679  *
10680  *    Function : freeDrbSetupList
10681  *
10682  *    Functionality:
10683  *       Free the memory allocated for DRB setup list
10684  *
10685  * @params[in] DRBs_Setup_List_t *
10686  * @return void
10687  *
10688  * ****************************************************************/
10689 void freeDrbSetupList(DRBs_Setup_List_t *drbSetupList)
10690 {
10691    uint8_t arrIdx = 0;
10692    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
10693
10694    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
10695    {
10696       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
10697       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
10698       DU_FREE(drbSetupList->list.array[arrIdx],  sizeof(DRBs_Setup_Item_t));
10699    }
10700    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
10701 }
10702
10703 /*******************************************************************
10704  * @brief Free the memory allocated for UE Setup response
10705  *
10706  * @details
10707  *
10708  *    Function : FreeUeContextSetupRsp
10709  *
10710  *    Functionality:
10711  *       Free the memory allocated for UE Setup response
10712  *
10713  * @params[in] F1AP PDU for UE setup response
10714  * @return ROK     - success
10715  *         RFAILED - failure
10716  *
10717  * ****************************************************************/
10718 void FreeUeContextSetupRsp(F1AP_PDU_t *f1apMsg)
10719 {
10720    uint8_t idx;
10721    UEContextSetupResponse_t *ueSetRsp = NULLP;
10722
10723    if(f1apMsg)
10724    {
10725       if(f1apMsg->choice.successfulOutcome)
10726       {
10727          ueSetRsp = &f1apMsg->choice.successfulOutcome->value.choice.\
10728                     UEContextSetupResponse;
10729          if(ueSetRsp->protocolIEs.list.array)
10730          {
10731             for(idx = 0; idx < ueSetRsp->protocolIEs.list.count; idx++)
10732             {
10733                if(ueSetRsp->protocolIEs.list.array[idx])
10734                {
10735                   switch(ueSetRsp->protocolIEs.list.array[idx]->id)
10736                   {
10737                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10738                         break;
10739                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10740                         break;
10741                      case ProtocolIE_ID_id_DUtoCURRCInformation:
10742                         {
10743                            CellGroupConfig_t *cellGrpCfg = NULLP;
10744                            cellGrpCfg  = &ueSetRsp->protocolIEs.list.array[idx]->value.choice.\
10745                                          DUtoCURRCInformation.cellGroupConfig;
10746                            if(cellGrpCfg->buf != NULLP)
10747                            {
10748                               DU_FREE(cellGrpCfg->buf, cellGrpCfg->size);
10749                               cellGrpCfg = NULLP;
10750                            }
10751                            break;
10752                         }
10753                     case ProtocolIE_ID_id_DRBs_Setup_List:
10754                         {
10755                            freeDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
10756                            break;
10757                         }
10758                      default:
10759                         DU_LOG("\nERROR  -->  DUAPP: Invalid Id %ld at FreeUeContextSetupRsp()",\
10760                         ueSetRsp->protocolIEs.list.array[idx]->id);
10761                         break;
10762                   }
10763                   DU_FREE(ueSetRsp->protocolIEs.list.array[idx],\
10764                         sizeof(UEContextSetupResponseIEs_t));
10765                }
10766             }
10767             DU_FREE(ueSetRsp->protocolIEs.list.array, \
10768                   ueSetRsp->protocolIEs.list.size);
10769          }
10770          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
10771       }
10772       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10773    }
10774 }
10775
10776 /*******************************************************************
10777  *
10778  * @brief Builds Ue context Setup Rsp DU To CU Info
10779  *
10780  * @details
10781  *
10782  *    Function : EncodeUeCntxtDuToCuInfo
10783  *
10784  *    Functionality: Builds Ue context Setup Rsp DU To CU Info
10785  *
10786  * @params[in] CellGroupConfig_t *, CellGroupConfigRrc_t *
10787  *
10788  * @return ROK     - success
10789  *         RFAILED - failure
10790  *
10791  ******************************************************************/
10792
10793 uint8_t EncodeUeCntxtDuToCuInfo(CellGroupConfig_t *duToCuCellGrp, CellGroupConfigRrc_t *duCellGrpCfg)
10794 {
10795    asn_enc_rval_t        encRetVal;
10796
10797    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, duCellGrpCfg);
10798    memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
10799    encBufSize = 0;
10800    encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, duCellGrpCfg, PrepFinalEncBuf, encBuf);
10801    /* Encode results */
10802    if(encRetVal.encoded == ENCODE_FAIL)
10803    {
10804       DU_LOG( "\nERROR  -->  F1AP : Could not encode UeCntxtDuToCuInfo (at %s)\n",\
10805             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10806       return RFAILED;
10807    }
10808    else
10809    {
10810       DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
10811       for(int i=0; i< encBufSize; i++)
10812       {
10813          printf("%x",encBuf[i]);
10814       }
10815    }
10816    duToCuCellGrp->size = encBufSize;
10817    DU_ALLOC(duToCuCellGrp->buf, duToCuCellGrp->size);
10818    if(!duToCuCellGrp->buf)
10819    {
10820       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in UeCntxtDuToCuInfo");
10821    }
10822    memcpy(duToCuCellGrp->buf, encBuf, duToCuCellGrp->size);
10823    return ROK;
10824 }
10825
10826 /*******************************************************************
10827  *
10828  * @brief Fills Dl Gtp tunnel Info
10829  *
10830  * @details
10831  *
10832  *    Function : fillGtpTunnelforDl
10833  *
10834  *    Functionality: Fills Dl Gtp tunnel Info
10835  *
10836  * @params[in]
10837  *
10838  * @return ROK     - success
10839  *         RFAILED - failure
10840  *
10841  * ****************************************************************/
10842
10843 uint8_t fillGtpTunnelforDl(GTPTunnel_t *gtpDl, GtpTnlCfg *gtpUeCfg)
10844 {
10845    uint8_t bufSize = 0;
10846
10847    gtpDl->transportLayerAddress.size    = 4*sizeof(uint8_t);
10848    DU_ALLOC(gtpDl->transportLayerAddress.buf, gtpDl->transportLayerAddress.size);
10849    if(gtpDl->transportLayerAddress.buf == NULLP)
10850    {
10851       return RFAILED;
10852    }
10853    memcpy(gtpDl->transportLayerAddress.buf, &gtpUeCfg->dlTnlAddress, gtpDl->transportLayerAddress.size);
10854
10855    /*GTP TEID*/
10856    gtpDl->gTP_TEID.size = 4 * sizeof(uint8_t);
10857    DU_ALLOC(gtpDl->gTP_TEID.buf, gtpDl->gTP_TEID.size);
10858    if(gtpDl->gTP_TEID.buf == NULLP)
10859    {
10860       return RFAILED;
10861    }
10862    bufSize = 3; /*forming an Octect String*/
10863    fillTeIdString(bufSize, gtpUeCfg->teId, gtpDl->gTP_TEID.buf);
10864
10865    return ROK;
10866 }
10867
10868 /*******************************************************************
10869  *
10870  * @brief Fills DL Tunnel Setup List
10871  *
10872  * @details
10873  *
10874  *    Function : fillDlTnlSetupList
10875  *
10876  *    Functionality: Fills the DL Tunnel Setup List
10877  *
10878  * @params[in]
10879  *
10880  * @return ROK     - success
10881  *         RFAILED - failure
10882  *
10883  * ****************************************************************/
10884
10885 uint8_t fillDlTnlSetupList(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo, UpTnlCfg *tnlCfg)
10886 {
10887    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
10888
10889    eleCount = 1;
10890    dlTnlInfo->list.count = eleCount;
10891    dlTnlInfo->list.size = (eleCount * sizeof(DLUPTNLInformation_ToBeSetup_Item_t *));
10892
10893    /* Initialize the DL Tnl Setup List Members */
10894    DU_ALLOC(dlTnlInfo->list.array, dlTnlInfo->list.size);
10895    if(dlTnlInfo->list.array == NULLP)
10896    {
10897       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL Tnl Setup List in fillDlTnlSetupList()");
10898       ret = RFAILED;
10899    }
10900    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
10901    {
10902       DU_ALLOC(dlTnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
10903       if(dlTnlInfo->list.array[arrIdx] == NULLP)
10904       {
10905          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDlTnlSetupList()", arrIdx);
10906          return RFAILED;
10907       }
10908       dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
10909       DU_ALLOC(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
10910       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel == NULLP)
10911       {
10912          DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL tunnel info in fillDlTnlSetupList()");
10913          return RFAILED;
10914       }
10915       ret = fillGtpTunnelforDl(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel,\
10916                tnlCfg->tnlCfg1);
10917       if(ret != ROK)
10918          break;
10919    }
10920    return ret;
10921 }
10922
10923 /*******************************************************************
10924  *
10925  * @brief Fills the Drb Setup List for Ue Context Setup Response
10926  *
10927  * @details
10928  *
10929  *    Function : fillDrbSetupList
10930  *
10931  *    Functionality: Fills the Drb Setup List for Ue Context Setup Response
10932  *
10933  * @params[in]
10934  *
10935  * @return ROK     - success
10936  *         RFAILED - failure
10937  *
10938  * ****************************************************************/
10939 uint8_t fillDrbSetupList(DRBs_Setup_List_t *drbSetupList, DuUeCfg *ueCfg)
10940 {
10941    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
10942    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
10943
10944    eleCount = ueCfg->numDrb;
10945    drbSetupList->list.count = eleCount;
10946    drbSetupList->list.size = \
10947         (eleCount * sizeof(DRBs_Setup_Item_t *));
10948
10949    /* Initialize the Drb Setup List Members */
10950    DU_ALLOC(drbSetupList->list.array, drbSetupList->list.size);
10951    if(drbSetupList->list.array == NULLP)
10952    {
10953       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DRB Setup List in fillDrbSetupList()");
10954       ret = RFAILED;
10955    }
10956
10957    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
10958    {
10959       DU_ALLOC(drbSetupList->list.array[arrIdx], sizeof(DRBs_Setup_Item_t));
10960       if(drbSetupList->list.array[arrIdx] == NULLP)
10961       {
10962          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDrbSetupList()", arrIdx);
10963          return RFAILED;
10964       }
10965       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
10966       drbItemIe->id = ProtocolIE_ID_id_DRBs_Setup_Item;
10967       drbItemIe->criticality = Criticality_reject;
10968       drbItemIe->value.present = DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item;
10969       drbItemIe->value.choice.DRBs_Setup_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
10970       ret = fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List,\
10971           &ueCfg->upTnlInfo[arrIdx]);
10972       if(ret != ROK)
10973          break;
10974    }
10975    return ret;
10976 }
10977
10978 /*******************************************************************
10979  *
10980  * @brief Builds and sends the UE Setup Response
10981  *
10982  * @details
10983  *
10984  *    Function : BuildAndSendUeContextSetupRsp
10985  *
10986  *    Functionality: Constructs the UE Setup Response and sends
10987  *                   it to the DU through SCTP.
10988  *
10989  * @params[in] uint8_t cellId,uint8_t ueIdx
10990  *
10991  * @return ROK     - success
10992  *         RFAILED - failure
10993  *
10994  * ****************************************************************/
10995 uint8_t BuildAndSendUeContextSetupRsp(uint8_t cellId,uint8_t ueIdx)
10996 {
10997    uint8_t   idx, ret, cellIdx, elementCnt;
10998    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
10999    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
11000    asn_enc_rval_t  encRetVal;        /* Encoder return value */
11001    F1AP_PDU_t               *f1apMsg = NULLP;
11002    UEContextSetupResponse_t *ueSetRsp = NULLP;
11003    CellGroupConfigRrc_t     *cellGrpCfg = NULLP;
11004    DuUeCb                   *ueCb = NULLP;
11005
11006    DU_LOG("\n INFO   -->  F1AP : Building UE Context Setup Response for cellId %d, ueIdx %d\n", cellId, ueIdx);
11007
11008    while(true)
11009    {
11010       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11011       if(f1apMsg == NULLP)
11012       {
11013          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11014          ret = RFAILED;
11015          break;
11016       }
11017
11018       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
11019       DU_ALLOC(f1apMsg->choice.successfulOutcome,
11020             sizeof(SuccessfulOutcome_t));
11021       if(f1apMsg->choice.successfulOutcome == NULLP)
11022       {
11023          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
11024          ret = RFAILED;
11025          break;
11026       }
11027
11028       f1apMsg->choice.successfulOutcome->procedureCode = \
11029                                                          ProcedureCode_id_UEContextSetup;
11030       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
11031       f1apMsg->choice.successfulOutcome->value.present = \
11032                                                          SuccessfulOutcome__value_PR_UEContextSetupResponse;
11033
11034       ueSetRsp =
11035          &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
11036       elementCnt = 4;
11037       ueSetRsp->protocolIEs.list.count = elementCnt;
11038       ueSetRsp->protocolIEs.list.size = \
11039                                         elementCnt * sizeof(UEContextSetupResponse_t *);
11040
11041       /* Initialize the UESetup members */
11042       DU_ALLOC(ueSetRsp->protocolIEs.list.array, \
11043             ueSetRsp->protocolIEs.list.size);
11044       if(ueSetRsp->protocolIEs.list.array == NULLP)
11045       {
11046          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
11047          ret = RFAILED;
11048          break;
11049       }
11050
11051       for(idx=0; idx<elementCnt; idx++)
11052       {
11053          DU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
11054                sizeof(UEContextSetupResponseIEs_t));
11055          if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
11056          {
11057             DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
11058             ret = RFAILED;
11059             break;
11060          }
11061       }
11062       /* Fetching Ue Cb Info*/
11063       GET_CELL_IDX(cellId, cellIdx);
11064       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
11065       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
11066       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
11067
11068       idx = 0;
11069       /*GNB CU UE F1AP ID*/
11070       ueSetRsp->protocolIEs.list.array[idx]->id = \
11071                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11072       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11073       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
11074                                                              UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
11075       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
11076
11077       /*GNB DU UE F1AP ID*/
11078       idx++;
11079       ueSetRsp->protocolIEs.list.array[idx]->id = \
11080                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11081       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11082       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
11083                                                              UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
11084       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
11085
11086
11087       /*DUtoCURRC Information */
11088       idx++;
11089       ueSetRsp->protocolIEs.list.array[idx]->id  = \
11090                                                    ProtocolIE_ID_id_DUtoCURRCInformation;
11091       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11092       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
11093                                                             UEContextSetupResponseIEs__value_PR_DUtoCURRCInformation;
11094       if(ueCb->f1UeDb)
11095       {
11096          if(ueCb->f1UeDb->duUeCfg.cellGrpCfg)
11097          {
11098             cellGrpCfg = (CellGroupConfigRrc_t*)ueCb->f1UeDb->duUeCfg.cellGrpCfg;
11099             ret = EncodeUeCntxtDuToCuInfo(&ueSetRsp->protocolIEs.list.array[idx]->value.\
11100                      choice.DUtoCURRCInformation.cellGroupConfig, cellGrpCfg);
11101             if(ret == RFAILED)
11102             {
11103                DU_LOG("\nERROR  -->  F1AP : Failed to EncodeUeCntxtDuToCuInfo in BuildAndSendUeContextSetupRsp()");
11104                freeF1UeDb(ueCb->f1UeDb);
11105                ueCb->f1UeDb = NULLP;
11106                break;
11107             }
11108          }
11109       }
11110       else
11111       {
11112          DU_LOG("\nERROR  -->  F1AP : Failed to form DUtoCU RRCInfo at BuildAndSendUeContextSetupRsp()");
11113          ret = RFAILED;
11114          break;
11115       }
11116
11117       /* Drb Setup List */
11118       idx++;
11119       ueSetRsp->protocolIEs.list.array[idx]->id  = \
11120                                  ProtocolIE_ID_id_DRBs_Setup_List;
11121       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11122       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
11123                                  UEContextSetupResponseIEs__value_PR_DRBs_Setup_List;
11124       ret = fillDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List,\
11125                &ueCb->f1UeDb->duUeCfg);
11126       if(ret == RFAILED)
11127       {
11128          DU_LOG("\nERROR  -->  F1AP : Failed to fillDrbSetupList in BuildAndSendUeContextSetupRsp()");
11129          freeF1UeDb(ueCb->f1UeDb);
11130          ueCb->f1UeDb = NULLP;
11131          break;
11132       }
11133
11134        /* Free UeContext Db created during Ue context Req */
11135        freeF1UeDb(ueCb->f1UeDb);
11136        ueCb->f1UeDb = NULLP;
11137
11138       /* TODO: To send Drb list */
11139       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11140
11141       /* Encode the UE context setup response type as APER */
11142       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
11143       encBufSize = 0;
11144       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11145             encBuf);
11146       /* Encode results */
11147       if(encRetVal.encoded == ENCODE_FAIL)
11148       {
11149          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Response structure (at %s)\n",\
11150                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11151          ret = RFAILED;
11152          break;
11153       }
11154       else
11155       {
11156          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Setup Response\n");
11157          for(int i=0; i< encBufSize; i++)
11158          {
11159             printf("%x",encBuf[i]);
11160          }
11161       }
11162
11163       /* Sending  msg  */
11164       if(sendF1APMsg()  != ROK)
11165       {
11166          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Response failed");
11167          ret = RFAILED;
11168          break;
11169       }
11170       break;
11171    }
11172    FreeUeContextSetupRsp(f1apMsg);
11173    return ret;
11174 }/* End of BuildAndSendUeContextSetupRsp */
11175 /*******************************************************************
11176 *
11177 * @brief  Build And Send Ue Context Rsp
11178 *
11179 * @details
11180 *
11181 *    Function : BuildAndSendUeCtxtRsp
11182 *
11183 *    Functionality : Build And Send Ue Context Rsp
11184
11185 * @params[in]
11186 * @return sucess = ROK
11187 *         failure = RFAILED
11188 *
11189 * ****************************************************************/
11190 uint8_t BuildAndSendUeCtxtRsp(uint8_t cellId, uint8_t ueIdx)
11191 {
11192    uint8_t cellIdx = 0, actionType = 0;
11193
11194    GET_CELL_IDX(cellId, cellIdx);
11195    actionType = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].f1UeDb->actionType;
11196
11197    switch(actionType)
11198    {
11199       case UE_CTXT_SETUP:
11200          {
11201             BuildAndSendUeContextSetupRsp(cellId,ueIdx);
11202             break;
11203          }
11204       case UE_CTXT_MOD:
11205          {
11206             BuildAndSendUeContextModRsp(cellId, ueIdx);
11207             break;
11208          }
11209       default:
11210          DU_LOG("ERROR  -->  F1AP: Invalid Action Type %d at BuildAndSendUeCtxtRsp()", actionType);
11211          break;
11212
11213    }
11214    return ROK;
11215 }
11216
11217 /*******************************************************************
11218  *
11219  * @brief deallocating the memory of  F1reset msg
11220  *
11221  * @details
11222  *
11223  *    Function : FreeF1ResetReq
11224  *
11225  *    Functionality :
11226  *         - freeing memory of F1reset request msg
11227  *
11228  * @params[in]
11229  * @return void
11230  *
11231  *
11232  * ****************************************************************/
11233 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
11234 {
11235    uint8_t idx =0 ;
11236    Reset_t *f1ResetMsg;
11237
11238    if(f1apMsg)
11239    {
11240       if(f1apMsg->choice.initiatingMessage)
11241       {
11242          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11243
11244          if(f1ResetMsg->protocolIEs.list.array)
11245          {
11246             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
11247             {
11248                if(f1ResetMsg->protocolIEs.list.array[idx])
11249                {
11250                   DU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
11251                }
11252             }
11253             DU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
11254          }
11255          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11256       }
11257       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11258    }
11259 }
11260 /*******************************************************************
11261  *
11262  * @brief Build and Send F1reset request
11263  *
11264  * @details
11265  *
11266  *    Function : BuildAndSendF1ResetReq
11267  *
11268  *    Functionality:
11269  *         - Build and Send F1reset request msg
11270  *
11271  * @params[in]
11272  * @return ROK     - success
11273  *         RFAILED - failure
11274  *
11275  * ****************************************************************/
11276 uint8_t BuildAndSendF1ResetReq()
11277 {
11278    uint8_t          elementCnt=0;
11279    uint8_t          idx=0;
11280    uint8_t          ret= RFAILED;
11281    Reset_t          *f1ResetMsg = NULLP;
11282    F1AP_PDU_t       *f1apMsg = NULLP;
11283    asn_enc_rval_t   encRetVal;
11284    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset request \n");
11285    do
11286    {
11287       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11288       if(f1apMsg == NULLP)
11289       {
11290          break;
11291       }
11292       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
11293       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11294       if(f1apMsg->choice.initiatingMessage == NULLP)
11295       {
11296          break;
11297       }
11298       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
11299       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
11300       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
11301
11302       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11303
11304       elementCnt = 3;
11305       f1ResetMsg->protocolIEs.list.count = elementCnt;
11306       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
11307
11308       /* Initialize the F1Setup members */
11309       DU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
11310       if(f1ResetMsg->protocolIEs.list.array == NULLP)
11311       {
11312          break;
11313       }
11314       for(idx=0; idx<elementCnt; idx++)
11315       {
11316          DU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
11317          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
11318          {
11319             break;
11320          }
11321       }
11322
11323       /*TransactionID*/
11324       idx=0;
11325       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
11326       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11327       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
11328       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
11329
11330       /*Cause*/
11331       idx++;
11332       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
11333       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
11334       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
11335       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
11336       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
11337
11338       /*Reset Type*/
11339       idx++;
11340       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
11341       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11342       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
11343       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
11344       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
11345
11346       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11347
11348       /* Encode the F1SetupRequest type as APER */
11349       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11350       encBufSize = 0;
11351       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11352             encBuf);
11353
11354       /* Encode results */
11355       if(encRetVal.encoded == ENCODE_FAIL)
11356       {
11357          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
11358                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11359          break;
11360       }
11361       else
11362       {
11363          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1Reset\n");
11364          for(idx=0; idx< encBufSize; idx++)
11365          {
11366             printf("%x",encBuf[idx]);
11367          }
11368       }
11369
11370       if(sendF1APMsg() != ROK)
11371       {
11372          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
11373          break;
11374       }
11375
11376       ret = ROK;
11377       break;
11378    }while(true);
11379
11380    FreeF1ResetReq(f1apMsg);
11381    return ret;
11382 }
11383 /*******************************************************************
11384  *
11385  * @brief Build And Send F1ResetAck
11386  *
11387  * @details
11388  *
11389  *    Function : BuildAndSendF1ResetAck
11390  *
11391  *    Functionality:
11392  *         - Build And Send  F1ResetRSP
11393  *
11394  * @return ROK     - success
11395  *         RFAILED - failure
11396  *
11397  * ****************************************************************/
11398 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
11399 {
11400    uint8_t idx;
11401    ResetAcknowledge_t *f1ResetAck;
11402
11403    if(f1apMsg)
11404    {
11405       if(f1apMsg->choice.successfulOutcome)
11406       {
11407          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
11408
11409          if(f1ResetAck->protocolIEs.list.array)
11410          {
11411             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
11412             {
11413                if(f1ResetAck->protocolIEs.list.array[idx])
11414                {
11415                   DU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
11416                }
11417             }
11418             DU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
11419          }
11420          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11421       }
11422       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11423    }
11424 }
11425
11426 /*******************************************************************
11427  *
11428  * @brief Build And Send F1ResetAck
11429  *
11430  * @details
11431  *
11432  *    Function : BuildAndSendF1ResetAck
11433  *
11434  *    Functionality:
11435  *         - Build And Send  F1ResetRSP
11436  *
11437  *  @params[in]
11438  * @return ROK     - success
11439  *         RFAILED - failure
11440  *
11441  * ****************************************************************/
11442 uint8_t BuildAndSendF1ResetAck()
11443 {
11444    uint8_t                idx = 0;
11445    uint8_t                elementCnt = 0;
11446    uint8_t                ret = RFAILED;
11447    F1AP_PDU_t             *f1apMsg = NULL;
11448    ResetAcknowledge_t     *f1ResetAck = NULLP;
11449    asn_enc_rval_t         encRetVal;
11450    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset Acknowledgment \n");
11451
11452    do{
11453       /* Allocate the memory for F1ResetRequest_t */
11454       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11455       if(f1apMsg == NULLP)
11456       {
11457          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11458          break;
11459       }
11460
11461       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
11462
11463       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11464       if(f1apMsg->choice.successfulOutcome == NULLP)
11465       {
11466          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11467          break;
11468       }
11469       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
11470       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
11471       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
11472
11473       elementCnt = 1;
11474
11475       f1ResetAck->protocolIEs.list.count = elementCnt;
11476       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
11477
11478       DU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
11479       if(f1ResetAck->protocolIEs.list.array == NULLP)
11480       {
11481          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
11482          break;
11483       }
11484
11485       for(idx=0; idx<elementCnt; idx++)
11486       {
11487          DU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
11488          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
11489          {
11490             break;
11491          }
11492       }
11493       /*TransactionID*/
11494       idx = 0;
11495       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
11496       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11497       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
11498       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
11499
11500       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11501
11502       /* Encode the F1SetupRequest type as UPER */
11503       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11504       encBufSize = 0;
11505       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
11506
11507       /* Check encode results */
11508       if(encRetVal.encoded == ENCODE_FAIL)
11509       {
11510          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
11511                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11512          break;
11513       }
11514       else
11515       {
11516          DU_LOG("\nDUBUG   -->  F1AP : Created APER encoded buffer for F1ResetAck\n");
11517          for(int i=0; i< encBufSize; i++)
11518          {
11519             printf("%x",encBuf[i]);
11520          }
11521       }
11522       /* Sending msg */
11523       if(sendF1APMsg() != ROK)
11524       {
11525          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Acknowledgement failed");
11526          break;
11527       }
11528
11529       ret = ROK;
11530       break;
11531    }while(true);
11532
11533    FreeF1ResetAck(f1apMsg);
11534    return ret;
11535 }
11536 /******************************************************************
11537 *
11538 * @brief free F1 reset msg allocated by aper_decoder
11539 *
11540 * @details
11541 *
11542 *    Function : freeAperDecodeF1ResetMsg
11543 *
11544 *    Functionality: free F1 reset msg allocated by aper_decoder
11545 *
11546 * @params[in] Reset_t *f1ResetMsg
11547 * @return void
11548 *
11549 * ****************************************************************/
11550
11551 void freeAperDecodeF1ResetMsg(Reset_t *f1ResetMsg)
11552 {
11553    uint8_t ieIdx =0;
11554    if(f1ResetMsg->protocolIEs.list.array)
11555    {
11556       for(ieIdx=0 ;ieIdx < f1ResetMsg->protocolIEs.list.count ; ieIdx++)
11557       {
11558          if(f1ResetMsg->protocolIEs.list.array[ieIdx])
11559          {
11560             free(f1ResetMsg->protocolIEs.list.array[ieIdx]);
11561          }
11562       }
11563       free(f1ResetMsg->protocolIEs.list.array);
11564    }
11565 }
11566
11567 /******************************************************************
11568  *
11569  * @brief Processes DL RRC Message Transfer  sent by CU
11570  *
11571  * @details
11572  *
11573  *    Function : procF1ResetReq
11574  *
11575  *    Functionality: Processes DL RRC Message Transfer sent by CU
11576  *
11577  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11578  * @return ROK     - success
11579  *         RFAILED - failure
11580  *
11581  * ****************************************************************/
11582 uint8_t procF1ResetReq(F1AP_PDU_t *f1apMsg)
11583 {
11584    /* we are currently not supporting Ue release. right now we are supporting only init case of fireset */
11585    uint8_t       ieIdx = 0;
11586    uint8_t        ret = ROK;
11587    Reset_t       *f1ResetMsg = NULLP;
11588
11589    DU_LOG("\nINFO   -->  Processing F1 reset request");
11590    f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11591
11592    for(ieIdx=0; ieIdx<f1ResetMsg->protocolIEs.list.count; ieIdx++)
11593    {
11594       switch(f1ResetMsg->protocolIEs.list.array[ieIdx]->id)
11595       {
11596          case ProtocolIE_ID_id_TransactionID:
11597             break;
11598
11599          case ProtocolIE_ID_id_Cause:
11600             break;
11601
11602          case ProtocolIE_ID_id_ResetType:
11603             {
11604                break;
11605             }
11606
11607          default:
11608             break;
11609       }
11610    }
11611    ret = BuildAndSendF1ResetAck();
11612    DU_LOG("\nINFO   -->  UE release is not supported for now");
11613
11614    freeAperDecodeF1ResetMsg(f1ResetMsg);
11615
11616    return ret;
11617 }
11618
11619 /*******************************************************************
11620  *
11621  * @brief free the RRC delivery report
11622  *
11623  * @details
11624  *
11625  *    Function : freeRrcDeliveryReport
11626  *
11627  *    Functionality: free the RRC delivery report
11628  *
11629  * @params[in]
11630  * @return ROK     - success
11631  *         RFAILED - failure
11632  *
11633  * ****************************************************************/
11634 void freeRrcDeliveryReport(F1AP_PDU_t  *f1apMsg )
11635 {
11636    uint8_t idx=0;
11637    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11638
11639    if(f1apMsg)
11640    {
11641       if(f1apMsg->choice.initiatingMessage)
11642       {
11643          rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11644          if(rrcDeliveryReport->protocolIEs.list.array)
11645          {
11646             for(idx =0 ;idx <rrcDeliveryReport->protocolIEs.list.count ;
11647                   idx++)
11648             {
11649                if(rrcDeliveryReport->protocolIEs.list.array[idx])
11650                {
11651                   DU_FREE(rrcDeliveryReport->protocolIEs.list.array[idx],
11652                         sizeof(RRCDeliveryReportIEs_t));
11653                }
11654             }
11655             DU_FREE(rrcDeliveryReport->protocolIEs.list.array,
11656                   rrcDeliveryReport->protocolIEs.list.size);
11657          }
11658          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11659       }
11660       DU_FREE(f1apMsg,
11661             sizeof(F1AP_PDU_t));
11662    }
11663 }
11664
11665 /*******************************************************************
11666 *
11667 * @brief Builds and sends the RRC delivery report
11668 *
11669 * @details
11670 *
11671 *    Function : BuildAndSendRrcDeliveryReport
11672 *
11673 *    Functionality: Builds and sends the RRC delivery report
11674 *
11675 * @params[in]
11676 *
11677 * @return ROK     - success
11678 *         RFAILED - failure
11679 *
11680 * ****************************************************************/
11681 uint8_t BuildAndSendRrcDeliveryReport(uint32_t gnbCuUeF1apId, \
11682    uint32_t gnbDuUeF1apId, RrcDeliveryReport *rrcDelivery)
11683 {
11684    uint8_t             ret = RFAILED;
11685    uint8_t             idx    = 0;
11686    uint8_t             idx1   = 0;
11687    uint8_t             elementCnt = 0;
11688    F1AP_PDU_t          *f1apMsg = NULLP;
11689    asn_enc_rval_t      encRetVal;
11690    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11691
11692    do{
11693
11694       DU_LOG("\nINFO   -->  F1AP : Building RRC delivery Message Transfer Message\n");
11695       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11696       if(f1apMsg == NULLP)
11697       {
11698          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11699          break;
11700       }
11701       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
11702       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11703       if(f1apMsg->choice.initiatingMessage == NULLP)
11704       {
11705          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU  failed");
11706          break;
11707       }
11708       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_RRCDeliveryReport;
11709       f1apMsg->choice.initiatingMessage->criticality   = Criticality_ignore;
11710       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RRCDeliveryReport;
11711
11712       rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11713       elementCnt = 4;
11714       rrcDeliveryReport->protocolIEs.list.count = elementCnt;
11715       rrcDeliveryReport->protocolIEs.list.size = elementCnt * sizeof(RRCDeliveryReportIEs_t *);
11716
11717       /* Initialize the F1Setup members */
11718       DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array, rrcDeliveryReport->protocolIEs.list.size);
11719       if(rrcDeliveryReport->protocolIEs.list.array == NULLP)
11720       {
11721          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRC Delivery  failed");
11722          break;
11723       }
11724       for(idx =0 ;idx <elementCnt; idx++)
11725       {
11726          DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array[idx], sizeof(RRCDeliveryReportIEs_t));
11727          if(rrcDeliveryReport->protocolIEs.list.array[idx] == NULLP)
11728          {
11729             break;
11730          }
11731       }
11732
11733       idx1 = 0;
11734
11735       /*GNB CU UE F1AP ID*/
11736       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11737       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
11738       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_CU_UE_F1AP_ID;
11739       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
11740
11741       /*GNB DU UE F1AP ID*/
11742       idx1++;
11743       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11744       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
11745       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_DU_UE_F1AP_ID;
11746       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
11747
11748       /*RRC delivery status*/
11749       idx1++;
11750       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_RRCDeliveryStatus;
11751       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
11752       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_RRCDeliveryStatus;
11753       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.delivery_status =\
11754       rrcDelivery->rrcDeliveryStatus.deliveryStatus;
11755       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.triggering_message =\
11756       rrcDelivery->rrcDeliveryStatus.triggeringMessage;
11757
11758       /* SRB ID */
11759       idx1++;
11760       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
11761       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
11762       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_SRBID;
11763       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.SRBID =  rrcDelivery->srbId;
11764
11765       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11766
11767       /* Encode the RRC DELIVERY REPORT type as APER */
11768       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11769       encBufSize = 0;
11770       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11771             encBuf);
11772
11773       /* Encode results */
11774       if(encRetVal.encoded == ENCODE_FAIL)
11775       {
11776          DU_LOG("\nERROR  -->  F1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
11777                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11778          break;
11779       }
11780       else
11781       {
11782          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for RRC Delivery Msg \n");
11783          for(idx=0; idx< encBufSize; idx++)
11784          {
11785             printf("%x",encBuf[idx]);
11786          }
11787       }
11788
11789       /* Sending msg */
11790       if(sendF1APMsg() != ROK)
11791       {
11792          DU_LOG("\nERROR  -->  F1AP : Sending RRC delivery  msg request failed");
11793          break;
11794       }
11795       ret = ROK;
11796       break;
11797
11798    }while(true);
11799
11800    freeRrcDeliveryReport(f1apMsg);
11801    return ret;
11802 }
11803
11804 /*******************************************************************
11805  *
11806  * @brief Processes cells to be activated
11807  *
11808  * @details
11809  *
11810  *    Function : extractCellsToBeActivated
11811  *
11812  *    Functionality:
11813  *      - Processes cells to be activated list received in F1SetupRsp
11814  *
11815  * @params[in] void
11816  * @return ROK     - success
11817  *         RFAILED - failure
11818  *
11819  * ****************************************************************/
11820
11821 uint8_t extractCellsToBeActivated(Cells_to_be_Activated_List_t cellsToActivate)
11822 {
11823    uint8_t  ret = ROK;
11824    uint16_t idx, nci, pci = 0;
11825    Cells_to_be_Activated_List_Item_t cell;
11826
11827    for(idx=0; idx<cellsToActivate.list.count; idx++)
11828    {
11829       nci = 0;
11830       cell = cellsToActivate.list.array[idx]->value.choice.Cells_to_be_Activated_List_Item;
11831       bitStringToInt(&cell.nRCGI.nRCellIdentity, &nci);
11832
11833       if(cell.nRPCI)
11834       {
11835          pci = *cell.nRPCI;
11836       }
11837       ret = duProcCellsToBeActivated(cell.nRCGI.pLMN_Identity.buf, nci, pci);
11838    }
11839    return ret;
11840 }
11841 /******************************************************************
11842 *
11843 * @brief Processes F1 Setup Response allocated by aper_decoder
11844 *
11845 * @details
11846 *
11847 *    Function : freeF1SetupRsp
11848 *
11849 *    Functionality: free F1 Setup Response allocated by aper_decoder
11850 *
11851 * @params[in] F1SetupResponse_t *f1SetRspMsg
11852 * @return void
11853 *
11854 * ****************************************************************/
11855
11856 void freeAperDecodeF1SetupRsp(F1SetupResponse_t *f1SetRspMsg)
11857 {
11858    uint8_t ieIdx =0;
11859    uint8_t arrIdx =0;
11860    Cells_to_be_Activated_List_t *cellToActivate =NULLP;
11861    RRC_Version_t      *rrcVer =NULLP;
11862
11863    if(f1SetRspMsg->protocolIEs.list.array)
11864    {
11865       for(ieIdx=0; ieIdx<f1SetRspMsg->protocolIEs.list.count; ieIdx++)
11866       {
11867          if(f1SetRspMsg->protocolIEs.list.array[ieIdx])
11868          {
11869             switch(f1SetRspMsg->protocolIEs.list.array[ieIdx]->id)
11870             {
11871                case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11872                   {
11873                      cellToActivate =
11874                         &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.Cells_to_be_Activated_List;
11875                      if(cellToActivate->list.array)
11876                      {
11877                         for(arrIdx=0; arrIdx<cellToActivate->list.count ; arrIdx++)
11878                         {
11879                            if(cellToActivate->list.array[arrIdx])
11880                            {
11881
11882                               if(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.\
11883                               pLMN_Identity.buf)
11884                               {
11885                                  if(cellToActivate->list.array[0]->value.choice.\
11886                                        Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf)
11887                                  {
11888                                     free(cellToActivate->list.array[0]->value.choice.\
11889                                           Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf);
11890                                  }
11891
11892                                  free(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
11893                                        nRCGI.pLMN_Identity.buf);
11894                               }
11895                               free(cellToActivate->list.array[arrIdx]);
11896                            }
11897                         }
11898                         free(cellToActivate->list.array);
11899                      }
11900                      break;
11901                   }
11902                case ProtocolIE_ID_id_TransactionID:
11903                   {
11904                      break;
11905                   }
11906                case ProtocolIE_ID_id_gNB_CU_Name:
11907                   {
11908                      free(f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_Name.buf);
11909                      break;
11910                   }
11911                case ProtocolIE_ID_id_GNB_CU_RRC_Version:
11912                   {
11913                      rrcVer = &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
11914                      if(rrcVer->latest_RRC_Version.buf)
11915                      {
11916                         if(rrcVer->iE_Extensions)
11917                         {
11918                            if(rrcVer->iE_Extensions->list.array)
11919                            {
11920                               if(rrcVer->iE_Extensions->list.array[0])
11921                               {
11922                                  if(rrcVer->iE_Extensions->list.\
11923                                        array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf)
11924                                  {
11925                                     free(rrcVer->iE_Extensions->list.\
11926                                           array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf);
11927                                  }
11928                                  free(rrcVer->iE_Extensions->list.array[0]);
11929                               }
11930                               free(rrcVer->iE_Extensions->list.array);
11931                            }
11932                            free(rrcVer->iE_Extensions);
11933                         }
11934                         free(rrcVer->latest_RRC_Version.buf);
11935                      }
11936                      break;
11937
11938                   }
11939                default:
11940                   {
11941                      DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
11942                            f1SetRspMsg->protocolIEs.list.array[ieIdx]->id);
11943                   }
11944             }
11945             free(f1SetRspMsg->protocolIEs.list.array[ieIdx]);
11946          }
11947       }
11948       free(f1SetRspMsg->protocolIEs.list.array);
11949    }
11950 }
11951 /******************************************************************
11952  *
11953  * @brief Processes F1 Setup Response sent by CU
11954  *
11955  * @details
11956  *
11957  *    Function : procF1SetupRsp
11958  *
11959  *    Functionality: Processes F1 Setup Response sent by CU
11960  *
11961  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11962  * @return ROK     - success
11963  *         RFAILED - failure
11964  *
11965  * ****************************************************************/
11966 uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg)
11967 {
11968    uint8_t ret = ROK;
11969    uint16_t idx =0;
11970    F1SetupResponse_t *f1SetRspMsg = NULLP;
11971    GNB_CU_Name_t     *cuName = NULLP;
11972    F1SetupRsp  f1SetRspDb;
11973    RRC_Version_t      *rrcVer =NULLP;
11974
11975    memset(&f1SetRspDb, 0, sizeof(F1SetupRsp));
11976
11977    DU_LOG("\nINFO   -->  F1AP : F1 Setup Response received");
11978    f1SetRspMsg = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
11979
11980    for(idx=0; idx<f1SetRspMsg->protocolIEs.list.count; idx++)
11981    {
11982       switch(f1SetRspMsg->protocolIEs.list.array[idx]->id)
11983       {
11984          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11985             {
11986                extractCellsToBeActivated(f1SetRspMsg->protocolIEs.list.array[idx]->\
11987                      value.choice.Cells_to_be_Activated_List);
11988                break;
11989             }
11990          case ProtocolIE_ID_id_TransactionID:
11991             {
11992                f1SetRspDb.transId = f1SetRspMsg->protocolIEs.list.array[idx]->\
11993                                     value.choice.TransactionID;
11994                break;
11995             }
11996          case ProtocolIE_ID_id_gNB_CU_Name:
11997             {
11998                cuName = &f1SetRspMsg->protocolIEs.list.array[idx]->\
11999                         value.choice.GNB_CU_Name;
12000                strcpy(f1SetRspDb.cuName, (const char*)cuName->buf);
12001                break;
12002             }
12003          case ProtocolIE_ID_id_GNB_CU_RRC_Version:
12004             {
12005                rrcVer = &f1SetRspMsg->protocolIEs.list.array[idx]->value.choice.RRC_Version;
12006                strcpy(f1SetRspDb.rrcVersion.rrcVer,
12007                      (const char*)rrcVer->latest_RRC_Version.buf);
12008                break;
12009             }
12010          default:
12011             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
12012                   f1SetRspMsg->protocolIEs.list.array[idx]->id);
12013       }
12014       duProcF1SetupRsp();
12015    }
12016
12017    freeAperDecodeF1SetupRsp(f1SetRspMsg);
12018    return ret;
12019 }
12020 /*******************************************************************
12021 *
12022 * @brief free GNB DU config update ack
12023 *
12024 * @details
12025 *
12026 *    Function : freeAperDecodeGnbDuAck
12027 *
12028 *    Functionality: Processes GNB DU config update ack And
12029 *                     added free part for the memory allocated by aper_decoder
12030 *
12031 * @params[in] F1AP_PDU_t ASN decoded F1AP message
12032 * @return ROK     - success
12033 *         RFAILED - failure
12034 *
12035 * ****************************************************************/
12036
12037 void freeAperDecodeGnbDuAck(GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck)
12038 {
12039    uint8_t ieIdx = 0;
12040
12041    if(gnbDuAck->protocolIEs.list.array)
12042    {
12043       for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
12044       {
12045          if(gnbDuAck->protocolIEs.list.array[ieIdx])
12046          {
12047             free(gnbDuAck->protocolIEs.list.array[ieIdx]);
12048          }
12049       }
12050       free(gnbDuAck->protocolIEs.list.array);
12051    }
12052 }
12053
12054 /*******************************************************************
12055 *
12056 * @brief Building  result of gnb-du config update ack output
12057 *
12058 * @details
12059 *
12060 *    Function : duProcGnbDuCfgUpdAckMsg
12061 *
12062 *    Functionality:
12063 *        Building output of gnb-du config update ack
12064 *
12065 * @params[in] transId
12066 * @return void
12067 *
12068 * ****************************************************************/
12069
12070 uint8_t duProcGnbDuCfgUpdAckMsg(uint8_t transId)
12071 {
12072    uint8_t  ieIdx=0, arrIdx=0,ret=ROK;
12073    uint8_t  ueId =0 , ueIdx =0;
12074    uint16_t cellId =0, cellIdx =0, crnti=0;
12075    CmLList *f1apPduNode = NULLP;
12076    ReservedF1apPduInfo *f1apPduInfo =NULLP;
12077    F1AP_PDU_t *f1apMsgPdu = NULLP;
12078    GNBDUConfigurationUpdate_t *gnbDuConfigUpdate = NULLP;
12079    BIT_STRING_t *cellIdentity=NULLP;
12080    struct Served_Cells_To_Delete_ItemIEs *deleteItemIe=NULLP;
12081    Served_Cells_To_Delete_List_t *cellsToDelete=NULLP;
12082    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
12083
12084    DU_LOG("\nINFO   -->  DU APP: GNB-DU config update Ack received ");
12085    f1apPduNode = searchFromReservedF1apPduList(transId);
12086    f1apPduInfo = (ReservedF1apPduInfo *)f1apPduNode->node;
12087    f1apMsgPdu = (F1AP_PDU_t *)f1apPduInfo->f1apMsg;
12088
12089    if(f1apMsgPdu)
12090    {
12091       if(f1apMsgPdu->choice.initiatingMessage)
12092       {
12093          gnbDuConfigUpdate = &f1apMsgPdu->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
12094          for(ieIdx=0; ieIdx < gnbDuConfigUpdate->protocolIEs.list.count; ieIdx++)
12095          {
12096             switch(gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->id)
12097             {
12098                case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
12099                   {
12100                      cellsToDelete = &gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
12101                                      Served_Cells_To_Delete_List;
12102                      if(cellsToDelete->list.array)
12103                      {
12104                         if(cellsToDelete->list.array[arrIdx])
12105                         {
12106                            deleteItemIe = (Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx];
12107                            deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
12108                            if(deleteItem->oldNRCGI.nRCellIdentity.buf)
12109                            {
12110                               cellIdentity = &deleteItem->oldNRCGI.nRCellIdentity;
12111                               bitStringToInt(cellIdentity, &cellId);
12112                            }
12113                         }
12114                      }
12115
12116                      GET_CELL_IDX(cellId, cellIdx);
12117                      if(duCb.actvCellLst[cellIdx] != NULLP)
12118                      {
12119                         if(duCb.actvCellLst[cellIdx]->numActvUes == 0)
12120                         {
12121                            duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
12122                            ret = duSendCellDeletReq(cellId);
12123                            if(ret == RFAILED)
12124                            {
12125                               DU_LOG("ERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to send cell delete\
12126                               request for cellId[%d]", cellId);
12127                            }
12128                         }
12129                         else
12130                         {
12131                            for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
12132                            {
12133                               crnti = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].crnti;
12134                               GET_UE_IDX(crnti,ueId);
12135                               ret = BuildAndSendUeContextReleaseReq(cellId, ueId);
12136                               if(ret == RFAILED)
12137                               {
12138                                  DU_LOG("ERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to build and send UE delete\
12139                                  request for cellId[%d]", cellId);
12140                               }
12141                            }
12142                         }
12143                      }
12144                      else
12145                      {
12146                         DU_LOG("ERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): CellId [%d] not found", cellId);
12147                         ret = RFAILED;
12148                      }
12149                      break;
12150                   }
12151
12152                default:
12153                   break;
12154             }
12155          }
12156       }
12157    }
12158
12159    FreeDUConfigUpdate(f1apMsgPdu);
12160    deleteFromReservedF1apPduList(f1apPduNode);
12161    return ret;
12162 }
12163
12164 /*******************************************************************
12165 *
12166 * @brief Processes GNB DU config update ack
12167 *
12168 * @details
12169 *
12170 *    Function : procF1GNBDUCfgUpdAck
12171 *
12172 *    Functionality: added free part for the memory allocated by aper_decoder
12173 *
12174 * @params[in] F1AP_PDU_t *f1apMsg
12175 * @return void
12176 *
12177 * ****************************************************************/
12178 uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
12179 {
12180    uint8_t ieIdx=0,transId=0;
12181    GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
12182
12183    DU_LOG("\nINFO   -->  F1AP : GNB-DU config update acknowledgment");
12184    gnbDuAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
12185
12186    for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
12187    {
12188       switch(gnbDuAck->protocolIEs.list.array[ieIdx]->id)
12189       {
12190          case ProtocolIE_ID_id_TransactionID:
12191             {
12192                transId = gnbDuAck->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
12193                break;
12194             }
12195          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
12196             {
12197                break;
12198             }
12199          default :
12200             {
12201                DU_LOG("\nERROR  -->  F1AP: procF1GNBDUCfgUpdAck(): Invalid IE Received: %ld", \
12202                      gnbDuAck->protocolIEs.list.array[ieIdx]->id);
12203                break;
12204             }
12205       }
12206    }
12207
12208    duProcGnbDuCfgUpdAckMsg(transId);
12209
12210 #if 0
12211    /* presently we are not supporting F1 Reset from DU to CU , we are only
12212     * supporting F1 Reset from CU to DU */
12213
12214    if(BuildAndSendF1ResetReq() != ROK)
12215    {
12216       return RFAILED;
12217    }
12218 #endif
12219
12220    freeAperDecodeGnbDuAck(gnbDuAck);
12221    return ROK;
12222 }
12223 /******************************************************************
12224 *
12225 * @brief free DL RRC Message Transfer allocated by aper_decoder
12226 *
12227 * @details
12228 *
12229 *    Function : freeAperDecodef1DlRrcMsg
12230 *
12231 *    Functionality: free DL RRC Message Transfer allocated by aper_decoder
12232 *
12233 * @params[in] DLRRCMessageTransfer_t *f1DlRrcMsg
12234 * @return ROK     - success
12235 *         RFAILED - failure
12236 *
12237 * ****************************************************************/
12238
12239 void freeAperDecodef1DlRrcMsg(DLRRCMessageTransfer_t *f1DlRrcMsg)
12240 {
12241    uint8_t ieIdx =0;
12242    RRCContainer_t *rrcContainer = NULLP;
12243
12244    if(f1DlRrcMsg->protocolIEs.list.array)
12245    {
12246       for(ieIdx=0; ieIdx<f1DlRrcMsg->protocolIEs.list.count; ieIdx++)
12247       {
12248          if(f1DlRrcMsg->protocolIEs.list.array[ieIdx])
12249          {
12250             switch(f1DlRrcMsg->protocolIEs.list.array[ieIdx]->id)
12251             {
12252                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12253                   break;
12254                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12255                   break;
12256                case ProtocolIE_ID_id_SRBID:
12257                   break;
12258                case ProtocolIE_ID_id_RRCContainer:
12259                   {
12260                      rrcContainer =&f1DlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
12261                      free(rrcContainer->buf);
12262                   }
12263                case ProtocolIE_ID_id_ExecuteDuplication:
12264                   break;
12265                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
12266                   break;
12267                   break;
12268             }
12269             free(f1DlRrcMsg->protocolIEs.list.array[ieIdx]);
12270          }
12271       }
12272       free(f1DlRrcMsg->protocolIEs.list.array);
12273    }
12274 }
12275 /******************************************************************
12276  *
12277  * @brief Processes DL RRC Message Transfer  sent by CU
12278  *
12279  * @details
12280  *
12281  *    Function : procF1DlRrcMsgTrans
12282  *
12283  *    Functionality: Processes DL RRC Message Transfer sent by CU
12284  *
12285  * @params[in] F1AP_PDU_t ASN decoded F1AP message
12286  * @return ROK     - success
12287  *         RFAILED - failure
12288  *
12289  * ****************************************************************/
12290 uint8_t procF1DlRrcMsgTrans(F1AP_PDU_t *f1apMsg)
12291 {
12292    uint8_t  idx, ret;
12293    DLRRCMessageTransfer_t *f1DlRrcMsg = NULLP;
12294    F1DlRrcMsg dlMsg;
12295    memset(&dlMsg, 0, sizeof(F1DlRrcMsg));
12296
12297    DU_LOG("\nINFO   -->  DU_APP : DL RRC message transfer Recevied");
12298    f1DlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
12299
12300    ret = ROK;
12301
12302    for(idx=0; idx<f1DlRrcMsg->protocolIEs.list.count; idx++)
12303    {
12304       switch(f1DlRrcMsg->protocolIEs.list.array[idx]->id)
12305       {
12306          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12307             {
12308                dlMsg.gnbCuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
12309                break;
12310             }
12311          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12312             {
12313                dlMsg.gnbDuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
12314                break;
12315             }
12316          case ProtocolIE_ID_id_SRBID:
12317             {
12318                dlMsg.srbId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
12319                break;
12320             }
12321          case ProtocolIE_ID_id_ExecuteDuplication:
12322             dlMsg.execDup = true;
12323             break;
12324
12325          case ProtocolIE_ID_id_RRCContainer:
12326             {
12327                if(f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0)
12328                {
12329                   dlMsg.rrcMsgSize = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
12330                   DU_ALLOC_SHRABL_BUF(dlMsg.rrcMsgPdu, dlMsg.rrcMsgSize);
12331                   if(dlMsg.rrcMsgPdu)
12332                   {
12333                      memcpy(dlMsg.rrcMsgPdu, f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
12334                         dlMsg.rrcMsgSize);
12335                   }
12336                   else
12337                   {
12338                      DU_LOG("\nERROR  -->  DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
12339                      return RFAILED;
12340                   }
12341                }
12342                else
12343                {
12344                   DU_LOG("\nERROR  -->  DU_APP : RRC Container Size is invalid:%ld",\
12345                   f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
12346                   return RFAILED;
12347                }
12348                break;
12349             }
12350          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
12351             {
12352                dlMsg.deliveryStatRpt = true;
12353                break;
12354             }
12355          default:
12356             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
12357                   f1DlRrcMsg->protocolIEs.list.array[idx]->id);
12358       }
12359    }
12360
12361    ret = duProcDlRrcMsg(&dlMsg);
12362
12363    freeAperDecodef1DlRrcMsg(f1DlRrcMsg);
12364    return ret;
12365 }
12366 /*******************************************************************
12367  *
12368 * @brief Builds the DRB to be Setup Mod list
12369 *
12370 * @details
12371 *
12372 *    Function :
12373 *
12374 *    Functionality: Constructs the DRB to be Setup Mod list
12375 *
12376 * @params[in] DRBs_SetupMod_List_t *drbSet
12377 *
12378 * @return ROK     - success
12379 *         RFAILED - failure
12380 *
12381 * ****************************************************************/
12382
12383 uint8_t BuildDrbSetupModList(DRBs_SetupMod_List_t *drbSet , DuUeCfg *ueCfg)
12384 {
12385    uint8_t arrIdx =0;
12386    uint8_t drbCnt =0;
12387    struct DRBs_SetupMod_ItemIEs *drbItemIe;
12388
12389    drbCnt = 1;
12390    drbSet->list.count = drbCnt;
12391    drbSet->list.size = drbCnt * sizeof(DRBs_SetupMod_ItemIEs_t *);
12392    DU_ALLOC(drbSet->list.array, drbSet->list.size);
12393    if(drbSet->list.array == NULLP)
12394    {
12395       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
12396       return  RFAILED;
12397    }
12398    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
12399    {
12400       DU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
12401       if(drbSet->list.array[arrIdx] == NULLP)
12402       {
12403               DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
12404               return  RFAILED;
12405       }
12406
12407       drbItemIe = (struct DRBs_SetupMod_ItemIEs *)drbSet->list.array[arrIdx];
12408       drbItemIe->id = ProtocolIE_ID_id_DRBs_SetupMod_Item;
12409       drbItemIe->criticality = Criticality_reject;
12410       drbItemIe->value.present = DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item;
12411       drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
12412       if(fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List,\
12413       &ueCfg->upTnlInfo[arrIdx])!= ROK)
12414       {
12415          DU_LOG("\nERROR  -->  F1AP : Failed to fill DlTnl SetupList in BuildDrbToBeSetupModList");
12416          return RFAILED;
12417       }
12418
12419    }
12420
12421    return ROK;
12422 }
12423 /*******************************************************************
12424 * @brief Free the memory allocated for DRB setup List
12425 *
12426 * @details
12427 *
12428 *    Function : FreeDrbSetupModList
12429 *
12430 *    Functionality:
12431 *       Free the memory allocated for DRB setup list
12432 *
12433 * @params[in] DRBs_Setup_List_t *
12434 * @return void
12435 *
12436 * ****************************************************************/
12437 void FreeDrbSetupModList(DRBs_SetupMod_List_t *drbSetupList)
12438 {
12439    uint8_t arrIdx = 0;
12440    DRBs_SetupMod_ItemIEs_t *drbItemIe = NULLP;
12441
12442    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
12443    {
12444       drbItemIe = ((DRBs_SetupMod_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
12445       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
12446       DU_FREE(drbSetupList->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
12447    }
12448    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
12449 }
12450 /*******************************************************************
12451 * @brief Free the memory allocated for UE Context Mod Response
12452 *
12453 * @details
12454 *
12455 *    Function : FreeUeContextModResp
12456 *
12457 *    Functionality:
12458 *       Free the memory allocated for UE Context Mod Response
12459 *
12460 * @params[in] F1AP_PDU_t *f1apMsg
12461 * @return void
12462 *
12463 * ****************************************************************/
12464
12465 void FreeUeContextModResp(F1AP_PDU_t *f1apMsg)
12466 {
12467    uint8_t ieIdx;
12468    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
12469    if(f1apMsg)
12470    {
12471       if(f1apMsg->choice.successfulOutcome)
12472       {
12473          ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
12474          if(ueContextModifyRes->protocolIEs.list.array)
12475          {
12476             for(ieIdx=0 ; ieIdx<ueContextModifyRes->protocolIEs.list.count; ieIdx++)
12477             {
12478                if(ueContextModifyRes->protocolIEs.list.array[ieIdx])
12479                {
12480                   switch(ueContextModifyRes->protocolIEs.list.array[ieIdx]->id)
12481                   {
12482                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12483                         break;
12484                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12485                         break;
12486                      case ProtocolIE_ID_id_DRBs_SetupMod_List:
12487                         {
12488                             FreeDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
12489                             value.choice.DRBs_SetupMod_List));
12490                             break;
12491                         }
12492                   }
12493                   DU_FREE(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
12494                }
12495
12496             }
12497             DU_FREE(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
12498          }
12499          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12500       }
12501       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12502    }
12503 }
12504
12505 /*****************************************************************i
12506 *
12507 * @brief Creating the ue context modifcation response and sending
12508 *
12509 * @details
12510 *
12511 *    Function : BuildAndSendUeContextModRsp
12512 *
12513 *    Functionality:
12514 *         - Creating the ue context modifcation response
12515 *
12516 * @params[in] uint8_t cellId,uint8_t ueIdx
12517 * @return ROK     - success
12518 *         RFAILED - failure
12519 *
12520 * ****************************************************************/
12521 uint8_t BuildAndSendUeContextModRsp(uint8_t cellId,uint8_t ueIdx)
12522 {
12523    uint8_t   ieIdx = 0;
12524    uint8_t   cellIdx =0;
12525    uint8_t   elementCnt = 0;
12526    uint8_t   ret = RFAILED;
12527    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
12528    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
12529    F1AP_PDU_t *f1apMsg = NULLP;
12530    asn_enc_rval_t         encRetVal;
12531    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
12532    DuUeCb                   *ueCb = NULLP;
12533
12534    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification response\n");
12535
12536    while(1)
12537    {
12538       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12539       if(f1apMsg == NULLP)
12540       {
12541          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
12542          break;
12543       }
12544
12545       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
12546
12547       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12548       if(f1apMsg->choice.successfulOutcome == NULLP)
12549       {
12550          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
12551          break;
12552       }
12553       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextModification;
12554       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
12555       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_UEContextModificationResponse;
12556
12557       ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
12558
12559       elementCnt = 3;
12560       ueContextModifyRes->protocolIEs.list.count = elementCnt;
12561       ueContextModifyRes->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationResponse_t*);
12562
12563       /* Initialize the UE context modification members */
12564       DU_ALLOC(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
12565       if(ueContextModifyRes->protocolIEs.list.array == NULLP)
12566       {
12567          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
12568          break;
12569       }
12570
12571       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
12572       {
12573          DU_ALLOC(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
12574          if(ueContextModifyRes->protocolIEs.list.array[ieIdx] == NULLP)
12575          {
12576             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
12577             break;
12578          }
12579       }
12580
12581       /* Fetching Ue Cb Info*/
12582       GET_CELL_IDX(cellId, cellIdx);
12583       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
12584       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
12585       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
12586
12587       ieIdx=0;
12588       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
12589       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12590       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
12591       UEContextModificationResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
12592       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
12593
12594       ieIdx++;
12595       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
12596       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12597       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present=\
12598       UEContextModificationResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
12599       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
12600
12601       ieIdx++;
12602       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_SetupMod_List;
12603       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12604       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
12605       UEContextModificationResponseIEs__value_PR_DRBs_SetupMod_List;
12606       if(ueCb->f1UeDb)
12607       {
12608          ret = BuildDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
12609                   value.choice.DRBs_SetupMod_List) , &ueCb->f1UeDb->duUeCfg);
12610          if(ret != ROK)
12611          {
12612             DU_LOG( "\nERROR  -->  F1AP : Failed to build drb setupmod List ");
12613             break;
12614          }
12615          freeF1UeDb(ueCb->f1UeDb);
12616          ueCb->f1UeDb = NULLP;
12617       }
12618       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12619
12620       /* Encode the F1SetupRequest type as APER */
12621       memset(encBuf, 0, ENC_BUF_MAX_LEN);
12622       encBufSize = 0;
12623       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,encBuf);
12624
12625       /* Encode results */
12626       if(encRetVal.encoded == ENCODE_FAIL)
12627       {
12628          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
12629                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12630          ret = RFAILED;
12631          break;
12632       }
12633       else
12634       {
12635          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Modification Response\n");
12636          for(int i=0; i< encBufSize; i++)
12637          {
12638             printf("%x",encBuf[i]);
12639          }
12640       }
12641
12642       /* Sending  msg  */
12643       if(sendF1APMsg() != ROK)
12644       {
12645          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Res Failed");
12646          ret = RFAILED;
12647          break;
12648       }
12649       break;
12650    }
12651    FreeUeContextModResp(f1apMsg);
12652    return ret;
12653 }
12654 /*******************************************************************
12655  *
12656  * @brief Deallocating the memory allocated by the aper decoder
12657  *          for QOSInfo
12658  *
12659  * @details
12660  *
12661  *    Function : freeAperDecodeQosInfo
12662  *
12663  *    Functionality:  Deallocating the memory allocated for QOSInfo
12664  *
12665  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
12666  *
12667  * @return void
12668  *
12669  * ****************************************************************/
12670
12671 void freeAperDecodeQosInfo(QoSFlowLevelQoSParameters_t *drbQos)
12672 {
12673    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
12674    {
12675       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
12676       {
12677          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
12678          {
12679             free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
12680          }
12681          free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
12682       }
12683       free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI);
12684    }
12685 }
12686 /*******************************************************************
12687  *
12688  * @brief Deallocating the memory allocated by the aper decoder
12689  *          for UlTnlInfoforDrb
12690  *
12691  * @details
12692  *
12693  *    Function : freeAperDecodeUlTnlInfoforDrbSetupMod
12694  *
12695  *    Functionality:  Deallocating memory allocated for UlTnlInfoforDrb
12696  *
12697  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
12698  *
12699  * @return void
12700  *
12701  * ****************************************************************/
12702 void freeAperDecodeUlTnlInfoforDrbSetupMod(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
12703 {
12704    uint8_t arrIdx =0;
12705
12706    if(ulInfo->list.array)
12707    {
12708       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
12709       {
12710          if(ulInfo->list.array[arrIdx])
12711          {
12712             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
12713             {
12714                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
12715                {
12716                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
12717                   {
12718                      free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12719                            gTP_TEID.buf);
12720                   }
12721                   free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12722                         transportLayerAddress.buf);
12723                }
12724                free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel);
12725             }
12726             free(ulInfo->list.array[arrIdx]);
12727          }
12728       }
12729       free(ulInfo->list.array);
12730    }
12731 }
12732 /*******************************************************************
12733  *
12734  * @brief Deallocating the memory allocated by the aper decoder
12735  *          for DrbSetupModItem
12736  *
12737  * @details
12738  *
12739  *    Function : freeAperDecodeDrbSetupModItem
12740  *
12741  *    Functionality:  Deallocating memory allocated for DrbSetupModItem
12742  *
12743  * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
12744  *
12745  * @return void
12746  *
12747  * ****************************************************************/
12748
12749 void freeAperDecodeDrbSetupModItem(DRBs_ToBeSetupMod_Item_t *drbItem)
12750 {
12751    uint8_t arrIdx =0;
12752    SNSSAI_t *snssai =NULLP;
12753    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
12754
12755    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
12756    switch(drbItem->qoSInformation.present)
12757    {
12758       case QoSInformation_PR_NOTHING:
12759          break;
12760       case QoSInformation_PR_eUTRANQoS:
12761          {
12762             if(drbItem->qoSInformation.choice.eUTRANQoS)
12763             {
12764                free(drbItem->qoSInformation.choice.eUTRANQoS);
12765             }
12766             break;
12767          }
12768       case QoSInformation_PR_choice_extension:
12769          {
12770             if(drbItem->qoSInformation.choice.choice_extension)
12771             {
12772                freeAperDecodeQosInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.\
12773                      DRB_Information.dRB_QoS);
12774                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
12775                if(snssai->sST.buf)
12776                {
12777                   free(snssai->sST.buf);
12778                }
12779                if(snssai->sD)
12780                {
12781                   if(snssai->sD->buf)
12782                   {
12783                      free(snssai->sD->buf);
12784                   }
12785                   free(snssai->sD);
12786                }
12787
12788                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.\
12789                          DRB_Information.flows_Mapped_To_DRB_List;
12790                if(flowMap->list.array)
12791                {
12792                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
12793                   {
12794                      if(flowMap->list.array[arrIdx] )
12795                      {
12796                         freeAperDecodeQosInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
12797                         free(flowMap->list.array[arrIdx]);
12798                      }
12799                   }
12800                   free(flowMap->list.array);
12801                }
12802
12803                free(drbItem->qoSInformation.choice.choice_extension);
12804             }
12805             break;
12806          }
12807
12808    }
12809    freeAperDecodeUlTnlInfoforDrbSetupMod(&drbItem->uLUPTNLInformation_ToBeSetup_List);
12810    if(drbItem->uLConfiguration)
12811    {
12812       free(drbItem->uLConfiguration);
12813    }
12814 }
12815
12816 /*******************************************************************
12817  *
12818  * @brief Deallocating the memory allocated by the aper decoder
12819  *          for DrbToBeSetupModList
12820  *
12821  * @details
12822  *
12823  *    Function : freeAperDecodeDrbToBeSetupModList
12824  *
12825  *    Functionality:  Deallocating memory allocated for DrbToBeSetupModList
12826  *
12827  * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
12828  *
12829  * @return void
12830  *
12831  * ****************************************************************/
12832
12833 void freeAperDecodeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
12834 {
12835    uint8_t arrIdx =0;
12836    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
12837
12838    if(drbSet->list.array)
12839    {
12840       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
12841       {
12842          if(drbSet->list.array[arrIdx] != NULLP)
12843          {
12844             if(arrIdx == 0)
12845             {
12846                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
12847                freeAperDecodeDrbSetupModItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
12848             }
12849             free(drbSet->list.array[arrIdx]);
12850          }
12851       }
12852       free(drbSet->list.array);
12853    }
12854
12855 }
12856 /*******************************************************************
12857  *
12858  * @brief Deallocating the memory allocated by the aper decoder
12859  *          for UeContextModificationReqMsg
12860  *
12861  * @details
12862  *
12863  *    Function : freeAperDecodeUeContextModificationReqMsg
12864  *
12865  *    Functionality:  Deallocating memory allocated for
12866  *                  UeContextModificationReqMsg
12867  *
12868  * @params[in] UEContextModificationRequest_t *UeContextModifyReq
12869  *
12870  * @return void
12871  *
12872  * ****************************************************************/
12873 void freeAperDecodeUeContextModificationReqMsg(UEContextModificationRequest_t *UeContextModifyReq )
12874 {
12875    uint8_t arrIdx, ieId;
12876
12877    if(UeContextModifyReq->protocolIEs.list.array)
12878    {
12879       for( arrIdx = 0 ; arrIdx<UeContextModifyReq->protocolIEs.list.count ; arrIdx++)
12880       {
12881          if(UeContextModifyReq->protocolIEs.list.array[arrIdx])
12882          {
12883             ieId = UeContextModifyReq->protocolIEs.list.array[arrIdx]->id;
12884             switch(ieId)
12885             {
12886                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12887                   break;
12888                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12889                   break;
12890                case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
12891                   {
12892                      freeAperDecodeDrbToBeSetupModList(&UeContextModifyReq->protocolIEs.list.array[arrIdx]->\
12893                            value.choice.DRBs_ToBeSetupMod_List);
12894                      break;
12895                   }
12896             }
12897             free(UeContextModifyReq->protocolIEs.list.array[arrIdx]);
12898          }
12899       }
12900       free(UeContextModifyReq->protocolIEs.list.array);
12901    }
12902 }
12903 /*******************************************************************
12904  *
12905  * @brief processing the F1 UeContextModificationReq
12906  *
12907  * @details
12908  *
12909  *    Function : procF1UeContextModificationReq
12910  *
12911  *    Functionality:  processing the F1 UeContextModificationReq
12912  *
12913  * @params[in] F1AP_PDU_t *f1apMsg
12914  *
12915  * @return
12916  * ****************************************************************/
12917 uint8_t procF1UeContextModificationReq(F1AP_PDU_t *f1apMsg)
12918 {
12919    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
12920    uint8_t  ret = ROK, ieIdx = 0, cellIdx=0, ueIdx=0;
12921    DuUeCb   *duUeCb = NULLP;
12922    DRBs_ToBeSetupMod_List_t *drbSetupModCfg;
12923    DRBs_ToBeModified_List_t *drbModifiedCfg;
12924    uint32_t gnbCuUeF1apId, gnbDuUeF1apId;
12925
12926    ueContextModifyReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
12927    for(ieIdx=0; (ieIdx < ueContextModifyReq->protocolIEs.list.count && ret == ROK); ieIdx++)
12928    {
12929       switch(ueContextModifyReq->protocolIEs.list.array[ieIdx]->id)
12930       {
12931          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12932             {
12933                gnbCuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
12934                break;
12935             }
12936          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12937             {
12938                gnbDuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
12939                break;
12940             }
12941          case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
12942          case ProtocolIE_ID_id_DRBs_ToBeModified_List:
12943             {
12944                for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
12945                {
12946                   for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
12947                   {
12948                      if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
12949                            (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
12950                      {
12951
12952                         duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
12953                         if(duUeCb->f1UeDb == NULLP)
12954                         {
12955                            DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
12956                         }
12957                         if(duUeCb->f1UeDb)
12958                         {
12959                            duUeCb->f1UeDb->actionType = UE_CTXT_MOD;
12960                            if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present ==\
12961                                  UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List)
12962                            {
12963                               drbSetupModCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
12964                               choice.DRBs_ToBeSetupMod_List;
12965
12966                               if(extractDrbListToSetupMod(NULL, drbSetupModCfg, NULL, drbSetupModCfg->list.count,\
12967                                     &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap))
12968                               {
12969                                  DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbSetupModList");
12970                                  ret = RFAILED;
12971                               }
12972                            }
12973
12974                            if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present == \
12975                                   UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List)
12976
12977                            {
12978                               drbModifiedCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
12979                               choice.DRBs_ToBeModified_List;
12980                               if(extractDrbListToSetupMod(NULL, NULL, drbModifiedCfg, drbSetupModCfg->list.count,\
12981                                  &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap))
12982                               {
12983                                  DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbModifiedList");
12984                                  ret = RFAILED;
12985                               }
12986                            }
12987                         }
12988                         break;
12989                      }
12990                   }
12991                   if(ueIdx >= duCb.actvCellLst[cellIdx]->numActvUes)
12992                   {
12993                      DU_LOG("\nERROR  -->  DU APP : wrong values of gnbCuUeF1apId and gnbDuUeF1apId ");
12994                      ret = RFAILED;
12995                   }
12996                }
12997                break;
12998             }
12999       }
13000    }
13001    if(ret != RFAILED)
13002    {
13003       ret = duProcUeContextModReq(duUeCb);
13004    }
13005    freeAperDecodeUeContextModificationReqMsg(ueContextModifyReq);
13006    return ret;
13007 }
13008 /*****************************************************************i
13009 *
13010 * @brief Free memory allocated for UE Context Release Request
13011 *
13012 * @details
13013 *
13014 *    Function : FreeUeContextReleaseReq
13015 *
13016 *    Functionality:
13017 *         - Free memory allocated for UE Context Release Request
13018 *
13019 * @params[in] F1AP_PDU_t *f1apMsg
13020 * @return void
13021 *
13022 * *************************************************************/
13023 void FreeUeContextReleaseReq(F1AP_PDU_t *f1apMsg)
13024 {
13025    uint8_t ieIdx;
13026    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
13027
13028    if(f1apMsg)
13029    {
13030       if(f1apMsg->choice.initiatingMessage)
13031       {
13032          ueReleaseReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
13033          if(ueReleaseReq->protocolIEs.list.array)
13034          {
13035             for(ieIdx=0 ; ieIdx<ueReleaseReq->protocolIEs.list.count; ieIdx++)
13036             {
13037                DU_FREE(ueReleaseReq->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseRequest_t));
13038             }
13039             DU_FREE(ueReleaseReq->protocolIEs.list.array, ueReleaseReq->protocolIEs.list.size);
13040          }
13041          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
13042       }
13043       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
13044    }
13045
13046 }
13047 /*****************************************************************i
13048 *
13049 * @brief Build and Send UE Context Release Request
13050 *
13051 * @details
13052 *
13053 *    Function : BuildAndSendUeContextReleaseReq
13054 *
13055 *    Functionality:
13056 *         - Build and Send UE Context Release Request
13057 *
13058 * @params[in]
13059 * @return ROK     - success
13060 *         RFAILED - failure
13061 *
13062 * *************************************************************/
13063 uint8_t BuildAndSendUeContextReleaseReq(uint16_t cellId, uint8_t ueIdx)
13064 {
13065    bool memAllocFail = false;
13066    uint8_t ieIdx =0;
13067    uint8_t ret = RFAILED;
13068    uint16_t cellIdx =0;
13069    uint16_t crnti = 0;
13070    uint8_t  elementCnt = 0;
13071    uint32_t  gnbCuUeF1apId =0;   /* gNB-CU UE F1AP Id */
13072    uint32_t  gnbDuUeF1apId =0;   /* gNB-DU UE F1AP Id */
13073    asn_enc_rval_t encRetVal;
13074    F1AP_PDU_t *f1apMsg = NULLP;
13075    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
13076
13077    DU_LOG("\nINFO  --> Building the UE Context Release Request");
13078    do
13079    {
13080       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
13081       if(f1apMsg == NULLP)
13082       {
13083          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for f1apMsg");
13084          break;
13085       }
13086
13087       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
13088       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
13089       if(f1apMsg->choice.initiatingMessage == NULLP)
13090       {
13091          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for\
13092          initiatingMessage");
13093          break;
13094       }
13095       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextReleaseRequest;
13096       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
13097       f1apMsg->choice.initiatingMessage->value.present = \
13098       InitiatingMessage__value_PR_UEContextReleaseRequest;
13099
13100       ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
13101
13102       elementCnt = 2;
13103
13104       ueReleaseReq->protocolIEs.list.count = elementCnt;
13105       ueReleaseReq->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseRequest_t *);
13106
13107       /* Initialize the F1Setup members */
13108       DU_ALLOC(ueReleaseReq->protocolIEs.list.array,ueReleaseReq->protocolIEs.list.size);
13109       if(ueReleaseReq->protocolIEs.list.array == NULLP)
13110       {
13111          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE array");
13112          break;
13113       }
13114       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
13115       {
13116          DU_ALLOC(ueReleaseReq->protocolIEs.list.array[ieIdx],\
13117                sizeof(UEContextReleaseRequest_t));
13118          if(ueReleaseReq->protocolIEs.list.array[ieIdx] == NULLP)
13119          {
13120             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE elements");
13121             memAllocFail = true;
13122             break;
13123          }
13124       }
13125       if(memAllocFail == true)
13126          break;
13127
13128       /* Fetching Ue Cb Info*/
13129       GET_CELL_IDX(cellId, cellIdx);
13130       if(duCb.actvCellLst[cellIdx] == NULLP)
13131       {
13132          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): CellId[%d] does not exist", cellId);
13133          break;
13134       }
13135       else
13136       {
13137          GET_CRNTI(crnti, ueIdx);
13138          if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].crnti != crnti)
13139          {
13140             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): crnti[%d] does not exist", crnti);
13141             break;
13142          }
13143          gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
13144          gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
13145       }
13146
13147       ieIdx=0;
13148       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
13149       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13150       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present = \
13151       UEContextReleaseRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
13152       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
13153
13154       ieIdx++;
13155       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
13156       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13157       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present =\
13158       UEContextReleaseRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
13159       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
13160
13161       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13162
13163       /* Encode the F1SetupRequest type as APER */
13164       memset(encBuf, 0, ENC_BUF_MAX_LEN);
13165       encBufSize = 0;
13166       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
13167       /* Encode results */
13168       if(encRetVal.encoded == ENCODE_FAIL)
13169       {
13170          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseRequest structure (at %s)\n",\
13171                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13172          break;
13173       }
13174       else
13175       {
13176          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseRequest\n");
13177          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
13178          {
13179             printf("%x",encBuf[ieIdx]);
13180          }
13181       }
13182
13183       /* Sending msg */
13184       if(sendF1APMsg() != ROK)
13185       {
13186          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Request failed");
13187          break;
13188       }
13189       ret = ROK;
13190       break;
13191    }while(true);
13192
13193    FreeUeContextReleaseReq(f1apMsg);
13194    return ret;
13195 }
13196 /*****************************************************************i
13197  *
13198  * @brief Free memory allocated for UE Context Release Complete
13199  *
13200  * @details
13201  *
13202  *    Function : FreeUeContextReleaseComplete
13203  *
13204  *    Functionality:
13205  *         - Free memory allocated for UE Context Release Complete
13206  *
13207  * @params[in] F1AP_PDU_t *f1apMsg
13208  * @return void
13209  *
13210  * *************************************************************/
13211 void FreeUeContextReleaseComplete(F1AP_PDU_t *f1apMsg)
13212 {
13213    uint8_t ieIdx;
13214    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
13215
13216    if(f1apMsg)
13217    {
13218       if(f1apMsg->choice.successfulOutcome)
13219       {
13220          ueReleaseComplete =&f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
13221          if(ueReleaseComplete->protocolIEs.list.array)
13222          {
13223             for(ieIdx=0 ; ieIdx<ueReleaseComplete->protocolIEs.list.count; ieIdx++)
13224             {
13225                DU_FREE(ueReleaseComplete->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseComplete_t));
13226             }
13227             DU_FREE(ueReleaseComplete->protocolIEs.list.array, ueReleaseComplete->protocolIEs.list.size);
13228          }
13229          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
13230       }
13231       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
13232    }
13233
13234 }
13235 /*****************************************************************i
13236  *
13237  * @brief Build and Send UE Context Release Complete
13238  *
13239  * @details
13240  *
13241  *    Function : BuildAndSendUeContextReleaseComplete
13242  *
13243  *    Functionality:
13244  *         - Build and Send UE Context Release Complete
13245  *
13246  * @params[in]  cellId,  gnbCuUeF1apId, gnbDuUeF1apId
13247  * @return ROK     - success
13248  *         RFAILED - failure
13249  *
13250  * *************************************************************/
13251 uint8_t BuildAndSendUeContextReleaseComplete(uint16_t cellId, uint32_t gnbCuUeF1apId, uint32_t gnbDuUeF1apId)
13252 {
13253    bool memAllocFail = false;
13254    uint8_t ieIdx =0, ret = RFAILED, elementCnt = 0;
13255    asn_enc_rval_t encRetVal;
13256    F1AP_PDU_t *f1apMsg = NULLP;
13257    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
13258
13259    DU_LOG("\nINFO  --> Building the UE Context Release Complete");
13260    do
13261    {
13262       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
13263       if(f1apMsg == NULLP)
13264       {
13265          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for f1apMsg");
13266          break;
13267       }
13268
13269       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
13270       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
13271       if(f1apMsg->choice.successfulOutcome == NULLP)
13272       {
13273          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for\
13274                successfulOutcome");
13275          break;
13276       }
13277       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextRelease;
13278       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
13279       f1apMsg->choice.successfulOutcome->value.present = \
13280       SuccessfulOutcome__value_PR_UEContextReleaseComplete;
13281
13282       ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
13283
13284       elementCnt = 2;
13285       ueReleaseComplete->protocolIEs.list.count = elementCnt;
13286       ueReleaseComplete->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseComplete_t *);
13287
13288       /* Initialize the UE Release Complete members */
13289       DU_ALLOC(ueReleaseComplete->protocolIEs.list.array,ueReleaseComplete->protocolIEs.list.size);
13290       if(ueReleaseComplete->protocolIEs.list.array == NULLP)
13291       {
13292          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE array");
13293          break;
13294       }
13295       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
13296       {
13297          DU_ALLOC(ueReleaseComplete->protocolIEs.list.array[ieIdx],\
13298                sizeof(UEContextReleaseComplete_t));
13299          if(ueReleaseComplete->protocolIEs.list.array[ieIdx] == NULLP)
13300          {
13301             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE\
13302             elements");
13303             memAllocFail = true;
13304             break;
13305          }
13306       }
13307       if(memAllocFail == true)
13308          break;
13309
13310
13311       ieIdx=0;
13312       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
13313       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13314       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present = \
13315       UEContextReleaseCompleteIEs__value_PR_GNB_CU_UE_F1AP_ID;
13316       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
13317
13318       ieIdx++;
13319       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
13320       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13321       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present =\
13322       UEContextReleaseCompleteIEs__value_PR_GNB_DU_UE_F1AP_ID;
13323       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
13324
13325       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13326
13327       /* Encode the F1SetupComplete type as APER */
13328       memset(encBuf, 0, ENC_BUF_MAX_LEN);
13329       encBufSize = 0;
13330       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
13331       /* Encode results */
13332       if(encRetVal.encoded == ENCODE_FAIL)
13333       {
13334          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseComplete structure (at %s)\n",\
13335                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13336          break;
13337       }
13338       else
13339       {
13340          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseComplete\n");
13341          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
13342          {
13343             printf("%x",encBuf[ieIdx]);
13344          }
13345       }
13346
13347       /* Sending msg */
13348       if(sendF1APMsg() != ROK)
13349       {
13350          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Complete failed");
13351          break;
13352       }
13353       ret = ROK;
13354       break;
13355    }while(true);
13356
13357    if(ret == ROK)
13358    {
13359       duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
13360       ret = duSendCellDeletReq(cellId);
13361       if(ret != ROK)
13362       {
13363          DU_LOG("\nERROR  -->  F1AP: BuildAndSendUeContextReleaseComplete(): Failed to process cell\
13364                Delete req for CellId");
13365       }
13366    }
13367    FreeUeContextReleaseComplete(f1apMsg);
13368    return ret;
13369
13370 }
13371
13372 /*******************************************************************
13373 *
13374 * @brief added free part for the memory allocated by aper_decoder
13375 *
13376 * @details
13377 *
13378 *    Function : freeAperDecodeUeContextReleaseCommand
13379 *
13380 *    Functionality: added free part for the memory allocated by aper_decoder
13381 *
13382 * @params[in] F1AP_PDU_t *f1apMsg
13383 * @return void
13384 *
13385 * ****************************************************************/
13386 void freeAperDecodeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
13387 {
13388    uint8_t ieIdx=0;
13389    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
13390
13391    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
13392
13393    if(ueContextReleaseCommand->protocolIEs.list.array)
13394    {
13395       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
13396       {
13397          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
13398          {
13399             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
13400             {
13401                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13402                   break;
13403                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13404                   break;
13405                case ProtocolIE_ID_id_Cause:
13406                   break;
13407                case ProtocolIE_ID_id_RRCContainer:
13408                {
13409                   if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
13410                   {
13411                      free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
13412                   }
13413                   break;
13414                }
13415                default :
13416                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
13417                        ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
13418                   break;
13419             }
13420          }
13421          free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]);
13422       }
13423       free(ueContextReleaseCommand->protocolIEs.list.array);
13424    }
13425 }
13426 /*******************************************************************
13427 *
13428 * @brief processing of UE Context Release Command
13429 *
13430 * @details
13431 *
13432 *    Function : procF1UeContextReleaseCommand
13433 *
13434 *    Functionality: processing of UE Context Release Command
13435 *
13436 * @params[in] F1AP_PDU_t *f1apMsg
13437 * @return void
13438 *
13439 * ****************************************************************/
13440 uint8_t procF1UeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
13441 {
13442    uint8_t  ieIdx=0, ret=ROK, ueIdx=0;
13443    uint16_t cellIdx =0;
13444    bool ueIdxFound;
13445    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0;
13446    DuUeCb   *duUeCb = NULLP;
13447    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
13448
13449    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
13450
13451    if(ueContextReleaseCommand->protocolIEs.list.array)
13452    {
13453       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
13454       {
13455          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
13456          {
13457             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
13458             {
13459                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13460                   {
13461                      gnbCuUeF1apId= ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13462                                     value.choice.GNB_CU_UE_F1AP_ID;
13463                      break;
13464                   }
13465
13466                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13467                   {
13468                      gnbDuUeF1apId = ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13469                                      value.choice.GNB_DU_UE_F1AP_ID;
13470                      break;
13471                   }
13472
13473                case ProtocolIE_ID_id_Cause:
13474                   {
13475                      break;
13476                   }
13477
13478                case ProtocolIE_ID_id_RRCContainer:
13479                   {
13480                      for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
13481                      {
13482                         for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
13483                         {
13484                            if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
13485                                  (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
13486                            {
13487                               duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
13488                               DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
13489                               if(duUeCb->f1UeDb)
13490                               {
13491                                  memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
13492                                  duUeCb->f1UeDb->actionType = UE_CTXT_RELEASE;
13493                                  duUeCb->f1UeDb->cellIdx = cellIdx;
13494                                  /* Filling Dl RRC Msg Info */
13495                                  DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
13496                                  if(!duUeCb->f1UeDb->dlRrcMsg)
13497                                  {
13498                                     DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
13499                                     Memory allocation failed ");
13500                                     ret = RFAILED;
13501                                  }
13502                                  else
13503                                  {
13504                                     duUeCb->f1UeDb->dlRrcMsgPres = true;
13505                                     memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
13506                                     ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
13507                                           &ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13508                                           value.choice.RRCContainer);
13509                                  }
13510
13511                               }
13512                               else
13513                               {
13514                                  DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
13515                                  Memory allocation failed ");
13516                                  ret = RFAILED;
13517
13518                               }
13519
13520                               ueIdxFound = true;
13521                               break;
13522                            }
13523                         }
13524                         if(ueIdxFound == true)
13525                         {
13526                            break;
13527                         }
13528                      }
13529                      if(!ueIdxFound)
13530                      {
13531                         DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
13532                         ret = RFAILED;
13533                      }
13534
13535
13536                      break;
13537                   }
13538                default :
13539                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
13540                         ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
13541                   break;
13542             }
13543          }
13544       }
13545    }
13546    if(ret != RFAILED)
13547    {
13548       duProcUeContextReleaseCommand(duUeCb);
13549    }
13550    freeAperDecodeUeContextReleaseCommand(f1apMsg);
13551    return ret;
13552 }
13553 /**************************************************************
13554  *
13555  * @brief Handles received F1AP message and sends back response
13556  *
13557  * @details
13558  *
13559  *    Function : F1APMsgHdlr
13560  *
13561  *    Functionality:
13562  *         - Decodes received F1AP control message
13563  *         - Prepares response message, encodes and sends to SCTP
13564  *
13565  * @params[in]
13566  * @return ROK     - success
13567  *         RFAILED - failure
13568  *
13569  * ****************************************************************/
13570 void F1APMsgHdlr(Buffer *mBuf)
13571 {
13572    int i =0;
13573    char *recvBuf =NULLP;
13574    MsgLen copyCnt =0;
13575    MsgLen recvBufLen =0;
13576    F1AP_PDU_t *f1apMsg =NULLP;
13577    asn_dec_rval_t rval; /* Decoder return value */
13578    F1AP_PDU_t f1apasnmsg ;
13579    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
13580    ODU_PRINT_MSG(mBuf, 0,0);
13581
13582    /* Copy mBuf into char array to decode it */
13583    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
13584    DU_ALLOC(recvBuf, (Size)recvBufLen);
13585
13586    if(recvBuf == NULLP)
13587    {
13588       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
13589       return;
13590    }
13591    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
13592    {
13593       DU_LOG("\nERROR   -->  F1AP : Failed while copying %d", copyCnt);
13594       return;
13595    }
13596
13597    printf("\nDEBUG   -->  F1AP : Received flat buffer to be decoded : ");
13598    for(i=0; i< recvBufLen; i++)
13599    {
13600       printf("%x",recvBuf[i]);
13601    }
13602
13603    /* Decoding flat buffer into F1AP messsage */
13604    f1apMsg = &f1apasnmsg;
13605    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
13606
13607    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
13608    DU_FREE(recvBuf, (Size)recvBufLen);
13609
13610    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
13611    {
13612       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
13613       return;
13614    }
13615    printf("\n");
13616    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13617
13618    switch(f1apMsg->present)
13619    {
13620       case F1AP_PDU_PR_successfulOutcome:
13621          {
13622             switch(f1apMsg->choice.successfulOutcome->value.present)
13623             {
13624                case SuccessfulOutcome__value_PR_ResetAcknowledge:
13625                   {
13626                      DU_LOG("\nINFO   -->  F1AP : F1ResetAcknowledge is received successfully ");
13627                      break;
13628                   }
13629                case SuccessfulOutcome__value_PR_F1SetupResponse:
13630                   {
13631 #ifndef ODU_TEST_STUB
13632                      procF1SetupRsp(f1apMsg);
13633 #endif
13634                      break;
13635                   }
13636
13637                case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
13638                   {
13639                      procF1GNBDUCfgUpdAck(f1apMsg);
13640                      break;
13641                   }
13642
13643                default:
13644                   {
13645                      DU_LOG("\nERROR  -->  F1AP : Invalid type of SuccessfulOutcome__value_PR_ResetAcknowledge [%d]",\
13646                            f1apMsg->choice.successfulOutcome->value.present);
13647                      return;
13648                   }
13649             }/* End of switch(successfulOutcome) */
13650             free(f1apMsg->choice.successfulOutcome);
13651             break;
13652          }
13653       case F1AP_PDU_PR_initiatingMessage:
13654          {
13655             switch(f1apMsg->choice.initiatingMessage->value.present)
13656             {
13657                case InitiatingMessage__value_PR_Reset:
13658                   {
13659                      procF1ResetReq(f1apMsg);
13660                      break;
13661                   }
13662                case InitiatingMessage__value_PR_DLRRCMessageTransfer:
13663                   {
13664                      procF1DlRrcMsgTrans(f1apMsg);
13665                      break;
13666                   }
13667                case InitiatingMessage__value_PR_UEContextSetupRequest:
13668                   {
13669                      procF1UeContextSetupReq(f1apMsg);
13670                      break;
13671                   }
13672                case InitiatingMessage__value_PR_UEContextModificationRequest:
13673                   {
13674                      procF1UeContextModificationReq(f1apMsg);
13675                      break;
13676                   }
13677                case InitiatingMessage__value_PR_UEContextReleaseCommand:
13678                   {
13679                       procF1UeContextReleaseCommand(f1apMsg);
13680                       break;
13681                   }
13682                default:
13683                   {
13684                      DU_LOG("\nERROR  -->  F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
13685                            f1apMsg->choice.initiatingMessage->value.present);
13686                      return;
13687                   }
13688             }/* End of switch(initiatingMessage) */
13689             free(f1apMsg->choice.initiatingMessage);
13690             break;
13691          }
13692
13693       default:
13694          {
13695             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
13696             return;
13697          }
13698          free(f1apMsg);
13699
13700    }/* End of switch(f1apMsg->present) */
13701
13702 } /* End of F1APMsgHdlr */
13703
13704 /**********************************************************************
13705   End of file
13706  **********************************************************************/