src/du_app/du_f1ap_msg_hdl.c

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   4 #                                                                              #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
   6 #   you may not use this file except in compliance with the License.           #
   7 #   You may obtain a copy of the License at                                    #
   8 #                                                                              #
   9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10 #                                                                              #
  11 #   Unless required by applicable law or agreed to in writing, software        #
  12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
  14 #   See the License for the specific language governing permissions and        #
  15 #   limitations under the License.                                             #
  16 ################################################################################
  17 *******************************************************************************/
  18
  19 /* This file contains F1AP message handler functions */
  20 #include "common_def.h"
  21 #include "lrg.h"
  22 #include "legtp.h"
  23 #include "lkw.x"
  24 #include "lrg.x"
  25 #include "F1AP-PDU.h"
  26 #include "du_app_mac_inf.h"
  27 #include "du_cfg.h"
  28 #include "du_app_rlc_inf.h"
  29 #include "du_mgr_main.h"
  30 #include "du_utils.h"
  31 #include "RAT-Type.h"
  32 #include "FeatureSetUplinkPerCC.h"
  33 #include "FeatureSetDownlinkPerCC.h"
  34 #include "FeatureSets.h"
  35 #include "UE-NR-Capability.h"
  36 #include "UE-CapabilityRAT-Container.h"
  37 #include "UE-CapabilityRAT-ContainerListRRC.h"
  38 #include "GNB-DU-System-Information.h"
  39 #include "CellGroupConfigRrc.h"
  40 #include "MAC-CellGroupConfig.h"
  41 #include "SchedulingRequestConfig.h"
  42 #include "SchedulingRequestToAddMod.h"
  43 #include "BSR-Config.h"
  44 #include "TAG-Config.h"
  45 #include "TAG.h"
  46 #include "PHR-Config.h"
  47 #include "RLC-Config.h"
  48 #include "UL-AM-RLC.h"
  49 #include "DL-AM-RLC.h"
  50 #include "LogicalChannelConfig.h"
  51 #include "RLC-BearerConfig.h"
  52 #include "PhysicalCellGroupConfig.h"
  53 #include "SpCellConfig.h"
  54 #include "TDD-UL-DL-ConfigDedicated.h"
  55 #include "ServingCellConfig.h"
  56 #include "ControlResourceSet.h"
  57 #include "SearchSpace.h"
  58 #include "PDCCH-Config.h"
  59 #include "PDSCH-TimeDomainResourceAllocation.h"
  60 #include "PDSCH-TimeDomainResourceAllocationList.h"
  61 #include "PDSCH-CodeBlockGroupTransmission.h"
  62 #include "PDSCH-ServingCellConfig.h"
  63 #include "DMRS-DownlinkConfig.h"
  64 #include "PDSCH-Config.h"
  65 #include "BWP-DownlinkDedicated.h"
  66 #include "PUSCH-TimeDomainResourceAllocation.h"
  67 #include "PUSCH-TimeDomainResourceAllocationList.h"
  68 #include "DMRS-UplinkConfig.h"
  69 #include "PUSCH-Config.h"
  70 #include "SRS-ResourceId.h"
  71 #include "SRS-Resource.h"
  72 #include "SRS-ResourceSet.h"
  73 #include "SRS-Config.h"
  74 #include "BWP-UplinkDedicated.h"
  75 #include "PUSCH-ServingCellConfig.h"
  76 #include "UplinkConfig.h"
  77 #include "DUtoCURRCContainer.h"
  78 #include "GBR-QoSFlowInformation.h"
  79 #include "QoSFlowLevelQoSParameters.h"
  80 #include "PUCCH-Config.h"
  81 #include "PUCCH-ResourceSet.h"
  82 #include "PUCCH-Resource.h"
  83 #include "PUCCH-PowerControl.h"
  84 #include "P0-PUCCH.h"
  85 #include "PUCCH-PathlossReferenceRS.h"
  86 #include "PUCCH-format0.h"
  87 #include "PUCCH-format1.h"
  88 #include "PUCCH-format2.h"
  89 #include "PUCCH-format3.h"
  90 #include "PUCCH-format4.h"
  91 #include "PUCCH-FormatConfig.h"
  92 #include "SchedulingRequestResourceConfig.h"
  93 #include<ProtocolIE-Field.h>
  94 #include "ProtocolExtensionField.h"
  95 #include "odu_common_codec.h"
  96 #include "du_mgr.h"
  97 #include "du_cell_mgr.h"
  98 #include "du_f1ap_msg_hdl.h"
  99 #include "DRBs-Setup-Item.h"
 100 #include "DLUPTNLInformation-ToBeSetup-List.h"
 101 #include "DLUPTNLInformation-ToBeSetup-Item.h"
 102 #include "UPTransportLayerInformation.h"
 103 #include "GTPTunnel.h"
 104
 105 #ifdef O1_ENABLE
 106 #include "ConfigInterface.h"
 107 extern StartupConfig g_cfg;
 108 #endif
 109
 110 DuCfgParams duCfgParam;
 111
 112 /************************************************************************
 113  *
 114  * @brief Converts enum values into actual value of Poll retransmit timer
 115  *
 116  * @details
 117  *
 118  *    Function : getPollPdu
 119  *
 120  *    Functionality: Converts enum values into actual value of poll
 121  *    retransmit timer
 122  *
 123  * @params[in] Enum value of pollPdu
 124  * @return Actual value of pollPdu
 125  *
 126  * **********************************************************************/
 127
 128 uint16_t getPollRetxTmr(uint8_t pollRetxTmrCfg)
 129 {
 130    uint16_t pollRetxTmr;
 131
 132    /* All values of poll retx timer are at interval of 5ms.
 133     * This is valid upto 250ms
 134     * Hence converting the enum value to actual value by multiplying it to 5
 135     */
 136    if(pollRetxTmrCfg <= T_PollRetransmit_ms250)
 137       pollRetxTmr = (pollRetxTmrCfg + 1) * 5;
 138    else
 139    {
 140       switch(pollRetxTmrCfg)
 141       {
 142          case T_PollRetransmit_ms300:
 143             pollRetxTmr = 300;
 144             break;
 145          case T_PollRetransmit_ms350:
 146             pollRetxTmr = 350;
 147             break;
 148          case T_PollRetransmit_ms400:
 149             pollRetxTmr = 400;
 150             break;
 151          case T_PollRetransmit_ms450:
 152             pollRetxTmr = 450;
 153             break;
 154          case T_PollRetransmit_ms500:
 155             pollRetxTmr = 500;
 156             break;
 157          case T_PollRetransmit_ms800:
 158             pollRetxTmr = 800;
 159             break;
 160          default:
 161             DU_LOG("\nERROR  -->  F1AP: Invalid value of Poll Retransmit timer");
 162             pollRetxTmr = 0;
 163       }
 164    }
 165    return pollRetxTmr;
 166 }
 167
 168 /*******************************************************************
 169  *
 170  * @brief Converts enum values into actual value of PollPdu
 171  *
 172  * @details
 173  *
 174  *    Function : getPollPdu
 175  *
 176  *    Functionality: Converts enum values into actual value of PollPdu
 177  *
 178  * @params[in] Enum value of pollPdu
 179  * @return Actual value of pollPdu
 180  *
 181  * ****************************************************************/
 182 int32_t getPollPdu(uint8_t pollPduCfg)
 183 {
 184    int32_t pollPdu;
 185    switch(pollPduCfg)
 186    {
 187       case PollPDU_p4:
 188          pollPdu = 4;
 189          break;
 190       case PollPDU_p8:
 191          pollPdu = 8;
 192          break;
 193       case PollPDU_p16:
 194          pollPdu = 16;
 195          break;
 196       case PollPDU_p32:
 197          pollPdu = 32;
 198          break;
 199       case PollPDU_p64:
 200          pollPdu = 64;
 201          break;
 202       case PollPDU_p128:
 203          pollPdu = 128;
 204          break;
 205       case PollPDU_p256:
 206          pollPdu = 256;
 207          break;
 208       case PollPDU_p512:
 209          pollPdu = 512;
 210          break;
 211       case PollPDU_p1024:
 212          pollPdu = 1024;
 213          break;
 214       case PollPDU_p2048:
 215          pollPdu = 2048;
 216          break;
 217       case PollPDU_p4096:
 218          pollPdu = 4096;
 219          break;
 220       case PollPDU_p6144:
 221          pollPdu = 6144;
 222          break;
 223       case PollPDU_p8192:
 224          pollPdu = 8192;
 225          break;
 226       case PollPDU_p12288:
 227          pollPdu = 12288;
 228          break;
 229       case PollPDU_p16384:
 230          pollPdu = 16384;
 231          break;
 232       case PollPDU_p20480:
 233          pollPdu = 20480;
 234          break;
 235       case PollPDU_p24576:
 236          pollPdu = 24576;
 237          break;
 238       case PollPDU_p28672:
 239          pollPdu = 28672;
 240          break;
 241       case PollPDU_p32768:
 242          pollPdu = 32768;
 243          break;
 244       case PollPDU_p40960:
 245          pollPdu = 40960;
 246          break;
 247       case PollPDU_p49152:
 248          pollPdu = 49152;
 249          break;
 250       case PollPDU_p57344:
 251          pollPdu = 57344;
 252          break;
 253       case PollPDU_p65536:
 254          pollPdu = 65536;
 255          break;
 256       case PollPDU_infinity:
 257          pollPdu = -1;
 258          break;
 259       default:
 260          DU_LOG("\nERROR  -->  F1AP: Invalid value of poll pdu");
 261          pollPdu = 0;
 262          break;
 263    }
 264    return pollPdu;
 265 }
 266
 267 /*******************************************************************
 268  *
 269  * @brief Converts enum values into actual value of poll bytes
 270  *
 271  * @details
 272  *
 273  *    Function : getPollByte
 274  *
 275  *    Functionality: Converts enum values into actual value of pollBytes
 276  *
 277  * @params[in] Enum value
 278  * @return Actual value
 279  *
 280  * ****************************************************************/
 281 int32_t getPollByte(uint16_t pollBytesCfg)
 282 {
 283    int32_t pollBytes;
 284    switch(pollBytesCfg)
 285    {
 286       case PollByte_kB1:
 287          pollBytes = 1000;
 288          break;
 289       case PollByte_kB2:
 290          pollBytes = 2000;
 291          break;
 292       case PollByte_kB5:
 293          pollBytes = 5000;
 294          break;
 295       case PollByte_kB8:
 296          pollBytes = 8000;
 297          break;
 298       case PollByte_kB10:
 299          pollBytes = 10000;
 300          break;
 301       case PollByte_kB15:
 302          pollBytes = 15000;
 303          break;
 304       case PollByte_kB25:
 305          pollBytes = 25000;
 306          break;
 307       case PollByte_kB50:
 308          pollBytes = 50000;
 309          break;
 310       case PollByte_kB75:
 311          pollBytes = 75000;
 312          break;
 313       case PollByte_kB100:
 314          pollBytes = 100000;
 315          break;
 316       case PollByte_kB125:
 317          pollBytes = 125000;
 318          break;
 319       case PollByte_kB250:
 320          pollBytes = 250000;
 321          break;
 322       case PollByte_kB375:
 323          pollBytes = 375000;
 324          break;
 325       case PollByte_kB500:
 326          pollBytes = 500000;
 327          break;
 328       case PollByte_kB750:
 329          pollBytes = 750000;
 330          break;
 331       case PollByte_kB1000:
 332          pollBytes = 1000000;
 333          break;
 334       case PollByte_kB1250:
 335          pollBytes = 1250000;
 336          break;
 337       case PollByte_kB1500:
 338          pollBytes = 1500000;
 339          break;
 340       case PollByte_kB2000:
 341          pollBytes = 2000000;
 342          break;
 343       case PollByte_kB3000:
 344          pollBytes = 3000000;
 345          break;
 346       case PollByte_kB4000:
 347          pollBytes = 4000000;
 348          break;
 349       case PollByte_kB4500:
 350          pollBytes = 4500000;
 351          break;
 352       case PollByte_kB5000:
 353          pollBytes = 5000000;
 354          break;
 355       case PollByte_kB5500:
 356          pollBytes = 5500000;
 357          break;
 358       case PollByte_kB6000:
 359          pollBytes = 6000000;
 360          break;
 361       case PollByte_kB6500:
 362          pollBytes = 6500000;
 363          break;
 364       case PollByte_kB7000:
 365          pollBytes = 7000000;
 366          break;
 367       case PollByte_kB7500:
 368          pollBytes = 7500000;
 369          break;
 370       case PollByte_mB8:
 371          pollBytes = 8000000;
 372          break;
 373       case PollByte_mB9:
 374          pollBytes = 9000000;
 375          break;
 376       case PollByte_mB10:
 377          pollBytes = 10000000;
 378          break;
 379       case PollByte_mB11:
 380          pollBytes = 11000000;
 381          break;
 382       case PollByte_mB12:
 383          pollBytes = 12000000;
 384          break;
 385       case PollByte_mB13:
 386          pollBytes = 13000000;
 387          break;
 388       case PollByte_mB14:
 389          pollBytes = 14000000;
 390          break;
 391       case PollByte_mB15:
 392          pollBytes = 15000000;
 393          break;
 394       case PollByte_mB16:
 395          pollBytes = 16000000;
 396          break;
 397       case PollByte_mB17:
 398          pollBytes = 17000000;
 399          break;
 400       case PollByte_mB18:
 401          pollBytes = 18000000;
 402          break;
 403       case PollByte_mB20:
 404          pollBytes = 20000000;
 405          break;
 406       case PollByte_mB25:
 407          pollBytes = 25000000;
 408          break;
 409       case PollByte_mB30:
 410          pollBytes = 30000000;
 411          break;
 412       case PollByte_mB40:
 413          pollBytes = 40000000;
 414          break;
 415       case PollByte_infinity:
 416          pollBytes = -1;
 417          break;
 418       default:
 419          DU_LOG("\nERROR  -->  F1AP: Invalid value of poll bytes");
 420          pollBytes = 0;
 421    }
 422    return pollBytes;
 423 }
 424
 425 /*******************************************************************
 426  *
 427  * @brief Converts enum values into actual value of maxRetx
 428  *
 429  * @details
 430  *
 431  *    Function : getMaxRetx
 432  *
 433  *    Functionality: Converts enum values into actual value of maxRetx
 434  *
 435  * @params[in] Enum value
 436  * @return Actual value
 437  *
 438  * ****************************************************************/
 439 uint8_t getMaxRetx(uint8_t maxRetxCfg)
 440 {
 441    uint8_t maxRetx;
 442    switch(maxRetxCfg)
 443    {
 444       case UL_AM_RLC__maxRetxThreshold_t1:
 445          maxRetx = 1;
 446          break;
 447       case UL_AM_RLC__maxRetxThreshold_t2:
 448          maxRetx = 2;
 449          break;
 450       case UL_AM_RLC__maxRetxThreshold_t3:
 451          maxRetx = 3;
 452          break;
 453       case UL_AM_RLC__maxRetxThreshold_t4:
 454          maxRetx = 4;
 455          break;
 456       case UL_AM_RLC__maxRetxThreshold_t6:
 457          maxRetx = 6;
 458          break;
 459       case UL_AM_RLC__maxRetxThreshold_t8:
 460          maxRetx = 8;
 461          break;
 462       case UL_AM_RLC__maxRetxThreshold_t16:
 463          maxRetx = 16;
 464          break;
 465       case UL_AM_RLC__maxRetxThreshold_t32:
 466          maxRetx = 32;
 467          break;
 468       default:
 469          DU_LOG("\nERROR  -->  F1AP: Invalid configuration for Max retransmission threshold");
 470          maxRetx = 0;
 471    }
 472    return maxRetx;
 473 }
 474
 475 /*******************************************************************
 476  * @brief Converts enum values into actual value of reassembly timer
 477  *
 478  * @details
 479  *
 480  *    Function : getReAsmblTmr
 481  *
 482  *    Functionality: Converts enum values into actual value of reassembly
 483  *    timer
 484  *
 485  * @params[in] Enum value of reassembly timer
 486  * @return Actual value of reassembly timer
 487  *
 488  * **********************************************************************/
 489
 490 int8_t getReAsmblTmr(uint8_t reAsmblTmrCfg)
 491 {
 492    int8_t reAsmblTmr = 0;
 493
 494    if(reAsmblTmrCfg == T_Reassembly_ms0)
 495    {
 496       reAsmblTmr = 0;
 497    }
 498    else if(reAsmblTmrCfg >= T_Reassembly_ms5 || reAsmblTmrCfg <= T_Reassembly_ms100)
 499    {
 500      /* All values of re assembly timer are at interval of 5ms.
 501       * This is valid upto 100ms
 502       * Hence converting the enum value to actual value by multiplying it to 5
 503       */
 504       reAsmblTmr = reAsmblTmrCfg * 5;
 505    }
 506    else if(reAsmblTmrCfg >= T_Reassembly_ms110 || reAsmblTmrCfg <= T_Reassembly_ms200)
 507    {
 508      /* All values of re assembly timer are at interval of 10ms.
 509       * This is valid upto 200ms
 510       * since enum value starts from 20 for 100ms, subtracting 10 and
 511       * converting the enum value to actual value by multiplying it to 10
 512       */
 513       reAsmblTmr = ((reAsmblTmrCfg-10) * 10);
 514    }
 515    else
 516    {
 517       DU_LOG("\nERROR  -->  F1AP : Invalid value of Re Assembly timer %d", reAsmblTmrCfg);
 518       reAsmblTmr = -1;
 519    }
 520    return reAsmblTmr;
 521 }
 522
 523 /************************************************************************
 524  *
 525  * @brief Converts enum values into actual value of status prohibit timer
 526  *
 527  * @details
 528  *
 529  *    Function : getStatProhTmr
 530  *
 531  *    Functionality: Converts enum values into actual value of status prohibit
 532  *    timer
 533  *
 534  * @params[in] Enum value of status prohibit timer
 535  * @return Actual value of status prohibit timer
 536  *
 537  * **********************************************************************/
 538
 539 int16_t getStatProhTmr(uint8_t statProhTmrCfg)
 540 {
 541    int16_t statProhTmr =0;
 542
 543    if(statProhTmrCfg == T_StatusProhibit_ms0)
 544    {
 545       statProhTmr = 0;
 546    }
 547    else if(statProhTmrCfg >= T_StatusProhibit_ms5 || statProhTmrCfg <= T_StatusProhibit_ms250)
 548    {
 549       /* All values of re assembly timer are at interval of 5ms.
 550        * This is valid upto 250ms
 551        * Hence converting the enum value to actual value by multiplying it to 5
 552        */
 553       statProhTmr = statProhTmrCfg * 5;
 554    }
 555    else
 556    {
 557       switch(statProhTmrCfg)
 558       {
 559          case T_StatusProhibit_ms300:
 560             statProhTmr = 300;
 561             break;
 562          case T_StatusProhibit_ms350:
 563             statProhTmr = 350;
 564             break;
 565          case T_StatusProhibit_ms400:
 566             statProhTmr = 400;
 567             break;
 568          case T_StatusProhibit_ms450:
 569             statProhTmr = 450;
 570             break;
 571          case T_StatusProhibit_ms500:
 572             statProhTmr = 500;
 573             break;
 574          case T_StatusProhibit_ms800:
 575             statProhTmr = 800;
 576             break;
 577          case T_StatusProhibit_ms1000:
 578             statProhTmr = 1000;
 579             break;
 580          case T_StatusProhibit_ms1200:
 581             statProhTmr = 1200;
 582             break;
 583          case T_StatusProhibit_ms1600:
 584             statProhTmr = 1600;
 585             break;
 586          case T_StatusProhibit_ms2000:
 587             statProhTmr = 2000;
 588             break;
 589          case T_StatusProhibit_ms2400:
 590             statProhTmr = 2400;
 591             break;
 592          default:
 593             DU_LOG("\nInvalid value of Status Prohibit timer %d", statProhTmrCfg);
 594             statProhTmr = -1;
 595             break;
 596       }
 597    }
 598    return statProhTmr;
 599 }
 600
 601 /*******************************************************************
 602 *
 603 * @brief Adding F1AP pdu to reserved pdu list
 604 *
 605 * @details
 606 *
 607 *    Function : addToReservedF1apPduList
 608 *
 609 *    Functionality: Adding F1AP pdu to reserved pdu list.
 610 *     These pdu are awaiting aknowledgment from CU
 611 *
 612 * @params[in] uint8_t transId, F1AP_PDU_t *f1apMsg
 613 *
 614 * @return ROK - success
 615 *         RFAILED - failure
 616 *
 617 * ****************************************************************/
 618
 619 void addToReservedF1apPduList(uint8_t transId, F1AP_PDU_t *f1apPdu)
 620 {
 621    CmLList         *node = NULLP;
 622    ReservedF1apPduInfo *pduInfo = NULLP;
 623    DU_ALLOC(pduInfo, sizeof(ReservedF1apPduInfo));
 624    if(pduInfo)
 625    {
 626       DU_ALLOC(node, sizeof(CmLList));
 627       if(node)
 628       {
 629          pduInfo->transId = transId;
 630          pduInfo->f1apMsg = (void*) f1apPdu;
 631
 632          node->node = (PTR)pduInfo;
 633          cmLListAdd2Tail(&duCb.reservedF1apPduList, node);
 634       }
 635    }
 636 }
 637
 638 /*******************************************************************
 639 *
 640 * @brief searching for F1AP pdu from ReservedF1apPduList
 641 *
 642 * @details
 643 *
 644 *    Function : searchFromReservedF1apPduList
 645 *
 646 *    Functionality: searching for F1AP pdu information
 647 *
 648 * @params[in] uint8_t transId
 649 *
 650 * @return pointer to F1AP_PDU_t
 651 *
 652 * ****************************************************************/
 653
 654 CmLList *searchFromReservedF1apPduList(uint8_t transId)
 655 {
 656    CmLList         *node;
 657    ReservedF1apPduInfo *f1apPdu;
 658    if(duCb.reservedF1apPduList.count)
 659    {
 660       CM_LLIST_FIRST_NODE(&duCb.reservedF1apPduList, node);
 661       while(node)
 662       {
 663          f1apPdu = (ReservedF1apPduInfo*)node->node;
 664          if(f1apPdu->transId == transId)
 665          {
 666             return node;
 667          }
 668          node = node->next;
 669       }
 670    }
 671    return NULL;
 672 }
 673
 674 /*******************************************************************
 675 *
 676 * @brief deleting F1AP pdu information from ReservedF1apPduList
 677 *
 678 * @details
 679 *
 680 *    Function : deleteFromReservedF1apPduList
 681 *
 682 *    Functionality: deleting pdu information from ReservedF1apPduList
 683 *
 684 * @params[in] CmLList *node
 685 *
 686 * @return void
 687 *
 688 * ****************************************************************/
 689
 690 void deleteFromReservedF1apPduList(CmLList *node)
 691 {
 692    ReservedF1apPduInfo *f1apPdu;
 693
 694    if(node != NULL)
 695    {
 696       f1apPdu = (ReservedF1apPduInfo *)node->node;
 697       cmLListDelFrm(&duCb.reservedF1apPduList, node);
 698       DU_FREE(f1apPdu, sizeof(ReservedF1apPduInfo));
 699       DU_FREE(node, sizeof(CmLList));
 700       node = NULL;
 701    }
 702 }
 703
 704 /*******************************************************************
 705  *
 706  * @brief Builds Uplink Info for NR
 707  *
 708  * @details
 709  *
 710  *    Function : BuildULNRInfo
 711  *
 712  *    Functionality: Building NR Uplink Info
 713  *
 714  * @params[in] NRFreqInfo_t *ulnrfreq
 715  * @return ROK     - success
 716  *         RFAILED - failure
 717  *
 718  * ****************************************************************/
 719 uint8_t BuildULNRInfo(NRFreqInfo_t *ulnrfreq)
 720 {
 721    uint8_t idx=0;
 722    ulnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 723                        fdd.ulNrFreqInfo.nrArfcn;
 724    ulnrfreq->freqBandListNr.list.count = 1;
 725    ulnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 726    DU_ALLOC(ulnrfreq->freqBandListNr.list.array,ulnrfreq->freqBandListNr.list.size);
 727    if(ulnrfreq->freqBandListNr.list.array == NULLP)
 728    {
 729       return RFAILED;
 730    }
 731    for(idx=0;idx<ulnrfreq->freqBandListNr.list.count;idx++)
 732    {
 733       DU_ALLOC(ulnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 734       if(ulnrfreq->freqBandListNr.list.array[idx] == NULLP)
 735       {
 736          return RFAILED;
 737       }
 738    }
 739    ulnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 740                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
 741                                                                  freqBand[0].nrFreqBand;
 742    ulnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 743    return ROK;
 744 }
 745 /*******************************************************************
 746  *
 747  * @brief Builds Downlink NR Info
 748  *
 749  * @details
 750  *
 751  *    Function : BuildDLNRInfo
 752  *
 753  *    Functionality: Building Downlink NR Info
 754  *
 755  * @params[in] NRFreqInfo_t *dlnrfreq
 756  * @return ROK     - success
 757  *         RFAILED - failure
 758  *
 759  * ****************************************************************/
 760 uint8_t BuildDLNRInfo(NRFreqInfo_t *dlnrfreq)
 761 {
 762    uint8_t idx=0;
 763    dlnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 764                        fdd.dlNrFreqInfo.nrArfcn;
 765    dlnrfreq->freqBandListNr.list.count = 1;
 766    dlnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 767    DU_ALLOC(dlnrfreq->freqBandListNr.list.array,dlnrfreq->freqBandListNr.list.size);
 768    if(dlnrfreq->freqBandListNr.list.array == NULLP)
 769    {
 770       return RFAILED;
 771    }
 772    for(idx=0;idx< dlnrfreq->freqBandListNr.list.count;idx++)
 773    {
 774       DU_ALLOC(dlnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 775       if(dlnrfreq->freqBandListNr.list.array[idx] == NULLP)
 776       {
 777          return RFAILED;
 778       }
 779    }
 780    dlnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 781                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
 782                                                                  freqBand[0].nrFreqBand;
 783    dlnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 784
 785    return ROK;
 786 }
 787
 788 /*******************************************************************
 789  *
 790  * @brief Builds NRCell ID
 791  *
 792  * @details
 793  *
 794  *    Function : BuildNrCellId
 795  *
 796  *    Functionality: Building the NR Cell ID
 797  *
 798  * @params[in] BIT_STRING_t *nrcell
 799  * @return ROK     - success
 800  *         RFAILED - failure
 801  *
 802  * ****************************************************************/
 803
 804 S16 BuildNrCellId(BIT_STRING_t *nrcell)
 805 {
 806    memset(nrcell->buf, 0, nrcell->size);
 807    nrcell->buf[4]   = 16;
 808    nrcell->bits_unused = 4;
 809    return ROK;
 810 }
 811
 812 /*******************************************************************
 813  *
 814  * @brief Builds Nrcgi
 815  *
 816  * @details
 817  *
 818  *    Function : BuildNrcgi
 819  *
 820  *    Functionality: Building the PLMN ID and NR Cell id
 821  *
 822  * @params[in] NRCGI_t *nrcgi
 823  * @return ROK     - success
 824  *         RFAILED - failure
 825  *
 826  * ****************************************************************/
 827 uint8_t BuildNrcgi(NRCGI_t *nrcgi)
 828 {
 829    uint8_t ret;
 830    uint8_t byteSize = 5;
 831    /* Allocate Buffer Memory */
 832    nrcgi->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 833    DU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
 834    if(nrcgi->pLMN_Identity.buf == NULLP)
 835    {
 836       return RFAILED;
 837    }
 838    ret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 839          nrcgi->pLMN_Identity.buf); // Building PLMN function
 840    if(ret != ROK)
 841    {
 842       return RFAILED;
 843    }
 844    /*nrCellIdentity*/
 845    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
 846    DU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
 847    if(nrcgi->nRCellIdentity.buf == NULLP)
 848    {
 849       return RFAILED;
 850    }
 851    BuildNrCellId(&nrcgi->nRCellIdentity);
 852
 853    return ROK;
 854 }
 855 /*******************************************************************
 856  *
 857  * @brief Builds FiveGStac
 858  *
 859  * @details
 860  *
 861  *    Function : BuildFiveGSTac
 862  *
 863  *    Functionality: Building the FiveGSTac
 864  *
 865  * @params[in] OCTET_STRING_t *fivegsTac
 866  * @return ROK     - success
 867  *         RFAILED - failure
 868  *
 869  * ****************************************************************/
 870 uint8_t BuildFiveGSTac(Served_Cell_Information_t *servcell)
 871 {
 872    DU_ALLOC(servcell->fiveGS_TAC,sizeof(FiveGS_TAC_t));
 873    if(servcell->fiveGS_TAC == NULLP)
 874    {
 875       return RFAILED;
 876    }
 877    servcell->fiveGS_TAC->size = 3 * sizeof(uint8_t);
 878    DU_ALLOC(servcell->fiveGS_TAC->buf,\
 879          sizeof(servcell->fiveGS_TAC->size));
 880    if(servcell->fiveGS_TAC->buf == NULLP)
 881    {
 882       return RFAILED;
 883    }
 884    servcell->fiveGS_TAC->buf[0] = 0;
 885    servcell->fiveGS_TAC->buf[1] = 0;
 886    servcell->fiveGS_TAC->buf[2] = duCfgParam.srvdCellLst[0].duCellInfo.tac;
 887    return ROK;
 888 }
 889 /*******************************************************************
 890  *
 891  * @brief Builds NR Mode
 892  *
 893  * @details
 894  *
 895  *    Function : BuildNrMode
 896  *
 897  *    Functionality: Building the NR Mode
 898  *
 899  * @params[in] NR_Mode_Info_t *fdd
 900  * @return ROK     - success
 901  *         RFAILED - failure
 902  *
 903  * ****************************************************************/
 904 uint8_t BuildNrMode(NR_Mode_Info_t *mode)
 905 {
 906    uint8_t BuildDLNRInforet=0;
 907    uint8_t BuildULNRInforet=0;
 908    /* FDD Mode */
 909    mode->present = NR_Mode_Info_PR_fDD;
 910    if(mode->present == NR_Mode_Info_PR_fDD)
 911    {
 912       DU_ALLOC(mode->choice.fDD,sizeof(FDD_Info_t));
 913       if(mode->choice.fDD == NULLP)
 914       {
 915          return RFAILED;
 916       }
 917       BuildULNRInforet = BuildULNRInfo(&mode->choice.fDD->uL_NRFreqInfo);
 918       if(BuildULNRInforet != ROK)
 919       {
 920          return RFAILED;
 921       }
 922       BuildDLNRInforet = BuildDLNRInfo(&mode->choice.fDD->dL_NRFreqInfo);
 923       if(BuildDLNRInforet != ROK)
 924       {
 925          return RFAILED;
 926       }
 927    }
 928    mode->choice.fDD->uL_Transmission_Bandwidth.nRSCS = \
 929                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 930                                                        f1Mode.mode.fdd.ulTxBw.nrScs;
 931    mode->choice.fDD->uL_Transmission_Bandwidth.nRNRB = \
 932                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 933                                                        f1Mode.mode.fdd.ulTxBw.nrb;
 934    mode->choice.fDD->dL_Transmission_Bandwidth.nRSCS = \
 935                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 936                                                        f1Mode.mode.fdd.dlTxBw.nrScs;
 937    mode->choice.fDD->dL_Transmission_Bandwidth.nRNRB = \
 938                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 939                                                        f1Mode.mode.fdd.dlTxBw.nrb;
 940    return ROK;
 941 }
 942 /*******************************************************************
 943  *
 944  * @brief Builds IE Extensions for Served PLMNs
 945  *
 946  * @details
 947  *
 948  *    Function : BuildExtensions
 949  *
 950  *    Functionality: Building the IE Extensions
 951  *
 952  * @params[in] struct ProtocolExtensionContainer_4624P3 *buildextend
 953  * @return ROK     - success
 954  *         RFAILED - failure
 955  *
 956  * ****************************************************************/
 957 uint8_t BuildExtensions(ProtocolExtensionContainer_4624P3_t **ieExtend)
 958 {
 959    uint8_t idx=0, plmnidx=0, sliceLstIdx=0;
 960    uint8_t elementCnt=0, extensionCnt=0;
 961
 962    extensionCnt=IE_EXTENSION_LIST_COUNT;
 963    DU_ALLOC(*ieExtend,sizeof(ProtocolExtensionContainer_4624P3_t));
 964    if((*ieExtend) == NULLP)
 965    {
 966       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 967       return RFAILED;
 968    }
 969    (*ieExtend)->list.count = extensionCnt;
 970    (*ieExtend)->list.size = \
 971                             extensionCnt * sizeof(ServedPLMNs_ItemExtIEs_t *);
 972    DU_ALLOC((*ieExtend)->list.array,(*ieExtend)->list.size);
 973    if((*ieExtend)->list.array == NULLP)
 974    {
 975       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 976       return RFAILED;
 977    }
 978    for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
 979    {
 980       DU_ALLOC((*ieExtend)->list.array[plmnidx],\
 981             sizeof(ServedPLMNs_ItemExtIEs_t));
 982       if((*ieExtend)->list.array[plmnidx] == NULLP)
 983       {
 984          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 985          return RFAILED;
 986       }
 987    }
 988
 989    elementCnt = NUM_OF_SUPPORTED_SLICE;
 990    idx = 0;
 991    (*ieExtend)->list.array[idx]->id = ProtocolIE_ID_id_TAISliceSupportList;
 992    (*ieExtend)->list.array[idx]->criticality = Criticality_ignore;
 993    (*ieExtend)->list.array[idx]->extensionValue.present = \
 994    ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
 995    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 996       list.count = elementCnt;
 997    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 998       list.size = (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 999       list.count * sizeof(SliceSupportItem_t *);
1000
1001    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1002          list.array, elementCnt * sizeof(SliceSupportItem_t *));
1003    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1004          list.array == NULLP)
1005    {
1006       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1007       return RFAILED;
1008    }
1009
1010    for(sliceLstIdx =0; sliceLstIdx<elementCnt; sliceLstIdx++)
1011    {
1012       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1013             list.array[sliceLstIdx],sizeof(SliceSupportItem_t));
1014       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1015             list.array[sliceLstIdx] == NULLP)
1016       {
1017          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1018          return RFAILED;
1019       }
1020       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1021          list.array[sliceLstIdx]->sNSSAI.sST.size = sizeof(uint8_t);
1022       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
1023             .list.array[sliceLstIdx]->sNSSAI.sST.buf,(*ieExtend)->list.array[idx]->\
1024             extensionValue.choice.SliceSupportList.\
1025             list.array[sliceLstIdx]->sNSSAI.sST.size);
1026       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
1027             .list.array[sliceLstIdx]->sNSSAI.sST.buf == NULLP)
1028       {
1029          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1030          return RFAILED;
1031       }
1032       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1033          list.array[sliceLstIdx]->sNSSAI.sST.buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.\
1034          cellInfo.srvdPlmn[0].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
1035
1036       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1037             list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1038       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1039             list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
1040       {
1041          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1042          return RFAILED;
1043       }
1044       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1045          list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
1046       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1047             list.array[sliceLstIdx]->sNSSAI.sD->buf, (*ieExtend)->list.array[idx]->extensionValue.choice.\
1048             SliceSupportList.list.array[sliceLstIdx]->sNSSAI.sD->size);
1049       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1050             list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
1051       {
1052          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1053          return RFAILED;
1054       }
1055       memcpy((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1056       list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[0].duCellInfo.\
1057       cellInfo.srvdPlmn[0].taiSliceSuppLst.snssai[sliceLstIdx]->sd, (*ieExtend)->list.array[idx]->\
1058       extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->sNSSAI.sD->size);
1059    }
1060    return ROK;
1061 }
1062 /*******************************************************************
1063  *
1064  * @brief Builds Served PLMN
1065  *
1066  * @details
1067  *
1068  *    Function : BuildServedPlmn
1069  *
1070  *    Functionality: Building the Served PLMN
1071  *
1072  * @params[in] GNB_DU_Served_Cells_Item_t *srvCellItem
1073  * @return ROK     - success
1074  *         RFAILED - failure
1075  *
1076  * ****************************************************************/
1077 uint8_t  BuildServedPlmn(ServedPLMNs_List_t *srvplmn)
1078 {
1079    uint8_t  plmnidx;
1080    uint8_t  servPlmnCnt=1;
1081    uint8_t buildPlmnIdret=0;
1082    uint8_t BuildExtensionsret=0;
1083    srvplmn->list.count = servPlmnCnt;
1084    srvplmn->list.size = \
1085                         servPlmnCnt*sizeof(ServedPLMNs_Item_t *);
1086    DU_ALLOC(srvplmn->list.array,srvplmn->list.size);
1087    if(srvplmn->list.array == NULLP)
1088    {
1089       return RFAILED;
1090    }
1091    for(plmnidx=0; plmnidx<servPlmnCnt; plmnidx++)
1092    {
1093       DU_ALLOC(srvplmn->list.array[plmnidx],\
1094             sizeof(ServedPLMNs_Item_t));
1095       if(srvplmn->list.array[plmnidx] == NULLP)
1096       {
1097          return RFAILED;
1098       }
1099    }
1100    srvplmn->list.array[0]->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
1101    DU_ALLOC(srvplmn->list.array[0]->pLMN_Identity.buf, srvplmn->list.array[0]->pLMN_Identity.size);
1102    buildPlmnIdret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
1103          srvplmn->list.array[0]->pLMN_Identity.buf);
1104    if(buildPlmnIdret!= ROK)
1105    {
1106       return RFAILED;
1107    }
1108    BuildExtensionsret = BuildExtensions(&srvplmn->list.array[0]->iE_Extensions);
1109    if(BuildExtensionsret!= ROK)
1110    {
1111       return RFAILED;
1112    }
1113    return ROK;
1114 }
1115 /*******************************************************************
1116  *
1117  * @brief Builds Served Cell List
1118  *
1119  * @details
1120  *
1121  *    Function : BuildServedCellList
1122  *
1123  *    Functionality: Building Served Cell List
1124  *
1125  * @params[in] PLMNID plmn
1126  * @return ROK     - success
1127  *         RFAILED - failure
1128  *
1129  * ****************************************************************/
1130
1131 uint8_t BuildServedCellList(GNB_DU_Served_Cells_List_t *duServedCell)
1132 {
1133    uint8_t  BuildNrcgiret=0;
1134    uint8_t  BuildFiveGSTacret=0;
1135    uint8_t  BuildServedPlmnret=0;
1136    uint8_t  BuildNrModeret=0;
1137    uint8_t  idx;
1138    uint8_t  plmnidx;
1139    uint8_t  plmnCnt=1;
1140    GNB_DU_Served_Cells_Item_t *srvCellItem;
1141    duServedCell->list.size = plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t *);
1142    duServedCell->list.count = plmnCnt;
1143
1144    DU_ALLOC(duServedCell->list.array, duServedCell->list.size);
1145    if(duServedCell->list.array == NULLP)
1146    {
1147       return RFAILED;
1148    }
1149    for(plmnidx=0; plmnidx<plmnCnt; plmnidx++)
1150    {
1151       DU_ALLOC(duServedCell->list.array[plmnidx],\
1152             sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1153       if(duServedCell->list.array[plmnidx] == NULLP)
1154       {
1155          return RFAILED;
1156       }
1157    }
1158    idx = 0;
1159    duServedCell->list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_Served_Cells_Item;
1160    duServedCell->list.array[idx]->criticality = Criticality_reject;
1161    duServedCell->list.array[idx]->value.present = \
1162                                                   GNB_DU_Served_Cells_ItemIEs__value_PR_GNB_DU_Served_Cells_Item;
1163    srvCellItem = \
1164                  &duServedCell->list.array[idx]->value.choice.GNB_DU_Served_Cells_Item;
1165    /*nRCGI*/
1166    BuildNrcgiret = BuildNrcgi(&srvCellItem->served_Cell_Information.nRCGI);
1167    if(BuildNrcgiret != ROK)
1168    {
1169       return RFAILED;
1170    }
1171    /*nRPCI*/
1172    srvCellItem->served_Cell_Information.nRPCI = \
1173                                                 duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
1174
1175    /*fiveGS_TAC*/
1176    BuildFiveGSTacret = BuildFiveGSTac(&srvCellItem->served_Cell_Information);
1177    if(BuildFiveGSTacret != ROK)
1178    {
1179       return RFAILED;
1180    }
1181    /*Served PLMNs*/
1182    BuildServedPlmnret = BuildServedPlmn(&srvCellItem->served_Cell_Information.servedPLMNs);
1183    if(BuildServedPlmnret !=ROK)
1184    {
1185       return RFAILED;
1186    }
1187    /*nR Mode Info with FDD*/
1188    BuildNrModeret = BuildNrMode(&srvCellItem->served_Cell_Information.nR_Mode_Info);
1189    if(BuildNrModeret != ROK)
1190    {
1191       return RFAILED;
1192    }
1193    /*Measurement timing Config*/
1194    srvCellItem->served_Cell_Information.measurementTimingConfiguration.\
1195       size = sizeof(uint8_t);
1196    DU_ALLOC(srvCellItem->served_Cell_Information.\
1197          measurementTimingConfiguration.buf,srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1198    if(srvCellItem->served_Cell_Information.\
1199          measurementTimingConfiguration.buf == NULLP)
1200    {
1201       return RFAILED;
1202    }
1203    srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf[0] = \
1204                                                                                 duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
1205
1206    /* GNB DU System Information */
1207    DU_ALLOC(srvCellItem->gNB_DU_System_Information,
1208          sizeof(GNB_DU_System_Information_t));
1209    if(!srvCellItem->gNB_DU_System_Information)
1210    {
1211       return RFAILED;
1212    }
1213    /* MIB */
1214    srvCellItem->gNB_DU_System_Information->mIB_message.size = duCfgParam.srvdCellLst[0].duSysInfo.mibLen;
1215    DU_ALLOC(srvCellItem->gNB_DU_System_Information->mIB_message.buf,
1216          srvCellItem->gNB_DU_System_Information->mIB_message.size);
1217    if(!srvCellItem->gNB_DU_System_Information->mIB_message.buf)
1218    {
1219       return RFAILED;
1220    }
1221    memcpy(srvCellItem->gNB_DU_System_Information->mIB_message.buf, duCfgParam.srvdCellLst[0].duSysInfo.mibMsg, \
1222                    srvCellItem->gNB_DU_System_Information->mIB_message.size);
1223
1224    /* SIB1 */
1225    srvCellItem->gNB_DU_System_Information->sIB1_message.size =\
1226                                                               duCfgParam.srvdCellLst[0].duSysInfo.sib1Len;
1227
1228    DU_ALLOC(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,
1229          srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1230    if(!srvCellItem->gNB_DU_System_Information->sIB1_message.buf)
1231    {
1232       return RFAILED;
1233    }
1234    for(int x=0; x<srvCellItem->gNB_DU_System_Information->sIB1_message.size; x++)
1235    {
1236       srvCellItem->gNB_DU_System_Information->sIB1_message.buf[x]=\
1237                                                                   duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg[x];
1238    }
1239    return ROK;
1240 }
1241 /*******************************************************************
1242  *
1243  * @brief Builds RRC Version
1244  *
1245  * @details
1246  *
1247  *    Function : BuildRrcVer
1248  *
1249  *    Functionality: Building RRC Version
1250  *
1251  * @params[in] int idx,int elementCnt,RRC_Version_t *rrcver
1252  * @return ROK     - success
1253  *         RFAILED - failure
1254  *
1255  * ****************************************************************/
1256 uint8_t BuildRrcVer(RRC_Version_t *rrcVer)
1257 {
1258    uint8_t rrcExt;
1259    uint8_t rrcLatest;
1260    rrcVer->latest_RRC_Version.size = sizeof(uint8_t);
1261    DU_ALLOC(rrcVer->latest_RRC_Version.buf,sizeof(uint8_t));
1262    if(rrcVer->latest_RRC_Version.buf == NULLP)
1263    {
1264       return RFAILED;
1265    }
1266    rrcVer->latest_RRC_Version.buf[0] = 0;
1267    rrcVer->latest_RRC_Version.bits_unused = 5;
1268    DU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1269    if(rrcVer->iE_Extensions == NULLP)
1270    {
1271       return RFAILED;
1272    }
1273    rrcVer->iE_Extensions->list.count = 1;
1274    rrcVer->iE_Extensions->list.size = sizeof(RRC_Version_ExtIEs_t *);
1275    DU_ALLOC(rrcVer->iE_Extensions->list.array,rrcVer->iE_Extensions->list.size);
1276    if(rrcVer->iE_Extensions->list.array == NULLP)
1277    {
1278       return RFAILED;
1279    }
1280    rrcExt = 0;
1281    DU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
1282          sizeof(RRC_Version_ExtIEs_t));
1283    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
1284    {
1285       return RFAILED;
1286    }
1287    rrcVer->iE_Extensions->list.array[rrcExt]->id = \
1288                                                    ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
1289    rrcVer->iE_Extensions->list.array[rrcExt]->criticality = Criticality_reject;
1290    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.present =\
1291                                                                       RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
1292    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1293       .Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
1294    DU_ALLOC(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1295          .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1296          array[rrcExt]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1297    if(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1298          .Latest_RRC_Version_Enhanced.buf == NULLP)
1299    {
1300       return RFAILED;
1301    }
1302    rrcLatest = 0;
1303    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1304       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 15;
1305    rrcLatest++;
1306    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1307       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 5;
1308    rrcLatest++;
1309    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1310       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 0;
1311    return ROK;
1312 }
1313 /*******************************************************************
1314  *
1315  * @brief Sends F1 msg over SCTP
1316  *
1317  * @details
1318  *
1319  *    Function : sendF1APMsg
1320  *
1321  *    Functionality: Sends F1 msg over SCTP
1322  *
1323  * @params[in] Region region
1324  *             Pool pool
1325  * @return ROK     - success
1326  *         RFAILED - failure
1327  *
1328  * ****************************************************************/
1329 uint8_t sendF1APMsg()
1330 {
1331    Buffer *mBuf = NULLP;
1332
1333    if(ODU_GET_MSG_BUF(DU_APP_MEM_REGION, DU_POOL, &mBuf) == ROK)
1334    {
1335       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
1336       {
1337             ODU_PRINT_MSG(mBuf, 0,0);
1338
1339             if(sctpSend(mBuf, F1_INTERFACE) != ROK)
1340             {
1341                DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
1342                ODU_PUT_MSG_BUF(mBuf);
1343                return RFAILED;
1344             }
1345       }
1346       else
1347       {
1348          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
1349          ODU_PUT_MSG_BUF(mBuf);
1350          return RFAILED;
1351       }
1352       ODU_PUT_MSG_BUF(mBuf);
1353    }
1354    else
1355    {
1356       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
1357       return RFAILED;
1358    }
1359    return ROK;
1360 } /* sendF1APMsg */
1361
1362 /*******************************************************************
1363  *
1364  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1365  *
1366  * @details
1367  *
1368  *    Function :  FreeRrcVer
1369  *
1370  *    Functionality: deallocating the memory of function BuildRrcVer
1371  *
1372  * @params[in] RRC_Version_t *rrcVer
1373  *
1374  * @return void
1375  *
1376  *****************************************************************/
1377 void FreeRrcVer(RRC_Version_t *rrcVer)
1378 {
1379    if(rrcVer->latest_RRC_Version.buf != NULLP)
1380    {
1381       if(rrcVer->iE_Extensions != NULLP)
1382       {
1383          if(rrcVer->iE_Extensions->list.array != NULLP)
1384          {
1385             if(rrcVer->iE_Extensions->list.array[0] != NULLP)
1386             {
1387                if(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf
1388                      != NULLP)
1389                {
1390                   DU_FREE(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice\
1391                         .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1392                         array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1393                }
1394                DU_FREE(rrcVer->iE_Extensions->list.array[0],sizeof(RRC_Version_ExtIEs_t));
1395             }
1396             DU_FREE(rrcVer->iE_Extensions->list.array,sizeof(RRC_Version_ExtIEs_t*));
1397          }
1398          DU_FREE(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1399       }
1400       DU_FREE(rrcVer->latest_RRC_Version.buf,rrcVer->latest_RRC_Version.size);
1401    }
1402 }
1403 /*******************************************************************
1404  *
1405  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1406  *
1407  * @details
1408  *
1409  *    Function :  FreeServedCellList
1410  *
1411  *    Functionality:  deallocating the memory of function BuildServedCellList
1412
1413  *
1414  * @params[in] GNB_DU_Served_Cells_List_t *duServedCell
1415  *
1416  * @return void
1417  *
1418  * ****************************************************************/
1419 void FreeServedCellList( GNB_DU_Served_Cells_List_t *duServedCell)
1420 {
1421    uint8_t   plmnCnt=MAX_PLMN;
1422    uint8_t  extensionCnt=IE_EXTENSION_LIST_COUNT;
1423    uint8_t  plmnIdx=0, sliceIdx=0;
1424    GNB_DU_Served_Cells_Item_t *srvCellItem;
1425    ServedPLMNs_Item_t  *servedPlmnItem;
1426    SliceSupportItem_t  *sliceSupportItem;
1427
1428    if(duServedCell->list.array!=NULLP)
1429    {
1430       if(duServedCell->list.array[0]!=NULLP)
1431       {
1432          srvCellItem= &duServedCell->list.array[0]->value.choice.GNB_DU_Served_Cells_Item;
1433
1434          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1435                srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size * sizeof(uint8_t));
1436          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1437                srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size * sizeof(uint8_t));
1438
1439          if(srvCellItem->served_Cell_Information.fiveGS_TAC!=NULLP)
1440          {
1441             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
1442                   sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
1443             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,sizeof(FiveGS_TAC_t));
1444          }
1445
1446          if(srvCellItem->served_Cell_Information.servedPLMNs.list.array!=NULLP)
1447          {
1448             if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx] != NULLP)
1449             {
1450                servedPlmnItem = srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx];
1451                DU_FREE(servedPlmnItem->pLMN_Identity.buf, servedPlmnItem->pLMN_Identity.size);
1452
1453                if(servedPlmnItem->iE_Extensions != NULLP)
1454                {
1455                   if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1456                   {
1457                      if(servedPlmnItem->iE_Extensions->list.array[0] != NULLP)
1458                      {
1459                         if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1460                         SliceSupportList.list.array != NULLP)
1461                         {
1462                            for(sliceIdx =0; sliceIdx<servedPlmnItem->iE_Extensions->list.array[0]->\
1463                            extensionValue.choice.SliceSupportList.list.count; sliceIdx++)
1464                            {
1465                               if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1466                               SliceSupportList.list.array[sliceIdx] != NULLP)
1467                               {
1468                                  sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[0]->\
1469                                  extensionValue.choice.SliceSupportList.list.array[sliceIdx];
1470
1471                                  DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sizeof(uint8_t));
1472
1473                                  if(sliceSupportItem->sNSSAI.sD != NULLP)
1474                                  {
1475                                     DU_FREE(sliceSupportItem->sNSSAI.sD->buf,\
1476                                     sliceSupportItem->sNSSAI.sD->size);
1477                                     DU_FREE(sliceSupportItem->sNSSAI.sD, sizeof(OCTET_STRING_t));
1478                                  }
1479
1480                                  DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.\
1481                                  choice.SliceSupportList.list.array[sliceIdx], sizeof(SliceSupportItem_t));
1482                               }
1483                            }
1484                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1485                            SliceSupportList.list.array, sizeof(SliceSupportItem_t*));
1486                         }
1487                         DU_FREE(servedPlmnItem->iE_Extensions->list.array[0],\
1488                         sizeof(ServedPLMNs_ItemExtIEs_t));
1489                      }
1490                      DU_FREE(servedPlmnItem->iE_Extensions->list.array,\
1491                      extensionCnt*sizeof(ServedPLMNs_ItemExtIEs_t*));
1492                   }
1493                   DU_FREE(servedPlmnItem->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P3_t));
1494                }
1495                DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx],\
1496                sizeof(ServedPLMNs_Item_t));
1497             }
1498             DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array,\
1499             sizeof(ServedPLMNs_Item_t *));
1500          }
1501
1502          if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD != NULLP)
1503          {
1504             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
1505                   freqBandListNr.list.array != NULLP)
1506             {
1507                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
1508                uL_NRFreqInfo.freqBandListNr.list.array[0],sizeof(FreqBandNrItem_t));
1509                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
1510                uL_NRFreqInfo.freqBandListNr.list.array,sizeof(FreqBandNrItem_t*));
1511             }
1512
1513             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1514                   freqBandListNr.list.array)
1515             {
1516                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1517                      freqBandListNr.list.array[0],sizeof(FreqBandNrItem_t));
1518                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1519                      freqBandListNr.list.array,sizeof(FreqBandNrItem_t *));
1520             }
1521             DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD, sizeof(FDD_Info_t));
1522          }
1523
1524          DU_FREE(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1525                srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1526
1527          if(srvCellItem->gNB_DU_System_Information != NULLP)
1528          {
1529             if(srvCellItem->gNB_DU_System_Information->mIB_message.buf != NULLP)
1530             {
1531                DU_FREE(srvCellItem->gNB_DU_System_Information->mIB_message.buf,\
1532                      srvCellItem->gNB_DU_System_Information->mIB_message.size);
1533             }
1534
1535             if(srvCellItem->gNB_DU_System_Information->sIB1_message.buf != NULLP)
1536             {
1537                DU_FREE(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,\
1538                      srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1539             }
1540
1541             DU_FREE(srvCellItem->gNB_DU_System_Information, sizeof(GNB_DU_System_Information_t));
1542          }
1543
1544          DU_FREE(duServedCell->list.array[0], sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1545       }
1546       DU_FREE(duServedCell->list.array, plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t*));
1547    }
1548 }
1549
1550 /*******************************************************************
1551  *
1552  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1553  *
1554  * @details
1555  *
1556  *    Function :  FreeF1SetupReq
1557  *
1558  *    Functionality:  deallocating the memory of function BuildAndSendF1SetupReq
1559  *
1560  * @params[in] F1AP_PDU_t *f1apMsg
1561  *
1562  * @return void
1563  *
1564  * ****************************************************************/
1565 void FreeF1SetupReq(F1AP_PDU_t *f1apMsg)
1566 {
1567    uint8_t ieIdx, ieIdx2;
1568    F1SetupRequest_t *f1SetupReq=NULLP;
1569
1570    if(f1apMsg != NULLP)
1571    {
1572       if(f1apMsg->choice.initiatingMessage != NULLP)
1573       {
1574          f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1575          if(f1SetupReq->protocolIEs.list.array != NULLP)
1576          {
1577             for(ieIdx = 0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
1578             {
1579                if(f1SetupReq->protocolIEs.list.array[ieIdx] != NULLP)
1580                {
1581                   switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
1582                   {
1583                      case ProtocolIE_ID_id_TransactionID:
1584                         break;
1585                      case ProtocolIE_ID_id_gNB_DU_ID:
1586                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1587                               f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1588                         break;
1589                      case ProtocolIE_ID_id_gNB_DU_Name:
1590                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,\
1591                               strlen((char *)duCfgParam.duName));
1592                         break;
1593                      case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
1594                         FreeServedCellList(&f1SetupReq->protocolIEs.list.\
1595                               array[ieIdx]->value.choice.GNB_DU_Served_Cells_List);
1596                         break;
1597                      case ProtocolIE_ID_id_GNB_DU_RRC_Version:
1598                         FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version);
1599                         break;
1600                      default:
1601                         DU_LOG("\nERROR  -->  Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id);
1602                         break;
1603                   }
1604                }
1605             }
1606             for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++)
1607             {
1608                DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx2],sizeof(F1SetupRequestIEs_t));
1609             }
1610             DU_FREE(f1SetupReq->protocolIEs.list.array,\
1611                   f1SetupReq->protocolIEs.list.size);
1612          }
1613          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1614       }
1615       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1616    }
1617 }
1618 /*******************************************************************
1619  *
1620  * @brief Builds and Send the F1SetupRequest
1621  *
1622  * @details
1623  *
1624  *    Function : BuildAndSendF1SetupReq
1625  *
1626  * Functionality:Fills the F1SetupRequest
1627  *
1628  * @return ROK     - success
1629  *         RFAILED - failure
1630  *
1631  ******************************************************************/
1632 uint8_t BuildAndSendF1SetupReq()
1633 {
1634    uint8_t   ret, ieIdx, elementCnt;
1635    F1AP_PDU_t                 *f1apMsg = NULLP;
1636    F1SetupRequest_t           *f1SetupReq=NULLP;
1637    GNB_DU_Served_Cells_List_t *duServedCell=NULLP;
1638    RRC_Version_t              *rrcVer=NULLP;
1639    asn_enc_rval_t             encRetVal;        /* Encoder return value */
1640    ret= RFAILED;
1641
1642    DU_LOG("\nINFO   -->  F1AP : Building F1 Setup Request\n");
1643    do
1644    {
1645       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1646       if(f1apMsg == NULLP)
1647       {
1648          break;
1649       }
1650       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1651       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1652       if(f1apMsg->choice.initiatingMessage == NULLP)
1653       {
1654          break;
1655       }
1656       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_F1Setup;
1657       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
1658       f1apMsg->choice.initiatingMessage->value.present = \
1659                                                          InitiatingMessage__value_PR_F1SetupRequest;
1660
1661       f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1662
1663       elementCnt = (duCfgParam.duName != NULL) ? 5 : 4;
1664
1665       f1SetupReq->protocolIEs.list.count = elementCnt;
1666       f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t );
1667
1668       /* Initialize the F1Setup members */
1669       DU_ALLOC(f1SetupReq->protocolIEs.list.array,f1SetupReq->protocolIEs.list.size);
1670       if(f1SetupReq->protocolIEs.list.array == NULLP)
1671       {
1672          break;
1673       }
1674       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
1675       {
1676          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx],\
1677                sizeof(F1SetupRequestIEs_t));
1678          if(f1SetupReq->protocolIEs.list.array[ieIdx] == NULLP)
1679          {
1680             break;
1681          }
1682       }
1683
1684       ieIdx = 0;
1685       /*TransactionID*/
1686       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransactionID;
1687       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1688       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present =\
1689                                                                F1SetupRequestIEs__value_PR_TransactionID;
1690       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = \
1691                                                                              TRANS_ID;
1692
1693       /*DU ID*/
1694       ieIdx++;
1695       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
1696       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1697       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1698                                                                 F1SetupRequestIEs__value_PR_GNB_DU_ID;
1699       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size =\
1700                                                                              sizeof(uint8_t);
1701
1702       DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1703             f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1704       if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == \
1705             NULLP)
1706       {
1707          break;
1708       }
1709
1710       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] =\
1711          duCfgParam.duId;
1712
1713       /*DU Name*/
1714       if(duCfgParam.duName != NULL)
1715       {
1716          ieIdx++;
1717          f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_Name;
1718          f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
1719          f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = F1SetupRequestIEs__value_PR_GNB_DU_Name;
1720          f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.size =\
1721             strlen((char *)duCfgParam.duName);
1722          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.\
1723                GNB_DU_Name.buf, strlen((char *)duCfgParam.duName));
1724          if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.\
1725                buf == NULLP)
1726          {
1727             break;
1728          }
1729          strcpy((char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.\
1730                choice.GNB_DU_Name.buf,
1731                (char*)&duCfgParam.duName);
1732
1733       }
1734
1735       /*Served Cell list */
1736       ieIdx++;
1737       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1738                                                      ProtocolIE_ID_id_gNB_DU_Served_Cells_List;
1739       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1740       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1741                                                                 F1SetupRequestIEs__value_PR_GNB_DU_Served_Cells_List;
1742       duServedCell = &f1SetupReq->protocolIEs.list.\
1743                      array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
1744       if(BuildServedCellList(duServedCell))
1745       {
1746          break;
1747       }
1748       /*RRC Version*/
1749       ieIdx++;
1750       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1751                                                      ProtocolIE_ID_id_GNB_DU_RRC_Version ;
1752       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1753       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1754                                                                 F1SetupRequestIEs__value_PR_RRC_Version;
1755       rrcVer = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
1756       if(BuildRrcVer(rrcVer))
1757       {
1758          break;
1759       }
1760       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1761
1762       /* Encode the F1SetupRequest type as APER */
1763       memset(encBuf, 0, ENC_BUF_MAX_LEN);
1764       encBufSize = 0;
1765       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1766             encBuf);
1767
1768       /* Encode results */
1769       if(encRetVal.encoded == ENCODE_FAIL)
1770       {
1771          DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupRequest structure (at %s)\n",\
1772                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1773          break;
1774       }
1775       else
1776       {
1777          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1SetupRequest\n");
1778          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
1779          {
1780             printf("%x",encBuf[ieIdx]);
1781          }
1782       }
1783
1784       /* Sending msg */
1785       if(sendF1APMsg() != ROK)
1786       {
1787          DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup request failed");
1788          break;
1789       }
1790
1791       ret=ROK;
1792       break;
1793    }while(true);
1794
1795    FreeF1SetupReq(f1apMsg);
1796
1797    return ret;
1798 }/* End of BuildAndSendF1SetupReq */
1799
1800 /*******************************************************************
1801  *
1802  * @brief Deallocating memory allocated for Served_Cells_To_Modify_Item_t
1803  *
1804  * @details
1805  *
1806  *    Function : freeCellsToModifyItem
1807  *
1808  *    Functionality: Deallocating memory of variables allocated in
1809  *                    BuildAndSendDUConfigUpdate function
1810  *
1811  * @params[in]  Served_Cells_To_Modify_Item_t *modifyItem
1812  *
1813  * @return ROK     - void
1814  *
1815  * ****************************************************************/
1816
1817 void freeCellsToModifyItem(Served_Cells_To_Modify_Item_t *modifyItem)
1818 {
1819    uint8_t arrIdx=0, servedPlmnIdx=0, sliceLstIdx=0;
1820    ServedPLMNs_Item_t *servedPlmnItem = NULLP;
1821    SliceSupportItem_t *sliceSupportItem = NULLP;
1822
1823    DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf, modifyItem->oldNRCGI.pLMN_Identity.size);
1824    DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf, modifyItem->oldNRCGI.nRCellIdentity.size);
1825
1826    DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1827            modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
1828    DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1829          modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
1830
1831    if(modifyItem->served_Cell_Information.servedPLMNs.list.array != NULLP)
1832    {
1833       if(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx] != NULLP)
1834       {
1835          servedPlmnItem = modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx];
1836
1837          DU_FREE(servedPlmnItem->pLMN_Identity.buf,servedPlmnItem->pLMN_Identity.size);
1838
1839          if(servedPlmnItem->iE_Extensions != NULLP)
1840          {
1841             if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1842             {
1843                if(servedPlmnItem->iE_Extensions->list.array[arrIdx] != NULLP)
1844                {
1845                   if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1846                         list.array != NULLP)
1847                   {
1848                      for(sliceLstIdx =0; sliceLstIdx<servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
1849                            extensionValue.choice.SliceSupportList.list.count; sliceLstIdx++)
1850                      {
1851                         if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1852                               list.array[sliceLstIdx] != NULLP)
1853                         {
1854
1855                            sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1856                                               SliceSupportList.list.array[sliceLstIdx];
1857
1858                            DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sliceSupportItem->sNSSAI.sST.size);
1859                            if(sliceSupportItem->sNSSAI.sD != NULLP)
1860                            {
1861                               DU_FREE(sliceSupportItem->sNSSAI.sD->buf, sliceSupportItem->sNSSAI.sD->size);
1862                               DU_FREE(sliceSupportItem->sNSSAI.sD,sizeof(OCTET_STRING_t));
1863                            }
1864                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1865                                  SliceSupportList.list.array[sliceLstIdx], sizeof(SliceSupportItem_t));
1866                         }
1867                      }
1868                      DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.\
1869                            choice.SliceSupportList.list.array,\
1870                            servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
1871                            extensionValue.choice.SliceSupportList.list.size);
1872                   }
1873                }
1874                for(servedPlmnIdx=0; servedPlmnIdx< servedPlmnItem->iE_Extensions->list.count ; servedPlmnIdx++)
1875                {
1876                   DU_FREE(servedPlmnItem->iE_Extensions->list.array[servedPlmnIdx], sizeof(ServedPLMNs_ItemExtIEs_t ));
1877                }
1878                DU_FREE(servedPlmnItem->iE_Extensions->list.array, servedPlmnItem->iE_Extensions->list.size);
1879             }
1880             DU_FREE(servedPlmnItem->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1881          }
1882       }
1883       for(servedPlmnIdx=0; servedPlmnIdx<modifyItem->served_Cell_Information.servedPLMNs.list.count; servedPlmnIdx++)
1884       {
1885          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[servedPlmnIdx], sizeof(ServedPLMNs_Item_t));
1886       }
1887       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1888          modifyItem->served_Cell_Information.servedPLMNs.list.size);
1889    }
1890
1891    if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD != NULLP)
1892    {
1893       if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1894       {
1895          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
1896                array[arrIdx], sizeof(FreqBandNrItem_t));
1897          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array, \
1898                modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1899       }
1900
1901       if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1902       {
1903          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.\
1904              array[arrIdx], sizeof(FreqBandNrItem_t));
1905          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,\
1906                modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1907       }
1908       DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD,sizeof(FDD_Info_t));
1909    }
1910
1911    DU_FREE(modifyItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1912       modifyItem->served_Cell_Information.measurementTimingConfiguration.size);
1913 }
1914
1915 /*******************************************************************
1916  *
1917  * @brief Deallocating memory of BuildAndSendDUConfigUpdate
1918  *
1919  * @details
1920  *
1921  *    Function : FreeDUConfigUpdate
1922  *
1923  *    Functionality: Deallocating memory of variables allocated in
1924  *                    BuildAndSendDUConfigUpdate function
1925  *
1926  * @params[in]  F1AP_PDU_t *f1apDuCfg
1927  *
1928  * @return ROK     - void
1929  *
1930  * ****************************************************************/
1931 void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg)
1932 {
1933    uint8_t  ieIdx=0, cellModifyIdx=0, cellDeleteIdx=0;
1934    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
1935    Served_Cells_To_Modify_List_t  *cellsToModify=NULLP;
1936    Served_Cells_To_Delete_List_t  *cellsToDelete=NULLP;
1937    Served_Cells_To_Delete_Item_t  *deleteItem = NULLP;
1938    Served_Cells_To_Delete_ItemIEs_t *deleteItemIe = NULLP;
1939
1940    if(f1apDuCfg != NULLP)
1941    {
1942       if(f1apDuCfg->choice.initiatingMessage != NULLP)
1943       {
1944          duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->\
1945                        value.choice.GNBDUConfigurationUpdate;
1946          if(duCfgUpdate->protocolIEs.list.array != NULLP)
1947          {
1948             for(ieIdx=0; ieIdx<duCfgUpdate->protocolIEs.list.count; ieIdx++)
1949             {
1950                if(duCfgUpdate->protocolIEs.list.array[ieIdx] != NULLP)
1951                {
1952                   switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
1953                   {
1954                      case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
1955                         {
1956                            cellsToModify = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1957                                            value.choice.Served_Cells_To_Modify_List;
1958                            if(cellsToModify->list.array != NULLP)
1959                            {
1960                               for(cellModifyIdx=0; cellModifyIdx<cellsToModify->list.count ;cellModifyIdx++)
1961                               {
1962                                  if(cellsToModify->list.array[cellModifyIdx] != NULLP)
1963                                  {
1964                                     freeCellsToModifyItem(&cellsToModify->list.array[cellModifyIdx]->value.choice.\
1965                                           Served_Cells_To_Modify_Item);
1966                                     DU_FREE(cellsToModify->list.array[cellModifyIdx],\
1967                                           sizeof(Served_Cells_To_Modify_ItemIEs_t));
1968                                  }
1969                               }
1970                               DU_FREE(cellsToModify->list.array,cellsToModify->list.size);
1971                            }
1972                            break;
1973                         }
1974                      case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
1975                         {
1976                            cellsToDelete = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1977                                            value.choice.Served_Cells_To_Delete_List;
1978                            if(cellsToDelete->list.array != NULLP)
1979                            {
1980                               for(cellDeleteIdx=0; cellDeleteIdx<cellsToDelete->list.count ;cellDeleteIdx++)
1981                               {
1982                                  if(cellsToDelete->list.array[cellDeleteIdx] != NULLP)
1983                                  {
1984                                     deleteItemIe = ((Served_Cells_To_Delete_ItemIEs_t*)\
1985                                           cellsToDelete->list.array[cellDeleteIdx]);
1986                                     deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
1987                                     DU_FREE(deleteItem->oldNRCGI.pLMN_Identity.buf,\
1988                                           deleteItem->oldNRCGI.pLMN_Identity.size);
1989                                     DU_FREE(deleteItem->oldNRCGI.nRCellIdentity.buf,\
1990                                           deleteItem->oldNRCGI.nRCellIdentity.size);
1991                                     DU_FREE(cellsToDelete->list.array[cellDeleteIdx],\
1992                                           sizeof(Served_Cells_To_Delete_ItemIEs_t));
1993                                  }
1994                               }
1995                               DU_FREE(cellsToDelete->list.array,cellsToDelete->list.size);
1996                            }
1997
1998                            break;
1999                         }
2000                      case ProtocolIE_ID_id_gNB_DU_ID:
2001                         {
2002                            DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2003                                  duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2004                            break;
2005                         }
2006                   }
2007                   DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx],\
2008                         sizeof(GNBDUConfigurationUpdateIEs_t));
2009                }
2010             }
2011             DU_FREE(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2012          }
2013          DU_FREE(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2014       }
2015       DU_FREE(f1apDuCfg, (Size)sizeof(F1AP_PDU_t));
2016    }
2017 }
2018
2019 /*******************************************************************
2020  *
2021  * @brief Fills Served Plmns required in ServCellInfo IE
2022  *
2023  * @details
2024  *
2025  *    Function : fillServedPlmns
2026  *
2027  *    Functionality: Fills Served Plmns required in ServCellInfo IE
2028  *
2029  * @params[in] Pointer to ServedPLMNs_List_t *
2030  *
2031  * @return ROK     - success
2032  *         RFAILED - failure
2033  *
2034  *****************************************************************/
2035
2036 uint8_t fillServedPlmns(ServedPLMNs_List_t *servedPlmn)
2037 {
2038    uint8_t ieIdx=0, arrayIdx=0, ieListCnt=0, elementCnt=0, sliceLstIdx=0;
2039
2040    servedPlmn->list.array[arrayIdx]->pLMN_Identity.size = 3*sizeof(uint8_t);
2041    DU_ALLOC(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf, servedPlmn->list.\
2042          array[arrayIdx]->pLMN_Identity.size);
2043    if(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf == NULLP)
2044    {
2045       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2046       return RFAILED;
2047    }
2048    buildPlmnId(duCfgParam.srvdCellLst[arrayIdx].duCellInfo.cellInfo.srvdPlmn[arrayIdx].plmn,\
2049          servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf);
2050    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
2051    if(servedPlmn->list.array[arrayIdx]->iE_Extensions == NULLP)
2052    {
2053       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2054       return RFAILED;
2055    }
2056
2057    ieListCnt=1;
2058    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.count = ieListCnt;
2059    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.size = ieListCnt *sizeof(ServedPLMNs_ItemExtIEs_t *);
2060    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array,servedPlmn->list.array[arrayIdx]->\
2061          iE_Extensions->list.size);
2062    if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array == NULLP)
2063    {
2064       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2065       return RFAILED;
2066    }
2067    for(ieIdx=arrayIdx;ieIdx<ieListCnt;ieIdx++)
2068    {
2069       DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx],\
2070             sizeof(ServedPLMNs_ItemExtIEs_t));
2071       if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx] == NULLP)
2072       {
2073          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2074          return RFAILED;
2075       }
2076    }
2077
2078    ieIdx = 0;
2079    elementCnt = NUM_OF_SUPPORTED_SLICE;
2080    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->id =ProtocolIE_ID_id_TAISliceSupportList;
2081    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->criticality = Criticality_ignore;
2082    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.present = \
2083    ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
2084    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2085       list.count = elementCnt;
2086    servedPlmn->list.array[arrayIdx]->\
2087       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2088       list.size = elementCnt * sizeof(SliceSupportItem_t *);
2089    DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2090          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2091          list.array,servedPlmn->list.array[arrayIdx]->\
2092          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.size);
2093    if(servedPlmn->list.array[arrayIdx]->\
2094          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2095          list.array == NULLP)
2096    {
2097       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2098       return RFAILED;
2099    }
2100
2101    for(sliceLstIdx =0; sliceLstIdx< elementCnt; sliceLstIdx++)
2102    {
2103       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2104       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2105       list.array[sliceLstIdx],sizeof( SliceSupportItem_t));
2106       if(servedPlmn->list.array[arrayIdx]->\
2107       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2108       list.array[sliceLstIdx] == NULLP)
2109       {
2110          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2111          return RFAILED;
2112       }
2113
2114       servedPlmn->list.array[arrayIdx]->\
2115       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2116       list.array[sliceLstIdx]->sNSSAI.sST.size = sizeof(uint8_t);
2117       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2118       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2119       list.array[sliceLstIdx]->sNSSAI.sST.buf,servedPlmn->list.array[arrayIdx]->\
2120       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->\
2121       sNSSAI.sST.size);
2122
2123       if(servedPlmn->list.array[arrayIdx]->\
2124       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2125       list.array[sliceLstIdx]->sNSSAI.sST.buf == NULLP)
2126       {
2127          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2128          return RFAILED;
2129       }
2130       servedPlmn->list.array[arrayIdx]->\
2131       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2132       list.array[sliceLstIdx]->sNSSAI.sST.buf[arrayIdx] =  duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
2133       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
2134
2135       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2136       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2137       list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
2138       if(servedPlmn->list.array[arrayIdx]->\
2139       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2140       list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
2141       {
2142          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2143          return RFAILED;
2144       }
2145       servedPlmn->list.array[arrayIdx]->\
2146       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2147       list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
2148       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2149       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2150       list.array[sliceLstIdx]->sNSSAI.sD->buf,servedPlmn->list.array[arrayIdx]->\
2151       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2152       list.array[sliceLstIdx]->sNSSAI.sD->size);
2153       if(servedPlmn->list.array[arrayIdx]->\
2154       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2155       list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
2156       {
2157          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2158          return RFAILED;
2159       }
2160       memcpy(servedPlmn->list.array[arrayIdx]->\
2161       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2162       list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
2163       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sd,\
2164       servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2165       list.array[sliceLstIdx]->sNSSAI.sD->size);
2166    }
2167    return ROK;
2168 }
2169
2170 /*******************************************************************
2171  *
2172  * @brief Fills Nr Fdd Info required in ServCellInfo IE
2173  *
2174  * @details
2175  *
2176  *    Function : fillNrFddInfo
2177  *
2178  *    Functionality: Fills Nr Fdd Info required in ServCellInfo IE
2179  *
2180  * @params[in] Pointer to NR_Mode_Info_t *
2181  *
2182  * @return ROK     - success
2183  *         RFAILED - failure
2184  *
2185  *****************************************************************/
2186
2187 uint8_t fillNrFddInfo(NR_Mode_Info_t *nrFdd)
2188 {
2189    nrFdd->choice.fDD->uL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.\
2190       f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn;
2191    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.count = 1;
2192    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t*);
2193    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
2194          array, nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size);
2195    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2196    {
2197       return RFAILED;
2198    }
2199    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0], \
2200       sizeof(FreqBandNrItem_t));
2201    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2202    {
2203       return RFAILED;
2204    }
2205    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2206       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
2207       freqBand[0].nrFreqBand;
2208    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2209    nrFdd->choice.fDD->dL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.\
2210       dlNrFreqInfo.nrArfcn;
2211    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.count = 1;
2212    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
2213    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,nrFdd->\
2214          choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
2215    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2216    {
2217       return RFAILED;
2218    }
2219    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0],\
2220          sizeof(FreqBandNrItem_t));
2221    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2222    {
2223       return RFAILED;
2224    }
2225    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2226       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
2227       freqBand[0].nrFreqBand;
2228    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2229
2230    /*Transmission Bandwidth*/
2231    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2232       f1Mode.mode.fdd.ulTxBw.nrScs;
2233    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2234       f1Mode.mode.fdd.ulTxBw.nrb;
2235    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2236       f1Mode.mode.fdd.dlTxBw.nrScs;
2237    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2238       f1Mode.mode.fdd.dlTxBw.nrb;
2239
2240    return ROK;
2241 }
2242
2243 /*******************************************************************
2244  *
2245  * @brief Fills ServCellInfo IE
2246  *
2247  * @details
2248  *
2249  *    Function : fillServedCellInfo
2250  *
2251  *    Functionality: Fills ServCellInfo
2252  *
2253  * @params[in] Pointer to Served_Cell_Information_t *
2254  *
2255  * @return ROK     - success
2256  *         RFAILED - failure
2257  *
2258  *****************************************************************/
2259
2260 uint8_t fillServedCellInfo(Served_Cell_Information_t *srvCellInfo)
2261 {
2262    uint8_t tmp, ieIdx, ieListCnt;
2263
2264    /*nRCGI*/
2265    srvCellInfo->nRCGI.pLMN_Identity.size =3*sizeof(uint8_t);
2266    DU_ALLOC(srvCellInfo->nRCGI.pLMN_Identity.buf,\
2267          srvCellInfo->nRCGI.pLMN_Identity.size);
2268    if(srvCellInfo->nRCGI.pLMN_Identity.buf == NULLP)
2269    {
2270       return RFAILED;
2271    }
2272    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2273          srvCellInfo->nRCGI.pLMN_Identity.buf);
2274    srvCellInfo->nRCGI.nRCellIdentity.size =5*sizeof(uint8_t);
2275    DU_ALLOC(srvCellInfo->nRCGI.nRCellIdentity.buf,\
2276          srvCellInfo->nRCGI.nRCellIdentity.size);
2277    if(srvCellInfo->nRCGI.nRCellIdentity.buf == NULLP)
2278    {
2279       return RFAILED;
2280    }
2281    for (tmp = 0 ; tmp < srvCellInfo->\
2282          nRCGI.nRCellIdentity.size-1 ; tmp++)
2283    {
2284       srvCellInfo->nRCGI.nRCellIdentity.buf[tmp] = 0;
2285    }
2286    srvCellInfo->nRCGI.nRCellIdentity.buf[4] = 16;
2287    srvCellInfo->nRCGI.nRCellIdentity.bits_unused =4;
2288
2289    /*nRPCI*/
2290    srvCellInfo->nRPCI = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
2291
2292    /*servedPLMNs*/
2293    ieListCnt = 1;
2294    srvCellInfo->servedPLMNs.list.count = ieListCnt;
2295    srvCellInfo->servedPLMNs.list.size = ieListCnt*sizeof(ServedPLMNs_Item_t *);
2296    DU_ALLOC(srvCellInfo->servedPLMNs.list.array,\
2297          srvCellInfo->servedPLMNs.list.size);
2298    if(srvCellInfo->servedPLMNs.list.array == NULLP)
2299    {
2300       return RFAILED;
2301    }
2302    for(ieIdx=0; ieIdx < ieListCnt; ieIdx++)
2303    {
2304       DU_ALLOC(srvCellInfo->servedPLMNs.list.array[ieIdx],\
2305             sizeof(ServedPLMNs_Item_t));
2306       if(srvCellInfo->servedPLMNs.list.array[ieIdx]== NULLP)
2307       {
2308          return RFAILED;
2309       }
2310    }
2311    if(fillServedPlmns(&srvCellInfo->servedPLMNs))
2312    {
2313       return RFAILED;
2314    }
2315
2316    /*nR Mode Info with FDD*/
2317    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_fDD;
2318    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.fDD,\
2319          sizeof(FDD_Info_t));
2320    if(srvCellInfo->nR_Mode_Info.choice.fDD == NULLP)
2321    {
2322       return RFAILED;
2323    }
2324    if(fillNrFddInfo(&srvCellInfo->nR_Mode_Info))
2325       return RFAILED;
2326
2327    /*Measurement timing Config*/
2328    srvCellInfo->measurementTimingConfiguration.size = sizeof(uint8_t);
2329    DU_ALLOC(srvCellInfo->measurementTimingConfiguration.\
2330          buf,srvCellInfo->measurementTimingConfiguration.size);
2331    if(srvCellInfo->measurementTimingConfiguration.buf == NULLP)
2332    {
2333       return RFAILED;
2334    }
2335    srvCellInfo->measurementTimingConfiguration.\
2336          buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
2337
2338    return ROK;
2339 }
2340
2341 /*******************************************************************
2342  *
2343  * @brief Fills ServCellToModItem IE
2344  *
2345  * @details
2346  *
2347  *    Function : fillServCellToModItem
2348  *
2349  *    Functionality: Fills ServCellToModItem IE
2350  *
2351  * @params[in] Pointer to Served_Cells_To_Modify_Item_t *
2352  *
2353  * @return ROK     - success
2354  *         RFAILED - failure
2355  *
2356  *****************************************************************/
2357
2358 uint8_t fillServCellToModItem(Served_Cells_To_Modify_Item_t *modifyItem)
2359 {
2360    uint8_t ieIdx;
2361
2362    /*pLMN_Identity*/
2363    modifyItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2364    DU_ALLOC(modifyItem->oldNRCGI.pLMN_Identity.buf,modifyItem->oldNRCGI.pLMN_Identity.size);
2365    if(modifyItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2366    {
2367       return RFAILED;
2368    }
2369    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2370          modifyItem->oldNRCGI.pLMN_Identity.buf);
2371
2372    /*nRCellIdentity*/
2373    modifyItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2374    DU_ALLOC(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2375          modifyItem->oldNRCGI.nRCellIdentity.size);
2376    if(modifyItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2377    {
2378       return RFAILED;
2379    }
2380    for(ieIdx = 0; ieIdx < modifyItem->oldNRCGI.nRCellIdentity.size-1; ieIdx++)
2381    {
2382       modifyItem->oldNRCGI.nRCellIdentity.buf[ieIdx] = 0;
2383    }
2384    modifyItem->oldNRCGI.nRCellIdentity.buf[4] = 16;
2385    modifyItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
2386
2387    if(fillServedCellInfo(&modifyItem->served_Cell_Information))
2388       return RFAILED;
2389    else
2390       return ROK;
2391 }
2392
2393 /*******************************************************************
2394  *
2395  * @brief Builds ServCellToModList
2396  *
2397  * @details
2398  *
2399  *    Function : buildServCellToModList
2400  *
2401  *    Functionality: Builds the serv cell to Mod List
2402  *
2403  * @params[in] Pointer to Served_Cells_To_Modify_List_t *
2404  *
2405  * @return ROK     - success
2406  *         RFAILED - failure
2407  *
2408  *****************************************************************/
2409
2410 uint8_t buildServCellToModList(Served_Cells_To_Modify_List_t *cellsToModify)
2411 {
2412    uint8_t ieListCnt, ieIdx;
2413    Served_Cells_To_Modify_Item_t *modifyItem = NULLP;
2414
2415    ieListCnt = 1;
2416    cellsToModify->list.count = ieListCnt;
2417    cellsToModify->list.size = ieListCnt*sizeof(Served_Cells_To_Modify_ItemIEs_t *);
2418    DU_ALLOC(cellsToModify->list.array,cellsToModify->list.size);
2419    if(cellsToModify->list.array == NULLP)
2420    {
2421       return RFAILED;
2422    }
2423    for(ieIdx=0; ieIdx< ieListCnt; ieIdx++)
2424    {
2425       DU_ALLOC(cellsToModify->list.array[ieIdx],sizeof(Served_Cells_To_Modify_ItemIEs_t));
2426       if(cellsToModify->list.array[ieIdx] == NULLP)
2427       {
2428          return RFAILED;
2429       }
2430    }
2431    cellsToModify->list.array[0]->id = ProtocolIE_ID_id_Served_Cells_To_Modify_Item;
2432    cellsToModify->list.array[0]->criticality = Criticality_reject;
2433    cellsToModify->list.array[0]->value.present =\
2434       Served_Cells_To_Modify_ItemIEs__value_PR_Served_Cells_To_Modify_Item;
2435    modifyItem=&cellsToModify->list.array[0]->value.choice.Served_Cells_To_Modify_Item;
2436
2437    if(fillServCellToModItem(modifyItem))
2438       return RFAILED;
2439    else
2440       return ROK;
2441 }
2442 /*******************************************************************
2443  *
2444  * @brief filling the DeleteItemList
2445  *
2446  * @details
2447  *
2448  *    Function : fillCellToDeleteItem
2449  *
2450  *    Functionality: Filling the DeleteItemIe
2451  *
2452  * @params[in] Pointer to Served_Cells_To_Delete_ItemIEs_t
2453  *
2454  * @return ROK     - success
2455  *         RFAILED - failure
2456  *
2457  *****************************************************************/
2458 uint8_t fillCellToDeleteItem(struct Served_Cells_To_Delete_ItemIEs *deleteItemIe)
2459 {
2460    uint8_t arrIdx;
2461    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
2462
2463    deleteItemIe->id = ProtocolIE_ID_id_Served_Cells_To_Delete_Item;
2464    deleteItemIe->criticality = Criticality_reject;
2465    deleteItemIe->value.present =\
2466    Served_Cells_To_Delete_ItemIEs__value_PR_Served_Cells_To_Delete_Item;
2467    deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
2468
2469    /*pLMN_Identity*/
2470    deleteItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2471    DU_ALLOC(deleteItem->oldNRCGI.pLMN_Identity.buf,deleteItem->oldNRCGI.pLMN_Identity.size);
2472    if(deleteItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2473    {
2474       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2475       return RFAILED;
2476    }
2477    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2478          deleteItem->oldNRCGI.pLMN_Identity.buf);
2479
2480    /*nRCellIdentity*/
2481    deleteItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2482    DU_ALLOC(deleteItem->oldNRCGI.nRCellIdentity.buf,\
2483          deleteItem->oldNRCGI.nRCellIdentity.size);
2484    if(deleteItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2485    {
2486       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2487       return RFAILED;
2488    }
2489    for(arrIdx = 0; arrIdx < deleteItem->oldNRCGI.nRCellIdentity.size-1; arrIdx++)
2490    {
2491       deleteItem->oldNRCGI.nRCellIdentity.buf[arrIdx] = 0;
2492    }
2493    deleteItem->oldNRCGI.nRCellIdentity.buf[4] = 16;
2494    deleteItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
2495    return ROK;
2496 }
2497 /*******************************************************************
2498  *
2499  * @brief Builds ServCellToDeleteList
2500  *
2501  * @details
2502  *
2503  *    Function : buildServCellToDeleteList
2504  *
2505  *    Functionality: Builds the serv cell to delete List
2506  *
2507  * @params[in] Pointer to Served_Cells_To_Delete_List_t *
2508  *
2509  * @return ROK     - success
2510  *         RFAILED - failure
2511  *
2512  *****************************************************************/
2513
2514 uint8_t buildServCellToDeleteList(Served_Cells_To_Delete_List_t *cellsToDelete)
2515 {
2516    uint8_t ieListCnt, arrIdx;
2517
2518    ieListCnt = 1;
2519    cellsToDelete->list.count = ieListCnt;
2520    cellsToDelete->list.size = ieListCnt*sizeof(Served_Cells_To_Delete_ItemIEs_t *);
2521
2522    DU_ALLOC(cellsToDelete->list.array,cellsToDelete->list.size);
2523    if(cellsToDelete->list.array == NULLP)
2524    {
2525       DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2526       return RFAILED;
2527    }
2528
2529    for(arrIdx=0; arrIdx< ieListCnt; arrIdx++)
2530    {
2531       DU_ALLOC(cellsToDelete->list.array[arrIdx],sizeof(Served_Cells_To_Delete_ItemIEs_t));
2532       if(cellsToDelete->list.array[arrIdx] == NULLP)
2533       {
2534          DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2535          return RFAILED;
2536       }
2537    }
2538
2539    arrIdx=0;
2540    if(fillCellToDeleteItem((Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx]) !=ROK)
2541    {
2542       DU_LOG("\nERROR  -->  F1AP: buildServCellToDeleteList(): failed to fill Served_Cells_To_Delete_ItemIEs");
2543       return RFAILED;
2544    }
2545    return ROK;
2546 }
2547
2548 /*******************************************************************
2549  *
2550  * @brief Builds and sends the DUConfigUpdate
2551  *
2552  * @details
2553  *
2554  *    Function : BuildAndSendDUConfigUpdate
2555  *
2556  *    Functionality: Constructs the DU Update message and sends
2557  *                   it to the CU through SCTP.
2558  *
2559  * @params[in] void **buf,Buffer to which encoded pattern is written into
2560  * @params[in] int *size,size of buffer
2561  *
2562  * @return ROK     - success
2563  *         RFAILED - failure
2564  *
2565  * ****************************************************************/
2566 uint8_t BuildAndSendDUConfigUpdate(ServCellAction servCellAction)
2567 {
2568    uint8_t ret =0, ieIdx=0, elementCnt=0;
2569    bool memAlloctionFailure = false;
2570    F1AP_PDU_t                 *f1apDuCfg = NULLP;
2571    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
2572    asn_enc_rval_t encRetVal;     /* Encoder return value */
2573
2574    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2575    ret= RFAILED;
2576
2577    while(true)
2578    {
2579       DU_LOG("\nINFO   -->  F1AP : Building DU config update\n");
2580       /* Allocate the memory for F1DuCfg */
2581       DU_ALLOC(f1apDuCfg, sizeof(F1AP_PDU_t));
2582       if(f1apDuCfg == NULLP)
2583       {
2584          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2585          break;
2586       }
2587
2588       f1apDuCfg->present = F1AP_PDU_PR_initiatingMessage;
2589       DU_ALLOC(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2590       if(f1apDuCfg->choice.initiatingMessage == NULLP)
2591       {
2592          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2593          break;
2594       }
2595
2596       f1apDuCfg->choice.initiatingMessage->procedureCode = \
2597                                                            ProcedureCode_id_gNBDUConfigurationUpdate;
2598       f1apDuCfg->choice.initiatingMessage->criticality = Criticality_reject;
2599       f1apDuCfg->choice.initiatingMessage->value.present = \
2600                                                            InitiatingMessage__value_PR_GNBDUConfigurationUpdate;
2601       duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\
2602                     choice.GNBDUConfigurationUpdate;
2603       elementCnt = 3;
2604       duCfgUpdate->protocolIEs.list.count = elementCnt;
2605       duCfgUpdate->protocolIEs.list.size = \
2606                                            elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t*);
2607
2608       /* Initialize the F1Setup members */
2609       DU_ALLOC(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2610       if(duCfgUpdate->protocolIEs.list.array == NULLP)
2611       {
2612          DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2613          break;
2614       }
2615       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
2616       {
2617          DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx],sizeof(GNBDUConfigurationUpdateIEs_t));
2618          if(duCfgUpdate->protocolIEs.list.array[ieIdx] == NULLP)
2619          {
2620             DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2621             memAlloctionFailure = true;
2622             break;
2623          }
2624       }
2625
2626       if(memAlloctionFailure == true)
2627       {
2628          break;
2629       }
2630       /*TransactionID*/
2631       ieIdx = 0;
2632       duCfgUpdate->protocolIEs.list.array[ieIdx]->id=ProtocolIE_ID_id_TransactionID;
2633       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
2634       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2635       GNBDUConfigurationUpdateIEs__value_PR_TransactionID;
2636       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = TRANS_ID;
2637
2638       ieIdx++;
2639       if(servCellAction == SERV_CELL_TO_MODIFY)
2640       {
2641          /*Served Cell to Modify */
2642          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2643          ProtocolIE_ID_id_Served_Cells_To_Modify_List;
2644          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2645          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2646          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Modify_List;
2647          if(buildServCellToModList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2648                   Served_Cells_To_Modify_List))
2649          {
2650             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToModList");
2651             break;
2652          }
2653       }
2654       else
2655       {
2656          /*Served Cell to Delete */
2657          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2658          ProtocolIE_ID_id_Served_Cells_To_Delete_List;
2659          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2660          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2661          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Delete_List;
2662          if(buildServCellToDeleteList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2663          Served_Cells_To_Delete_List)!=ROK)
2664          {
2665             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToDeleteList");
2666             break;
2667          }
2668
2669       }
2670       // NOTE :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
2671       /*GNB DU ID */
2672       ieIdx++;
2673       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
2674       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
2675       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2676       GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID;
2677       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size = sizeof(uint8_t);
2678       DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2679             duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2680       if(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == NULLP)
2681       {
2682          DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): Memory allocation failed for GNB_DU_ID");
2683          break;
2684       }
2685       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] = duCfgParam.duId;
2686
2687       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
2688
2689       /* Encode the DU Config Update type as APER */
2690       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
2691       encBufSize = 0;
2692       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
2693
2694       /* Checking encode results */
2695       if(encRetVal.encoded == ENCODE_FAIL)
2696       {
2697          DU_LOG("ERROR  -->  F1AP : Could not encode DUConfigUpdate structure (at %s)\n",\
2698                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2699          break;
2700       }
2701       else
2702       {
2703          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DUConfigUpdate\n");
2704          for(ieIdx =0; ieIdx < encBufSize; ieIdx++)
2705          {
2706             printf("%x",encBuf[ieIdx]);
2707          }
2708       }
2709       /* Sending msg */
2710       if(sendF1APMsg() != ROK)
2711       {
2712          DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update failed");
2713          break;
2714       }
2715
2716       ret = ROK;
2717       break;
2718    }
2719
2720    addToReservedF1apPduList(TRANS_ID,f1apDuCfg);
2721    return ret;
2722 }
2723
2724
2725 /*******************************************************************
2726  *
2727  * @brief free the ULRRCMessageTransfer
2728  *
2729  * @details
2730  *
2731  *    Function : FreeULRRCMessageTransfer
2732  *
2733  *    Functionality: Deallocating the memory of variable allocated in
2734  *                      FreeULRRCMessageTransfer
2735  *
2736  * @params[in]
2737  *
2738  * @return ROK     - void
2739  *
2740  ******************************************************************/
2741 void FreeULRRCMessageTransfer( F1AP_PDU_t *f1apMsg)
2742 {
2743    uint8_t idx1;
2744    ULRRCMessageTransfer_t  *ulRRCMsg;
2745
2746    if(f1apMsg != NULLP)
2747    {
2748       if(f1apMsg->choice.initiatingMessage != NULLP)
2749       {
2750          ulRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2751          if(ulRRCMsg->protocolIEs.list.array != NULLP)
2752          {
2753             for(idx1=0;idx1<ulRRCMsg->protocolIEs.list.count;idx1++)
2754             {
2755                if(ulRRCMsg->protocolIEs.list.array[idx1] != NULLP)
2756                {
2757                   if(ulRRCMsg->protocolIEs.list.array[idx1]->value.present ==
2758                         ULRRCMessageTransferIEs__value_PR_RRCContainer)
2759                   {
2760                      DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2761                            ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2762                   }
2763                   DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1],sizeof(ULRRCMessageTransferIEs_t));
2764                }
2765             }
2766             DU_FREE(ulRRCMsg->protocolIEs.list.array,ulRRCMsg->protocolIEs.list.size );
2767          }
2768          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2769       }
2770       DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
2771    }
2772 }
2773 /*******************************************************************
2774  *
2775  * @brief Builds and sends the ULRRCMessageTransfer
2776  *
2777  * @details
2778  *
2779  *    Function : BuildAndSendULRRCMessageTransfer
2780  *
2781  *    Functionality: Constructs the UL RRC Message Transfer and sends
2782  *                   it to the CU through SCTP.
2783  *
2784  * @params[in]
2785  *
2786  * @return ROK     - success
2787  *         RFAILED - failure
2788  *
2789  * ****************************************************************/
2790 uint8_t BuildAndSendULRRCMessageTransfer(DuUeCb  ueCb, uint8_t lcId, \
2791       uint16_t msgLen, uint8_t *rrcMsg)
2792 {
2793    uint8_t   elementCnt =0;
2794    uint8_t   idx1 =0;
2795    uint8_t   idx =0;
2796    F1AP_PDU_t                   *f1apMsg = NULLP;
2797    ULRRCMessageTransfer_t       *ulRRCMsg = NULLP;
2798    asn_enc_rval_t               encRetVal;        /* Encoder return value */
2799    uint8_t ret =RFAILED;
2800
2801    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2802
2803    while(true)
2804    {
2805       DU_LOG("\n INFO   -->  F1AP : Building UL RRC Message Transfer Message\n");
2806
2807       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
2808       if(f1apMsg == NULLP)
2809       {
2810          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2811          break;
2812       }
2813       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
2814       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2815       if(f1apMsg->choice.initiatingMessage == NULLP)
2816       {
2817          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
2818          break;
2819       }
2820       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_ULRRCMessageTransfer;
2821       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
2822       f1apMsg->choice.initiatingMessage->value.present = \
2823                                                          InitiatingMessage__value_PR_ULRRCMessageTransfer;
2824       ulRRCMsg =
2825          &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2826       elementCnt = 4;
2827       ulRRCMsg->protocolIEs.list.count = elementCnt;
2828       ulRRCMsg->protocolIEs.list.size = \
2829                                         elementCnt * sizeof(ULRRCMessageTransferIEs_t *);
2830
2831       /* Initialize the F1Setup members */
2832       DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size);
2833       if(ulRRCMsg->protocolIEs.list.array == NULLP)
2834       {
2835          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
2836          break;
2837       }
2838       for(idx=0; idx<elementCnt; idx++)
2839       {
2840          DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t));
2841          if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP)
2842          {
2843             break;
2844          }
2845       }
2846
2847       idx1 = 0;
2848
2849       /*GNB CU UE F1AP ID*/
2850       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
2851       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2852       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2853                                                               ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
2854       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = ueCb.gnbCuUeF1apId;
2855
2856       /*GNB DU UE F1AP ID*/
2857       idx1++;
2858       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
2859       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2860       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2861                                                               ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
2862       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = ueCb.gnbDuUeF1apId;
2863
2864       /*SRBID*/
2865       idx1++;
2866       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
2867       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2868       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2869                                                               ULRRCMessageTransferIEs__value_PR_SRBID;
2870       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = lcId;
2871
2872       /*RRCContainer*/
2873       idx1++;
2874       ulRRCMsg->protocolIEs.list.array[idx1]->id  = ProtocolIE_ID_id_RRCContainer;
2875       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2876       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2877                                                               ULRRCMessageTransferIEs__value_PR_RRCContainer;
2878       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size = msgLen;
2879       DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2880             ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
2881       if(!ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
2882       {
2883          DU_LOG(" ERROR  -->  F1AP : Memory allocation for BuildAndSendULRRCMessageTransfer failed");
2884          break;
2885       }
2886       memset(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, 0, msgLen);
2887       memcpy(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, \
2888             rrcMsg, ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2889
2890       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2891
2892       /* Encode the F1SetupRequest type as APER */
2893       memset(encBuf, 0, ENC_BUF_MAX_LEN);
2894       encBufSize = 0;
2895       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
2896             encBuf);
2897       /* Encode results */
2898       if(encRetVal.encoded == ENCODE_FAIL)
2899       {
2900          DU_LOG( "\nERROR  -->  F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
2901                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2902          break;
2903       }
2904       else
2905       {
2906          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
2907          for(int i=0; i< encBufSize; i++)
2908          {
2909             printf("%x",encBuf[i]);
2910          }
2911       }
2912
2913       /* Sending  msg  */
2914       if(sendF1APMsg()  !=      ROK)
2915       {
2916          DU_LOG("\nERROR  -->   F1AP : Sending  UL RRC Message Transfer Failed");
2917          break;
2918       }
2919       ret = ROK;
2920       break;
2921    }
2922    FreeULRRCMessageTransfer(f1apMsg);
2923
2924    return ret;
2925 }/* End of BuildAndSendULRRCMessageTransfer*/
2926
2927 /*******************************************************************
2928  *
2929  * @brief Builds tag config
2930  *
2931  * @details
2932  *
2933  *    Function : BuildTagConfig
2934  *
2935  *    Functionality: Builds tag config in MacCellGroupConfig
2936  *
2937  * @params[in] TAG_Config *tag_Config
2938  *
2939  * @return ROK     - success
2940  *         RFAILED - failure
2941  *
2942  * ****************************************************************/
2943 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
2944 {
2945    struct TAG_Config__tag_ToAddModList *tagList;
2946    uint8_t                     idx, elementCnt;
2947
2948    tagConfig->tag_ToReleaseList = NULLP;
2949    tagConfig->tag_ToAddModList = NULLP;
2950    DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
2951    if(!tagConfig->tag_ToAddModList)
2952    {
2953       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2954       return RFAILED;
2955    }
2956
2957    elementCnt = 1; //ODU_VALUE_ONE;
2958    tagList = tagConfig->tag_ToAddModList;
2959    tagList->list.count = elementCnt;
2960    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
2961
2962    tagList->list.array = NULLP;
2963    DU_ALLOC(tagList->list.array, tagList->list.size);
2964    if(!tagList->list.array)
2965    {
2966       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2967       return RFAILED;
2968    }
2969
2970    for(idx=0; idx<tagList->list.count; idx++)
2971    {
2972       tagList->list.array[idx] = NULLP;
2973       DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
2974       if(!tagList->list.array[idx])
2975       {
2976          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2977          return RFAILED;
2978       }
2979    }
2980
2981    idx = 0;
2982    tagList->list.array[idx]->tag_Id = TAG_ID;
2983    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
2984
2985    return ROK;
2986 }
2987
2988 /*******************************************************************
2989  *
2990  * @brief Builds PHR Config
2991  *
2992  * @details
2993  *
2994  *    Function : BuildPhrConfig
2995  *
2996  *    Functionality: Builds phrConfig in MacCellGroupConfig
2997  *
2998  * @params[in] PHR Config *
2999  *
3000  * @return ROK     - success
3001  *         RFAILED - failure
3002  *
3003  * ****************************************************************/
3004 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
3005 {
3006
3007    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
3008    phrConfig->choice.setup = NULLP;
3009    DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
3010    if(!phrConfig->choice.setup)
3011    {
3012       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
3013       return RFAILED;
3014    }
3015
3016    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
3017    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
3018    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
3019    phrConfig->choice.setup->multiplePHR              = false;
3020    phrConfig->choice.setup->dummy                    = false;
3021    phrConfig->choice.setup->phr_Type2OtherCell       = false;
3022    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
3023
3024    return ROK;
3025 }
3026
3027 /*******************************************************************
3028  *
3029  * @brief Builds BSR Config
3030  *
3031  * @details
3032  *
3033  *    Function : BuildBsrConfig
3034  *
3035  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
3036  *
3037  * @params[in] BSR_Config *bsrConfig
3038  *
3039  * @return ROK     - success
3040  *         RFAILED - failure
3041  *
3042  * ****************************************************************/
3043 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
3044 {
3045    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
3046    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
3047    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
3048
3049    return ROK;
3050 }
3051
3052 /*******************************************************************
3053  *
3054  * @brief Builds scheduling request config
3055  *
3056  * @details
3057  *
3058  *    Function : BuildSchedulingReqConfig
3059  *
3060  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
3061  *
3062  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
3063  *
3064  * @return ROK     - success
3065  *         RFAILED - failure
3066  *
3067  * ****************************************************************/
3068 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
3069 {
3070    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
3071    uint8_t                     idx, elementCnt;
3072
3073    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
3074    DU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
3075          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
3076    if(!schedulingRequestConfig->schedulingRequestToAddModList)
3077    {
3078       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3079       return RFAILED;
3080    }
3081
3082    elementCnt = 1; //ODU_VALUE_ONE;
3083    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
3084    schReqList->list.count = elementCnt;
3085    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
3086
3087    schReqList->list.array = NULLP;
3088    DU_ALLOC(schReqList->list.array, schReqList->list.size);
3089    if(!schReqList->list.array)
3090    {
3091       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3092       return RFAILED;
3093    }
3094
3095    for(idx=0;idx<schReqList->list.count; idx++)
3096    {
3097       schReqList->list.array[idx] = NULLP;
3098       DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
3099       if(!schReqList->list.array[idx])
3100       {
3101          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3102          return RFAILED;
3103       }
3104    }
3105
3106    idx = 0;
3107    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
3108
3109    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
3110    DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
3111    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
3112    {
3113       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3114       return RFAILED;
3115    }
3116    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
3117    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
3118    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
3119
3120    return ROK;
3121 }
3122
3123 /*******************************************************************
3124  *
3125  * @brief Builds RLC Config
3126  *
3127  * @details
3128  *
3129  *    Function : BuildRlcConfig
3130  *
3131  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
3132  *
3133  * @params[in] RLC_Config *rlcConfig
3134  *
3135  * @return ROK     - success
3136  *         RFAILED - failure
3137  *
3138  * ****************************************************************/
3139 uint8_t BuildRlcConfig(struct RLC_Config *rlcConfig)
3140 {
3141
3142    rlcConfig->present = RLC_Config_PR_am;
3143
3144    rlcConfig->choice.am = NULLP;
3145    DU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
3146    if(!rlcConfig->choice.am)
3147    {
3148       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3149       return RFAILED;
3150    }
3151
3152    /* UL */
3153    rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
3154    DU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3155    if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
3156    {
3157       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3158       return RFAILED;
3159    }
3160    *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3161    rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
3162    rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
3163    rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
3164    rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
3165
3166    /* DL */
3167    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
3168    DU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3169    if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
3170    {
3171       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3172       return RFAILED;
3173    }
3174    *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3175    rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
3176    rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
3177
3178    return ROK;
3179 }
3180
3181 /*******************************************************************
3182  *
3183  * @brief Builds MAC LC Config
3184  *
3185  * @details
3186  *
3187  *    Function : BuildMacLCConfig
3188  *
3189  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
3190  *
3191  * @params[in] struct LogicalChannelConfig macLcConfig
3192  *
3193  * @return ROK     - success
3194  *         RFAILED - failure
3195  *
3196  * ****************************************************************/
3197 uint8_t BuildMacLCConfig(struct LogicalChannelConfig *macLcConfig)
3198 {
3199
3200    macLcConfig->ul_SpecificParameters = NULLP;
3201    DU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
3202    if(!macLcConfig->ul_SpecificParameters)
3203    {
3204       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3205       return RFAILED;
3206    }
3207
3208    macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
3209    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     PRIORTISIED_BIT_RATE;
3210    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     BUCKET_SIZE_DURATION;
3211    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
3212    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
3213    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
3214    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
3215
3216    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
3217    DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
3218    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
3219    {
3220       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3221       return RFAILED;
3222    }
3223    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
3224
3225    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
3226    DU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
3227    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
3228    {
3229       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3230       return RFAILED;
3231    }
3232    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
3233
3234    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
3235    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
3236    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
3237
3238    return ROK;
3239 }
3240
3241 /*******************************************************************
3242  *
3243  * @brief Builds RLC Bearer to Add/Mod list
3244  *
3245  * @details
3246  *
3247  *    Function :BuildRlcBearerToAddModList
3248  *
3249  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
3250  *
3251  * @params[in] rlc_BearerToAddModList
3252  *
3253  * @return ROK     - success
3254  *         RFAILED - failure
3255  *
3256  * ****************************************************************/
3257 uint8_t BuildRlcBearerToAddModList(struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
3258 {
3259    uint8_t                     idx, elementCnt;
3260
3261    elementCnt = 1;
3262    rlcBearerList->list.count = elementCnt;
3263    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
3264
3265    rlcBearerList->list.array = NULLP;
3266    DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
3267    if(!rlcBearerList->list.array)
3268    {
3269       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3270       return RFAILED;
3271    }
3272
3273    for(idx=0; idx<rlcBearerList->list.count; idx++)
3274    {
3275       rlcBearerList->list.array[idx] = NULLP;
3276       DU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
3277       if(!rlcBearerList->list.array[idx])
3278       {
3279          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3280          return RFAILED;
3281       }
3282    }
3283
3284    idx = 0;
3285    rlcBearerList->list.array[idx]->logicalChannelIdentity = SRB1_LCID;
3286
3287    DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, \
3288       sizeof(struct RLC_BearerConfig__servedRadioBearer));
3289    if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3290    {
3291       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3292       return RFAILED;
3293    }
3294
3295    rlcBearerList->list.array[idx]->servedRadioBearer->present = \
3296       RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
3297    rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = \
3298       SRB1_LCID;
3299
3300    rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3301    rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3302    DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3303    if(!rlcBearerList->list.array[idx]->rlc_Config)
3304    {
3305       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3306       return RFAILED;
3307    }
3308
3309    if(BuildRlcConfig(rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3310    {
3311       DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3312       return RFAILED;
3313    }
3314
3315    rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3316    DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, \
3317       sizeof(struct LogicalChannelConfig));
3318    if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3319    {
3320       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3321       return RFAILED;
3322    }
3323
3324    if(BuildMacLCConfig(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3325    {
3326       DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3327       return RFAILED;
3328    }
3329
3330    return ROK;
3331 }
3332
3333 /*******************************************************************
3334  *
3335  * @brief Build Control resource set to add/modify list
3336  *
3337  * @details
3338  *
3339  *    Function : BuildControlRSetToAddModList
3340  *
3341  *    Functionality: Build Control resource set to add/modify list
3342  *
3343  * @params[in]
3344  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3345  *
3346  * @return ROK     - success
3347  *         RFAILED - failure
3348  *
3349  * ****************************************************************/
3350    uint8_t BuildControlRSetToAddModList
3351 (
3352  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3353  )
3354 {
3355    uint8_t idx;
3356    uint8_t elementCnt;
3357    uint8_t numBytes, bitsUnused;
3358    struct ControlResourceSet *controlRSet;
3359    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3360    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3361
3362
3363    elementCnt = 1;
3364    controlRSetList->list.count = elementCnt;
3365    controlRSetList->list.size = \
3366                                 elementCnt * sizeof(struct ControlResourceSet *);
3367
3368    controlRSetList->list.array = NULLP;
3369    DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3370    if(!controlRSetList->list.array)
3371    {
3372       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3373       return RFAILED;
3374    }
3375
3376    for(idx = 0; idx < elementCnt; idx++)
3377    {
3378       controlRSetList->list.array[idx] = NULLP;
3379       DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3380       if(!controlRSetList->list.array[idx])
3381       {
3382          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3383          return RFAILED;
3384       }
3385    }
3386
3387    idx=0;
3388    controlRSet = controlRSetList->list.array[idx];
3389
3390    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3391
3392    /* size 6 bytes
3393     * 3 LSBs unsued
3394     * Bit string stored ff0000000000
3395     */
3396    numBytes = 6;
3397    bitsUnused = 3;
3398    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3399
3400    controlRSet->frequencyDomainResources.buf = NULLP;
3401    DU_ALLOC(controlRSet->frequencyDomainResources.buf, \
3402          controlRSet->frequencyDomainResources.size);
3403    if(!controlRSet->frequencyDomainResources.buf)
3404    {
3405       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3406       return RFAILED;
3407    }
3408
3409    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3410    coreset0EndPrb = CORESET0_END_PRB;
3411    coreset1StartPrb = coreset0EndPrb + 6;
3412    coreset1NumPrb = CORESET1_NUM_PRB;
3413    /* calculate the PRBs */
3414    freqDomRscAllocType0(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3415    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3416    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3417
3418    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3419    controlRSet->cce_REG_MappingType.present = \
3420                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3421
3422    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3423    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3424    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3425    controlRSet->tci_PresentInDCI = NULLP;
3426 #if 0
3427    uint8_t tciStateIdx;
3428
3429    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3430          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3431    if(!controlRset->tci_StatesPDCCH_ToAddList)
3432    {
3433       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3434       return RFAILED;
3435    }
3436
3437    elementCnt = 1;
3438    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3439    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3440    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3441          controlRset->tci_StatesPDCCH_ToAddList->list.size)
3442       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3443       {
3444          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3445          return RFAILED;
3446       }
3447
3448    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3449    {
3450       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3451       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3452       {
3453          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3454          return RFAILED;
3455       }
3456    }
3457
3458    tciStateIdx = 0;
3459    /* TODO */
3460    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3461
3462    DU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3463    if(!controlRset->tci_PresentInDCI)
3464    {
3465       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3466       return RFAILED;
3467    }
3468    /* TODO */
3469    *(controlRset->tci_PresentInDCI);
3470 #endif
3471
3472    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3473    DU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3474    if(!controlRSet->pdcch_DMRS_ScramblingID)
3475    {
3476       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3477       return RFAILED;
3478    }
3479    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3480
3481    return ROK;
3482 } /* End BuildControlRSetToAddModList */
3483
3484 /*******************************************************************
3485  *
3486  * @brief Build search space to add/modify list
3487  *
3488  * @details
3489  *
3490  *    Function : BuildSearchSpcToAddModList
3491  *
3492  *    Functionality: Build search space to add/modify list
3493  *
3494  * @params[in]
3495  * @return ROK     - success
3496  *         RFAILED - failure
3497  *
3498  * ****************************************************************/
3499    uint8_t BuildSearchSpcToAddModList
3500 (
3501  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
3502  )
3503 {
3504    uint8_t idx;
3505    uint8_t numBytes;
3506    uint8_t byteIdx;
3507    uint8_t bitsUnused;
3508    uint8_t elementCnt;
3509    struct SearchSpace *searchSpc;
3510
3511    elementCnt = 1;
3512    searchSpcList->list.count = elementCnt;
3513    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3514
3515    searchSpcList->list.array = NULLP;
3516    DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3517    if(!searchSpcList->list.array)
3518    {
3519       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3520       return RFAILED;
3521    }
3522
3523    for(idx = 0; idx < elementCnt; idx++)
3524    {
3525       searchSpcList->list.array[idx] = NULLP;
3526       DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3527       if(!searchSpcList->list.array[idx])
3528       {
3529          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3530          return RFAILED;
3531       }
3532    }
3533
3534    idx = 0;
3535    searchSpc = searchSpcList->list.array[idx];
3536
3537    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3538
3539    searchSpc->controlResourceSetId = NULLP;
3540    DU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3541    if(!searchSpc->controlResourceSetId)
3542    {
3543       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3544       return RFAILED;
3545    }
3546    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3547
3548    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3549    DU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
3550          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3551    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3552    {
3553       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3554       return RFAILED;
3555    }
3556    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
3557                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3558
3559    searchSpc->duration = NULLP;
3560    searchSpc->monitoringSymbolsWithinSlot = NULLP;
3561    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3562    if(!searchSpc->monitoringSymbolsWithinSlot)
3563    {
3564       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3565       return RFAILED;
3566    }
3567
3568    /* Values taken from reference logs :
3569     * size 2 bytes
3570     * 2 LSBs unsued
3571     * Bit string stores 8000
3572     */
3573    numBytes = 2;
3574    bitsUnused = 2;
3575
3576    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3577    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3578    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
3579          searchSpc->monitoringSymbolsWithinSlot->size);
3580    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3581    {
3582       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3583       return RFAILED;
3584    }
3585
3586    byteIdx = 0;
3587    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
3588                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3589    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3590    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3591
3592    searchSpc->nrofCandidates = NULLP;
3593    DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3594    if(!searchSpc->nrofCandidates)
3595    {
3596       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3597       return RFAILED;
3598    }
3599
3600    searchSpc->nrofCandidates->aggregationLevel1 = \
3601                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3602    searchSpc->nrofCandidates->aggregationLevel2 = \
3603                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3604    searchSpc->nrofCandidates->aggregationLevel4 = \
3605                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3606    searchSpc->nrofCandidates->aggregationLevel8 = \
3607                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3608    searchSpc->nrofCandidates->aggregationLevel16 = \
3609                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3610
3611    searchSpc->searchSpaceType = NULLP;
3612    DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3613    if(!searchSpc->searchSpaceType)
3614    {
3615       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3616       return RFAILED;
3617    }
3618
3619    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3620
3621    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3622    DU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
3623          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3624    if(!searchSpc->searchSpaceType->choice.ue_Specific)
3625    {
3626       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3627       return RFAILED;
3628    }
3629    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
3630                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3631
3632    return ROK;
3633 }/* End BuildSearchSpcToAddModList */
3634
3635 /*******************************************************************
3636  *
3637  * @brief Builds BWP DL dedicated PDCCH config
3638  *
3639  * @details
3640  *
3641  *    Function : BuildBWPDlDedPdcchCfg
3642  *
3643  *    Functionality: Builds BWP DL dedicated PDCCH config
3644  *
3645  * @params[in] struct PDCCH_Config *pdcchCfg
3646  *
3647  * @return ROK     - success
3648  *         RFAILED - failure
3649  *
3650  * ****************************************************************/
3651 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
3652 {
3653    pdcchCfg->controlResourceSetToAddModList = NULLP;
3654    DU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
3655          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3656    if(!pdcchCfg->controlResourceSetToAddModList)
3657    {
3658       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3659       return RFAILED;
3660    }
3661
3662    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
3663    {
3664       return RFAILED;
3665    }
3666
3667    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3668
3669    pdcchCfg->searchSpacesToAddModList = NULLP;
3670    DU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3671          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3672    if(!pdcchCfg->searchSpacesToAddModList)
3673    {
3674       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3675       return RFAILED;
3676    }
3677
3678    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3679    {
3680       return RFAILED;
3681    }
3682
3683    pdcchCfg->searchSpacesToReleaseList = NULLP;
3684    pdcchCfg->downlinkPreemption = NULLP;
3685    pdcchCfg->tpc_PUSCH = NULLP;
3686    pdcchCfg->tpc_PUCCH = NULLP;
3687    pdcchCfg->tpc_SRS = NULLP;
3688
3689    return ROK;
3690 }
3691
3692 /*******************************************************************
3693  *
3694  * @brief Builds DMRS DL PDSCH Mapping type A
3695  *
3696  * @details
3697  *
3698  *    Function : BuildDMRSDLPdschMapTypeA
3699  *
3700  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3701  *
3702  * @params[in]
3703  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3704  * @return ROK     - success
3705  *         RFAILED - failure
3706  *
3707  * ****************************************************************/
3708    uint8_t BuildDMRSDLPdschMapTypeA
3709 (
3710  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3711  )
3712 {
3713    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3714    dmrsDlCfg->choice.setup = NULLP;
3715    DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3716    if(!dmrsDlCfg->choice.setup)
3717    {
3718       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3719       return RFAILED;
3720    }
3721
3722    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3723    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3724    DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3725    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3726    {
3727       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3728       return RFAILED;
3729    }
3730    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3731
3732    dmrsDlCfg->choice.setup->maxLength = NULLP;
3733    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3734    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3735    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3736
3737    return ROK;
3738 }
3739
3740 /*******************************************************************
3741  *
3742  * @brief Builds TCI states to add/modify list
3743  *
3744  * @details
3745  *
3746  *    Function : BuildTCIStatesToAddModList
3747  *
3748  *    Functionality:Builds TCI states to add/modify list
3749  *
3750  * @params[in]
3751  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3752  *
3753  * @return ROK     - success
3754  *         RFAILED - failure
3755  *
3756  * ****************************************************************/
3757 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3758 {
3759    return ROK;
3760 }
3761
3762 /*******************************************************************
3763  *
3764  * @brief Builds PDSCH time domain allocation list
3765  *
3766  * @details
3767  *
3768  *    Function : BuildPdschTimeDomAllocList
3769  *
3770  *    Functionality: Builds PDSCH time domain allocation list
3771  *
3772  * @params[in]
3773  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3774  *
3775  * @return ROK     - success
3776  *         RFAILED - failure
3777  *
3778  * ****************************************************************/
3779    uint8_t BuildPdschTimeDomAllocList
3780 (
3781  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3782  )
3783 {
3784    uint8_t idx;
3785    uint8_t elementCnt;
3786    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3787
3788    timeDomAllocList->present = \
3789                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3790
3791    timeDomAllocList->choice.setup = NULLP;
3792    DU_ALLOC(timeDomAllocList->choice.setup, \
3793          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3794    if(!timeDomAllocList->choice.setup)
3795    {
3796       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3797       return RFAILED;
3798    }
3799
3800    elementCnt = 2;
3801    timeDomAllocList->choice.setup->list.count = elementCnt;
3802    timeDomAllocList->choice.setup->list.size = \
3803                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3804
3805    timeDomAllocList->choice.setup->list.array = NULLP;
3806    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3807          timeDomAllocList->choice.setup->list.size);
3808    if(!timeDomAllocList->choice.setup->list.array)
3809    {
3810       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3811       return RFAILED;
3812    }
3813
3814    for(idx = 0; idx < elementCnt; idx++)
3815    {
3816       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3817       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3818             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3819       if(!timeDomAllocList->choice.setup->list.array[idx])
3820       {
3821          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3822          return RFAILED;
3823       }
3824    }
3825
3826    idx = 0;
3827    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3828    DU_ALLOC(timeDomAlloc->k0, sizeof(long));
3829    if(!timeDomAlloc->k0)
3830    {
3831       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3832       return RFAILED;
3833    }
3834    *(timeDomAlloc->k0) = 0;
3835    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3836    timeDomAlloc->startSymbolAndLength = \
3837                                         calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
3838
3839    idx++;
3840    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3841    DU_ALLOC(timeDomAlloc->k0, sizeof(long));
3842    if(!timeDomAlloc->k0)
3843    {
3844       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3845       return RFAILED;
3846    }
3847    *(timeDomAlloc->k0) = 1;
3848    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3849    timeDomAlloc->startSymbolAndLength = calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
3850
3851    return ROK;
3852 }
3853
3854 /*******************************************************************
3855  *
3856  * @brief Builds PDSCH PRB Bundling type
3857  *
3858  * @details
3859  *
3860  *    Function : BuildPdschPrbBundlingType
3861  *
3862  *    Functionality: Builds PDSCH PRB Bundling type
3863  *
3864  * @params[in]
3865  * struct PDSCH_Config__prb_BundlingType *prbBndlType
3866  *
3867  * @return ROK     - success
3868  *         RFAILED - failure
3869  *
3870  * ****************************************************************/
3871    uint8_t BuildPdschPrbBundlingType
3872 (
3873  struct PDSCH_Config__prb_BundlingType *prbBndlType
3874  )
3875 {
3876    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
3877
3878    prbBndlType->choice.staticBundling = NULLP;
3879    DU_ALLOC(prbBndlType->choice.staticBundling, \
3880          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
3881    if(!prbBndlType->choice.staticBundling)
3882    {
3883       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
3884       return RFAILED;
3885    }
3886    prbBndlType->choice.staticBundling->bundleSize = NULLP;
3887
3888    return ROK;
3889 }
3890
3891 /*******************************************************************
3892  *
3893  * @brief Builds BWP DL dedicated PDSCH config
3894  *
3895  * @details
3896  *
3897  *    Function : BuildBWPDlDedPdschCfg
3898  *
3899  *    Functionality: Builds BWP DL dedicated PDSCH config
3900  *
3901  * @params[in] struct PDSCH_Config *pdschCfg
3902  *
3903  * @return ROK     - success
3904  *         RFAILED - failure
3905  *
3906  * ****************************************************************/
3907 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
3908 {
3909    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
3910
3911    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
3912    DU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
3913          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
3914    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
3915    {
3916       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3917       return RFAILED;
3918    }
3919
3920    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
3921    {
3922       return RFAILED;
3923    }
3924
3925    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
3926    pdschCfg->tci_StatesToAddModList = NULLP;
3927    pdschCfg->tci_StatesToReleaseList = NULLP;
3928    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
3929 #if 0
3930    DU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
3931    if(!pdschCfg->tci_StatesToAddModList)
3932    {
3933       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3934       return RFAILED;
3935    }
3936    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
3937    {
3938       return RFAILED;
3939    }
3940 #endif
3941
3942    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
3943
3944    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
3945    DU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
3946          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
3947    if(!pdschCfg->pdsch_TimeDomainAllocationList)
3948    {
3949       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3950       return RFAILED;
3951    }
3952
3953    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
3954    {
3955       return RFAILED;
3956    }
3957
3958    pdschCfg->pdsch_AggregationFactor = NULLP;
3959    pdschCfg->rateMatchPatternToAddModList = NULLP;
3960    pdschCfg->rateMatchPatternToReleaseList = NULLP;
3961    pdschCfg->rateMatchPatternGroup1 = NULLP;
3962    pdschCfg->rateMatchPatternGroup2 = NULLP;
3963    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
3964    pdschCfg->mcs_Table = NULLP;
3965
3966    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
3967    DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
3968    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
3969    {
3970       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3971       return RFAILED;
3972    }
3973    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
3974
3975    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
3976    {
3977       return RFAILED;
3978    }
3979
3980    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
3981    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
3982    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3983    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3984    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3985    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3986    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
3987
3988    return ROK;
3989 }
3990
3991 /*******************************************************************
3992  *
3993  * @brief Builds intitial DL BWP
3994  * @details
3995  *
3996  *    Function : BuildInitialDlBWP
3997  *
3998  *    Functionality: Builds intitial DL BWP in spCellCfgDed
3999  *
4000  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4001  *
4002  * @return ROK     - success
4003  *         RFAILED - failure
4004  *
4005  * ****************************************************************/
4006 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
4007 {
4008    dlBwp->pdcch_Config = NULLP;
4009    DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
4010    if(!dlBwp->pdcch_Config)
4011    {
4012       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4013       return RFAILED;
4014    }
4015    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
4016
4017    dlBwp->pdcch_Config->choice.setup = NULLP;
4018    DU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
4019    if(!dlBwp->pdcch_Config->choice.setup)
4020    {
4021       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4022       return RFAILED;
4023    }
4024    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
4025    {
4026       return RFAILED;
4027    }
4028
4029    dlBwp->pdsch_Config = NULLP;
4030    DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
4031    if(!dlBwp->pdsch_Config)
4032    {
4033       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4034       return RFAILED;
4035    }
4036    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
4037
4038    dlBwp->pdsch_Config->choice.setup = NULLP;
4039    DU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
4040    if(!dlBwp->pdsch_Config->choice.setup)
4041    {
4042       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4043       return RFAILED;
4044    }
4045
4046    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
4047    {
4048       return RFAILED;
4049    }
4050
4051    dlBwp->sps_Config = NULLP;
4052    dlBwp->radioLinkMonitoringConfig = NULLP;
4053    return ROK;
4054 }
4055
4056 /*******************************************************************
4057  *
4058  * @brief Builds DMRS UL Pusch Mapping type A
4059  *
4060  * @details
4061  *
4062  *    Function : BuildDMRSULPuschMapTypeA
4063  *
4064  *    Functionality: Builds DMRS UL Pusch Mapping type A
4065  *
4066  * @params[in]
4067  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4068  * @return ROK     - success
4069  *         RFAILED - failure
4070  *
4071  * ****************************************************************/
4072    uint8_t BuildDMRSULPuschMapTypeA
4073 (
4074  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4075  )
4076 {
4077    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
4078    dmrsUlCfg->choice.setup= NULLP;
4079    DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
4080    if(!dmrsUlCfg->choice.setup)
4081    {
4082       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4083       return RFAILED;
4084    }
4085
4086    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
4087    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
4088    DU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
4089    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4090    {
4091       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4092       return RFAILED;
4093    }
4094    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
4095
4096    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
4097    dmrsUlCfg->choice.setup->maxLength = NULLP;
4098    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
4099    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
4100          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4101    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4102    {
4103       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4104       return RFAILED;
4105    }
4106
4107    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
4108    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4109          sizeof(long));
4110    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
4111    {
4112       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4113       return RFAILED;
4114    }
4115    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
4116
4117    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
4118    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
4119    return ROK;
4120 }
4121
4122 /*******************************************************************
4123  *
4124  * @brief Build PUSCH time domain allocation list
4125  *
4126  * @details
4127  *
4128  *    Function : BuildPuschTimeDomAllocList
4129  *
4130  *    Functionality: Build PUSCH time domain allocation list
4131  *
4132  * @params[in]
4133  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4134  *
4135  * @return ROK     - success
4136  *         RFAILED - failure
4137  *
4138  * ****************************************************************/
4139    uint8_t BuildPuschTimeDomAllocList
4140 (
4141  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4142  )
4143 {
4144    uint8_t idx;
4145    uint8_t elementCnt;
4146    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
4147
4148    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
4149    timeDomAllocList->choice.setup = NULLP;
4150    DU_ALLOC(timeDomAllocList->choice.setup, \
4151          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4152    if(!timeDomAllocList->choice.setup)
4153    {
4154       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4155       return RFAILED;
4156    }
4157
4158    elementCnt = 2;
4159    timeDomAllocList->choice.setup->list.count = elementCnt;
4160    timeDomAllocList->choice.setup->list.size = \
4161                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
4162    timeDomAllocList->choice.setup->list.array = NULLP;
4163    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
4164          timeDomAllocList->choice.setup->list.size);
4165    if(!timeDomAllocList->choice.setup->list.array)
4166    {
4167       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4168       return RFAILED;
4169    }
4170
4171    for(idx = 0; idx < elementCnt; idx++)
4172    {
4173       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4174       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
4175             sizeof(PUSCH_TimeDomainResourceAllocation_t));
4176       if(!timeDomAllocList->choice.setup->list.array[idx])
4177       {
4178          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4179          return RFAILED;
4180       }
4181    }
4182
4183    idx = 0;
4184    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4185    DU_ALLOC(timeDomAlloc->k2, sizeof(long));
4186    if(!timeDomAlloc->k2)
4187    {
4188       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4189       return RFAILED;
4190    }
4191    *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
4192    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4193    timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
4194
4195    idx++;
4196    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4197    DU_ALLOC(timeDomAlloc->k2, sizeof(long));
4198    if(!timeDomAlloc->k2)
4199    {
4200       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4201       return RFAILED;
4202    }
4203    *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
4204    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4205    timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
4206
4207    return ROK;
4208 }
4209
4210 /*******************************************************************
4211  *
4212  * @brief Builds BWP UL dedicated PUSCH Config
4213  *
4214  * @details
4215  *
4216  *    Function : BuildBWPUlDedPuschCfg
4217  *
4218  *    Functionality:
4219  *      Builds BWP UL dedicated PUSCH Config
4220  *
4221  * @params[in] : PUSCH_Config_t *puschCfg
4222  *
4223  * @return ROK     - success
4224  *         RFAILED - failure
4225  *
4226  * ****************************************************************/
4227 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
4228 {
4229    puschCfg->dataScramblingIdentityPUSCH = NULLP;
4230    DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4231    if(!puschCfg->dataScramblingIdentityPUSCH)
4232    {
4233       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4234       return RFAILED;
4235    }
4236    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
4237
4238    puschCfg->txConfig = NULLP;
4239    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4240    DU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4241          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4242    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4243    {
4244       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4245       return RFAILED;
4246    }
4247
4248    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4249    {
4250       return RFAILED;
4251    }
4252
4253    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4254    puschCfg->pusch_PowerControl = NULLP;
4255    puschCfg->frequencyHopping = NULLP;
4256    puschCfg->frequencyHoppingOffsetLists = NULLP;
4257    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4258
4259    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4260    DU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
4261          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4262    if(!puschCfg->pusch_TimeDomainAllocationList)
4263    {
4264       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4265       return RFAILED;
4266    }
4267
4268    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
4269    {
4270       return RFAILED;
4271    }
4272
4273    puschCfg->pusch_AggregationFactor = NULLP;
4274    puschCfg->mcs_Table = NULLP;
4275    puschCfg->mcs_TableTransformPrecoder = NULLP;
4276    puschCfg->transformPrecoder = NULLP;
4277    DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4278    if(!puschCfg->transformPrecoder)
4279    {
4280       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4281       return RFAILED;
4282    }
4283    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4284
4285    puschCfg->codebookSubset = NULLP;
4286    puschCfg->maxRank = NULLP;
4287    puschCfg->rbg_Size = NULLP;
4288    puschCfg->uci_OnPUSCH = NULLP;
4289    puschCfg->tp_pi2BPSK = NULLP;
4290
4291    return ROK;
4292 }
4293
4294 /*******************************************************************
4295  *
4296  * @brief Builds BWP UL dedicated PUCCH Config
4297  *
4298  * @details
4299  *
4300  *    Function : BuildBWPUlDedPucchCfg
4301  *
4302  *    Functionality:
4303  *      Builds BWP UL dedicated PUCCH Config
4304  *
4305  * @params[in] : PUCCH_Config_t *pucchCfg
4306  *
4307  * @return ROK     - success
4308  *         RFAILED - failure
4309  *
4310  * ****************************************************************/
4311 uint8_t BuildBWPUlDedPucchCfg(PUCCH_Config_t *pucchCfg)
4312 {
4313    uint8_t arrIdx, elementCnt;
4314
4315    DU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
4316    if(pucchCfg->dl_DataToUL_ACK == NULLP)
4317    {
4318       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4319       return RFAILED;
4320    }
4321
4322    elementCnt = 2;
4323    pucchCfg->dl_DataToUL_ACK->list.count = elementCnt;
4324    pucchCfg->dl_DataToUL_ACK->list.size = elementCnt * sizeof(long *);
4325    DU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
4326    if(pucchCfg->dl_DataToUL_ACK->list.array == NULLP)
4327    {
4328       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4329       return RFAILED;
4330    }
4331
4332    for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
4333    {
4334       DU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
4335       if(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx] == NULLP)
4336       {
4337           DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4338           return RFAILED;
4339       }
4340    }
4341
4342    arrIdx = 0;
4343    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx++]) = 1;
4344    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx]) = 2;
4345    return ROK;
4346 }
4347
4348 /*******************************************************************
4349  *
4350  * @brief Fills SRS resource to add/modify list
4351  *
4352  * @details
4353  *
4354  *    Function : BuildSrsRsrcAddModList
4355  *
4356  *    Functionality: Fills SRS resource to add/modify list
4357  *
4358  * @params[in]
4359  * @return ROK     - success
4360  *         RFAILED - failure
4361  *
4362  * ****************************************************************/
4363 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
4364 {
4365    uint8_t   elementCnt;
4366    uint8_t   rsrcIdx;
4367
4368    elementCnt = 1;
4369    resourceList->list.count = elementCnt;
4370    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
4371    resourceList->list.array = NULLP;
4372    DU_ALLOC(resourceList->list.array, resourceList->list.size);
4373    if(!resourceList->list.array)
4374    {
4375       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4376       return RFAILED;
4377    }
4378
4379    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4380    {
4381       DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4382       if(!resourceList->list.array[rsrcIdx])
4383       {
4384          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4385          return RFAILED;
4386       }
4387    }
4388
4389    rsrcIdx = 0;
4390    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
4391    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
4392    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
4393
4394    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
4395    DU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
4396          sizeof(struct SRS_Resource__transmissionComb__n2));
4397    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
4398    {
4399       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4400       return RFAILED;
4401    }
4402    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
4403       = SRS_COMB_OFFSET_N2;
4404    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
4405       = SRS_CYCLIC_SHIFT_N2;
4406
4407    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
4408                                                                       PUSCH_START_SYMBOL;
4409    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
4410                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
4411    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
4412                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
4413
4414    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
4415    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
4416    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
4417    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
4418    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
4419    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
4420                                                                SRS_Resource__groupOrSequenceHopping_neither;
4421
4422    /* Setting resource type to aperiodic for intergration purposes */
4423    resourceList->list.array[rsrcIdx]->resourceType.present = \
4424                                                              SRS_Resource__resourceType_PR_aperiodic;
4425    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
4426    DU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
4427          sizeof(struct SRS_Resource__resourceType__aperiodic));
4428    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
4429    {
4430       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4431       return RFAILED;
4432    }
4433    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
4434
4435    return ROK;
4436 }
4437
4438 /*******************************************************************
4439  *
4440  * @brief Build SRS resource set Add/mod list
4441  *
4442  * @details
4443  *
4444  *    Function : BuildSrsRsrcSetAddModList
4445  *
4446  *    Functionality: Build SRS resource set Add/mod list
4447  *
4448  * @params[in]
4449  * @return ROK     - success
4450  *         RFAILED - failure
4451  *
4452  * ****************************************************************/
4453    uint8_t BuildSrsRsrcSetAddModList
4454 (
4455  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
4456  )
4457 {
4458    uint8_t  elementCnt;
4459    uint8_t  rSetIdx;
4460    uint8_t  rsrcIdx;
4461    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
4462
4463    elementCnt = 1;
4464    rsrcSetList->list.count = elementCnt;
4465    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
4466    rsrcSetList->list.array = NULLP;
4467    DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
4468    if(!rsrcSetList->list.array)
4469    {
4470       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4471       return RFAILED;
4472    }
4473
4474    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4475    {
4476       DU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4477       if(!rsrcSetList->list.array[rSetIdx])
4478       {
4479          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4480          return RFAILED;
4481       }
4482    }
4483
4484    rSetIdx = 0;
4485    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
4486
4487    /* Fill Resource Id list in resource set */
4488    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
4489    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4490          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4491    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4492    {
4493       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4494       return RFAILED;
4495    }
4496
4497    elementCnt = 1;
4498    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4499    rsrcIdList->list.count = elementCnt;
4500    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
4501    rsrcIdList->list.array = NULLP;
4502    DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
4503    if(!rsrcIdList->list.array)
4504    {
4505       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4506       return RFAILED;
4507    }
4508
4509    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4510    {
4511       DU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4512       if(!rsrcIdList->list.array[rsrcIdx])
4513       {
4514          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4515          return RFAILED;
4516       }
4517    }
4518
4519    rsrcIdx = 0;
4520    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
4521
4522    /* Fill resource type */
4523    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
4524                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
4525
4526    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
4527    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4528          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4529    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
4530    {
4531       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4532       return RFAILED;
4533    }
4534    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
4535       = APERIODIC_SRS_RESRC_TRIGGER;
4536
4537    /* TODO : Fill values for below IEs as expected by Viavi */
4538    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
4539    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
4540
4541
4542    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
4543    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
4544    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
4545    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
4546    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
4547
4548    return ROK;
4549 }
4550
4551 /*******************************************************************
4552  *
4553  * @brief Builds BWP UL dedicated SRS Config
4554  *
4555  * @details
4556  *
4557  *    Function : BuildBWPUlDedSrsCfg
4558  *
4559  *    Functionality: Builds BWP UL dedicated SRS Config
4560  *
4561  * @params[in] SRS Config
4562  * @return ROK     - success
4563  *         RFAILED - failure
4564  *
4565  * ****************************************************************/
4566 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
4567 {
4568    srsCfg->srs_ResourceSetToReleaseList = NULLP;
4569    srsCfg->srs_ResourceSetToAddModList = NULLP;
4570    DU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
4571          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4572    if(!srsCfg->srs_ResourceSetToAddModList)
4573    {
4574       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4575       return RFAILED;
4576    }
4577    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
4578    {
4579       return RFAILED;
4580    }
4581
4582    srsCfg->srs_ResourceToReleaseList = NULLP;
4583
4584    /* Resource to Add/Modify list */
4585    srsCfg->srs_ResourceToAddModList = NULLP;
4586    DU_ALLOC(srsCfg->srs_ResourceToAddModList, \
4587          sizeof(struct SRS_Config__srs_ResourceToAddModList));
4588    if(!srsCfg->srs_ResourceToAddModList)
4589    {
4590       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4591       return RFAILED;
4592    }
4593
4594    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
4595    {
4596       return RFAILED;
4597    }
4598
4599    srsCfg->tpc_Accumulation = NULLP;
4600
4601    return ROK;
4602 }
4603
4604
4605
4606 /*******************************************************************
4607  *
4608  * @brief Builds Pusch Serving cell Config
4609  *
4610  * @details
4611  *
4612  *    Function : BuildPuschSrvCellCfg
4613  *
4614  *    Functionality: Builds Pusch Serving cell Config
4615  *
4616  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
4617  *
4618  * @return ROK     - success
4619  *         RFAILED - failure
4620  *
4621  * ****************************************************************/
4622 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
4623 {
4624    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
4625    puschCfg->choice.setup = NULLP;
4626    DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4627    if(!puschCfg->choice.setup)
4628    {
4629       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4630       return RFAILED;
4631    }
4632
4633    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4634    puschCfg->choice.setup->rateMatching = NULLP;
4635    puschCfg->choice.setup->xOverhead = NULLP;
4636    puschCfg->choice.setup->ext1 = NULLP;
4637    DU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
4638    if(!puschCfg->choice.setup->ext1)
4639    {
4640       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4641       return RFAILED;
4642    }
4643
4644    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
4645    DU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
4646    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
4647    {
4648       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4649       return RFAILED;
4650    }
4651    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
4652
4653    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
4654    DU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
4655    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
4656    {
4657       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4658       return RFAILED;
4659    }
4660    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
4661    return ROK;
4662 }
4663
4664 /*******************************************************************
4665  *
4666  * @brief Builds inital UL BWP
4667  *
4668  * @details
4669  *
4670  *    Function : BuildInitialUlBWP
4671  *
4672  *    Functionality: Builds initial UL BWP
4673  *
4674  * @params[in] BWP_UplinkDedicated_t *ulBwp
4675  * @return ROK     - success
4676  *         RFAILED - failure
4677  *
4678  * ****************************************************************/
4679 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4680 {
4681    ulBwp->pucch_Config = NULLP;
4682    DU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
4683    if(!ulBwp->pucch_Config)
4684    {
4685       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4686       return RFAILED;
4687    }
4688
4689    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
4690    ulBwp->pucch_Config->choice.setup = NULLP;
4691    DU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
4692    if(!ulBwp->pucch_Config->choice.setup)
4693    {
4694       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4695       return RFAILED;
4696    }
4697
4698    if(BuildBWPUlDedPucchCfg(ulBwp->pucch_Config->choice.setup) != ROK)
4699    {
4700       return RFAILED;
4701    }
4702
4703    /* Fill BWP UL dedicated PUSCH config */
4704    ulBwp->pusch_Config = NULLP;
4705    DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4706    if(!ulBwp->pusch_Config)
4707    {
4708       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4709       return RFAILED;
4710    }
4711
4712    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
4713    ulBwp->pusch_Config->choice.setup = NULLP;
4714    DU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4715    if(!ulBwp->pusch_Config->choice.setup)
4716    {
4717       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4718       return RFAILED;
4719    }
4720
4721    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
4722    {
4723       return RFAILED;
4724    }
4725
4726    ulBwp->configuredGrantConfig = NULLP;
4727
4728    /* Fill BPW UL dedicated SRS config */
4729    ulBwp->srs_Config = NULLP;
4730    DU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4731    if(!ulBwp->srs_Config)
4732    {
4733       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4734       return RFAILED;
4735    }
4736
4737    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
4738    ulBwp->srs_Config->choice.setup = NULLP;
4739    DU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4740    if(!ulBwp->srs_Config->choice.setup)
4741    {
4742       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4743       return RFAILED;
4744    }
4745
4746    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
4747    {
4748       return RFAILED;
4749    }
4750
4751    ulBwp->beamFailureRecoveryConfig = NULLP;
4752
4753    return ROK;
4754 }
4755
4756 /*******************************************************************
4757  *
4758  * @brief Builds UL config
4759  * @details
4760  *
4761  *    Function : BuildUlCfg
4762  *
4763  *    Functionality: Builds UL config in spCellCfgDed
4764  *
4765  * @params[in] UplinkConfig_t *ulCfg
4766  *
4767  * @return ROK     - success
4768  *         RFAILED - failure
4769  *
4770  * ****************************************************************/
4771 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
4772 {
4773    ulCfg->initialUplinkBWP = NULLP;
4774    DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4775    if(!ulCfg->initialUplinkBWP)
4776    {
4777       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4778       return RFAILED;
4779    }
4780
4781    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
4782    {
4783       return RFAILED;
4784    }
4785
4786    ulCfg->uplinkBWP_ToReleaseList = NULLP;
4787    ulCfg->uplinkBWP_ToAddModList = NULLP;
4788    ulCfg->firstActiveUplinkBWP_Id = NULLP;
4789    DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4790    if(!ulCfg->firstActiveUplinkBWP_Id)
4791    {
4792       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4793       return RFAILED;
4794    }
4795    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
4796
4797    ulCfg->pusch_ServingCellConfig = NULLP;
4798    DU_ALLOC(ulCfg->pusch_ServingCellConfig, \
4799          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4800    if(!ulCfg->pusch_ServingCellConfig)
4801    {
4802       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4803       return RFAILED;
4804    }
4805
4806    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
4807    {
4808       return RFAILED;
4809    }
4810
4811    ulCfg->carrierSwitching = NULLP;
4812    ulCfg->ext1 = NULLP;
4813    return ROK;
4814 }
4815
4816 /*******************************************************************
4817  *
4818  * @brief Builds PDSCH serving cell config
4819  * @details
4820  *
4821  *    Function : BuildPdschSrvCellCfg
4822  *
4823  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
4824  *
4825  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
4826  *
4827  * @return ROK     - success
4828  *         RFAILED - failure
4829  *
4830  * ****************************************************************/
4831 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
4832 {
4833    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
4834    pdschCfg->choice.setup = NULLP;
4835    DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
4836    if(!pdschCfg->choice.setup)
4837    {
4838       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4839       return RFAILED;
4840    }
4841
4842    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4843    pdschCfg->choice.setup->xOverhead = NULLP;
4844    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
4845    DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
4846    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
4847    {
4848       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4849       return RFAILED;
4850    }
4851    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
4852    pdschCfg->choice.setup->pucch_Cell = NULLP;
4853    pdschCfg->choice.setup->ext1 = NULLP;
4854
4855    return ROK;
4856 }
4857
4858 /*******************************************************************
4859  *
4860  * @brief Builds CSI Meas config
4861  * @details
4862  *
4863  *    Function : BuildCsiMeasCfg
4864  *
4865  *    Functionality: Builds CSI Meas config in spCellCfgDed
4866  *
4867  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
4868  *
4869  * @return ROK     - success
4870  *         RFAILED - failure
4871  *
4872  * ****************************************************************/
4873 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
4874 {
4875
4876    return ROK;
4877 }
4878
4879 /*******************************************************************
4880  *
4881  * @brief Builds Spcell config dedicated
4882  * @details
4883  *
4884  *    Function : BuildSpCellCfgDed
4885  *
4886  *    Functionality: Builds sp cell config dedicated in spCellCfg
4887  *
4888  * @params[in] ServingCellConfig_t srvCellCfg
4889  *
4890  * @return ROK     - success
4891  *         RFAILED - failure
4892  *
4893  * ****************************************************************/
4894 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
4895 {
4896    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
4897    DU_ALLOC(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
4898    if(!srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
4899    {
4900       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4901       return RFAILED;
4902    }
4903
4904    srvCellCfg->initialDownlinkBWP = NULLP;
4905    DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
4906    if(!srvCellCfg->initialDownlinkBWP)
4907    {
4908       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4909       return RFAILED;
4910    }
4911
4912    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
4913    {
4914       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
4915       return RFAILED;
4916    }
4917    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
4918    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
4919
4920    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
4921    DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
4922    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
4923    {
4924       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4925       return RFAILED;
4926    }
4927    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4928
4929    srvCellCfg->bwp_InactivityTimer = NULLP;
4930
4931    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
4932    DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
4933    if(!srvCellCfg->defaultDownlinkBWP_Id)
4934    {
4935       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4936       return RFAILED;
4937    }
4938    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4939
4940    srvCellCfg->uplinkConfig = NULLP;
4941    DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
4942    if(!srvCellCfg->uplinkConfig)
4943    {
4944       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4945       return RFAILED;
4946    }
4947
4948    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
4949    {
4950       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
4951       return RFAILED;
4952    }
4953    srvCellCfg->supplementaryUplink = NULLP;
4954    srvCellCfg->pdcch_ServingCellConfig = NULLP;
4955
4956    srvCellCfg->pdsch_ServingCellConfig = NULLP;
4957    DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
4958    if(!srvCellCfg->pdsch_ServingCellConfig)
4959    {
4960       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4961       return RFAILED;
4962    }
4963
4964    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
4965    {
4966       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
4967       return RFAILED;
4968    }
4969
4970    srvCellCfg->csi_MeasConfig = NULLP;
4971 #if 0
4972    DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
4973       if(!srvCellCfg->csi_MeasConfig)
4974       {
4975          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4976          return RFAILED;
4977       }
4978
4979    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
4980    {
4981       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
4982       return RFAILED;
4983    }
4984 #endif
4985    srvCellCfg->sCellDeactivationTimer = NULLP;
4986    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
4987    srvCellCfg->tag_Id = TAG_ID;
4988    srvCellCfg->dummy = NULLP;
4989    srvCellCfg->pathlossReferenceLinking = NULLP;
4990    srvCellCfg->servingCellMO = NULLP;
4991    srvCellCfg->ext1 = NULLP;
4992
4993    return ROK;
4994 }
4995 /*******************************************************************
4996  *
4997  * @brief Builds Spcell config
4998  *
4999  * @details
5000  *
5001  *    Function : BuildSpCellCfg
5002  *
5003  *    Functionality: Builds sp cell config in DuToCuRrcContainer
5004  *
5005  * @params[in] SpCellConfig_t spCellCfg
5006  *
5007  * @return ROK     - success
5008  *         RFAILED - failure
5009  *
5010  * ****************************************************************/
5011 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
5012 {
5013
5014    spCellCfg->servCellIndex = NULLP;
5015    DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
5016    if(!spCellCfg->servCellIndex)
5017    {
5018       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5019       return RFAILED;
5020    }
5021    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
5022
5023    spCellCfg->reconfigurationWithSync = NULLP;
5024    spCellCfg->rlf_TimersAndConstants = NULLP;
5025    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
5026    DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5027    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
5028    {
5029       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5030       return RFAILED;
5031    }
5032    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
5033
5034    spCellCfg->spCellConfigDedicated = NULLP;
5035    DU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5036    if(!spCellCfg->spCellConfigDedicated)
5037    {
5038       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5039       return RFAILED;
5040    }
5041    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
5042    {
5043       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
5044       return RFAILED;
5045    }
5046    return ROK;
5047 }
5048 /*******************************************************************
5049  *
5050  * @brief Builds Phy cell group config
5051  *
5052  * @details
5053  *
5054  *    Function : BuildPhyCellGrpCfg
5055  *
5056  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
5057  *
5058  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
5059  *
5060  * @return ROK     - success
5061  *         RFAILED - failure
5062  *
5063  * ****************************************************************/
5064 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
5065 {
5066    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
5067    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
5068
5069    phyCellGrpCfg->p_NR_FR1 = NULLP;
5070    DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5071    if(!phyCellGrpCfg->p_NR_FR1)
5072    {
5073       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
5074       return RFAILED;
5075    }
5076    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
5077    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
5078    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
5079    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
5080    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
5081    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
5082    phyCellGrpCfg->cs_RNTI = NULLP;
5083    phyCellGrpCfg->ext1 = NULLP;
5084    phyCellGrpCfg->ext2 = NULLP;
5085
5086    return ROK;
5087 }
5088 /*******************************************************************
5089  *
5090  * @brief Builds Mac cell group config
5091  *
5092  * @details
5093  *
5094  *    Function : BuildMacCellGrpCfg
5095  *
5096  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
5097  *
5098  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
5099  *
5100  * @return ROK     - success
5101  *         RFAILED - failure
5102  *
5103  * ****************************************************************/
5104 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
5105 {
5106    macCellGrpCfg->drx_Config = NULLP;
5107    macCellGrpCfg->schedulingRequestConfig = NULLP;
5108    DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5109    if(!macCellGrpCfg->schedulingRequestConfig)
5110    {
5111       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5112       return RFAILED;
5113    }
5114
5115    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
5116    {
5117       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
5118       return RFAILED;
5119    }
5120
5121    macCellGrpCfg->bsr_Config = NULLP;
5122    DU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5123    if(!macCellGrpCfg->bsr_Config)
5124    {
5125       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5126       return RFAILED;
5127    }
5128
5129    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
5130    {
5131       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
5132       return RFAILED;
5133    }
5134
5135    macCellGrpCfg->tag_Config = NULLP;
5136    DU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
5137    if(!macCellGrpCfg->tag_Config)
5138    {
5139       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5140       return RFAILED;
5141    }
5142
5143    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
5144    {
5145       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
5146       return RFAILED;
5147    }
5148
5149    macCellGrpCfg->phr_Config = NULLP;
5150    DU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
5151    if(!macCellGrpCfg->phr_Config)
5152    {
5153       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5154       return RFAILED;
5155    }
5156
5157    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
5158    {
5159       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
5160       return RFAILED;
5161    }
5162
5163    macCellGrpCfg->skipUplinkTxDynamic = false;
5164    macCellGrpCfg->ext1 = NULLP;
5165
5166    return ROK;
5167 }
5168 /*******************************************************************
5169  *
5170  * @brief Frees memeory allocated for SearchSpcToAddModList
5171  *
5172  * @details
5173  *
5174  *    Function : FreeSearchSpcToAddModList
5175  *
5176  *    Functionality: Deallocating memory of SearchSpcToAddModList
5177  *
5178  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
5179  *
5180  * @return void
5181  *
5182  4221 * ****************************************************************/
5183 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
5184 {
5185    uint8_t idx1=0;
5186    uint8_t idx2=0;
5187    struct  SearchSpace *searchSpc=NULLP;
5188
5189    if(searchSpcList->list.array)
5190    {
5191       if(searchSpcList->list.array[idx2])
5192       {
5193          searchSpc = searchSpcList->list.array[idx2];
5194          if(searchSpc->controlResourceSetId)
5195          {
5196             if(searchSpc->monitoringSlotPeriodicityAndOffset)
5197             {
5198                if(searchSpc->monitoringSymbolsWithinSlot)
5199                {
5200                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
5201                   {
5202                      if(searchSpc->nrofCandidates)
5203                      {
5204                         if(searchSpc->searchSpaceType)
5205                         {
5206                            DU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
5207                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
5208                            DU_FREE(searchSpc->searchSpaceType, sizeof(struct
5209                                     SearchSpace__searchSpaceType));
5210                         }
5211                         DU_FREE(searchSpc->nrofCandidates,
5212                               sizeof(struct SearchSpace__nrofCandidates));
5213                      }
5214                      DU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
5215                            searchSpc->monitoringSymbolsWithinSlot->size);
5216                   }
5217                   DU_FREE(searchSpc->monitoringSymbolsWithinSlot,
5218                         sizeof(BIT_STRING_t));
5219                }
5220                DU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
5221                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
5222             }
5223             DU_FREE(searchSpc->controlResourceSetId,
5224                   sizeof(ControlResourceSetId_t));
5225          }
5226       }
5227       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
5228       {
5229          DU_FREE(searchSpcList->list.array[idx1],
5230                sizeof(struct SearchSpace));
5231       }
5232       DU_FREE(searchSpcList->list.array,searchSpcList->list.size);
5233    }
5234 }
5235 /*******************************************************************
5236  *
5237  * @brief Frees memory allocated for PdschTimeDomAllocList
5238  *
5239  * @details
5240  *
5241  *    Function : FreePdschTimeDomAllocList
5242  *
5243  *    Functionality: Deallocating memory of PdschTimeDomAllocList
5244  *
5245  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
5246  *
5247  * @return void
5248  *
5249  * ****************************************************************/
5250 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
5251 {
5252    uint8_t idx1=0;
5253
5254    if(timeDomAllocList->choice.setup)
5255    {
5256       if(timeDomAllocList->choice.setup->list.array)
5257       {
5258          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
5259          {
5260             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1]->k0, sizeof(long));
5261             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
5262                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
5263          }
5264          DU_FREE(timeDomAllocList->choice.setup->list.array, \
5265                timeDomAllocList->choice.setup->list.size);
5266       }
5267       DU_FREE(timeDomAllocList->choice.setup,\
5268             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
5269    }
5270 }
5271 /*******************************************************************
5272  *
5273  * @brief Frees memory allocated for PuschTimeDomAllocList
5274  *
5275  *@details
5276  *
5277  *    Function : FreePuschTimeDomAllocList
5278  *
5279  *    Functionality: Deallocating memory of PuschTimeDomAllocList
5280  *
5281  * @params[in] PUSCH_Config_t *puschCfg
5282  *
5283  * @return void
5284  *
5285  * ****************************************************************/
5286 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
5287 {
5288    uint8_t rsrcListIdx=0;
5289    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
5290
5291    if(puschCfg->pusch_TimeDomainAllocationList)
5292    {
5293       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
5294       if(timeDomAllocList_t->choice.setup)
5295       {
5296          if(timeDomAllocList_t->choice.setup->list.array)
5297          {
5298             for(rsrcListIdx = 0; rsrcListIdx<timeDomAllocList_t->choice.setup->list.count; rsrcListIdx++)
5299             {
5300                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx]->k2, sizeof(long));
5301                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx],\
5302                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
5303             }
5304             DU_FREE(timeDomAllocList_t->choice.setup->list.array, \
5305                   timeDomAllocList_t->choice.setup->list.size);
5306          }
5307          DU_FREE(timeDomAllocList_t->choice.setup, \
5308                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
5309       }
5310       DU_FREE(puschCfg->transformPrecoder, sizeof(long));
5311       DU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
5312             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
5313    }
5314
5315 }
5316 /*******************************************************************
5317  *
5318  * @brief Frees memory allocated for InitialUlBWP
5319  *
5320  * @details
5321  *
5322  *    Function : FreeInitialUlBWP
5323  *
5324  *    Functionality: Deallocating memory of InitialUlBWP
5325  *
5326  * @params[in] BWP_UplinkDedicated_t *ulBwp
5327  *
5328  * @return void
5329  *
5330  * ****************************************************************/
5331 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5332 {
5333    uint8_t  rSetIdx, rsrcIdx, k1Idx;
5334    SRS_Config_t   *srsCfg = NULLP;
5335    PUSCH_Config_t *puschCfg = NULLP;
5336    PUCCH_Config_t *pucchCfg = NULLP;
5337    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
5338    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
5339    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
5340    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
5341
5342    if(ulBwp->pucch_Config)
5343    {
5344       if(ulBwp->pucch_Config->choice.setup)
5345       {
5346           pucchCfg = ulBwp->pucch_Config->choice.setup;
5347           if(pucchCfg->dl_DataToUL_ACK)
5348           {
5349              if(pucchCfg->dl_DataToUL_ACK->list.array)
5350              {
5351                 for(k1Idx = 0; k1Idx < pucchCfg->dl_DataToUL_ACK->list.count; k1Idx++)
5352                 {
5353                    DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[k1Idx], sizeof(long));
5354                 }
5355                 DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
5356              }
5357              DU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
5358           }
5359           DU_FREE(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
5360       }
5361       DU_FREE(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
5362    }
5363
5364    if(ulBwp->pusch_Config)
5365    {
5366       if(ulBwp->pusch_Config->choice.setup)
5367       {
5368          puschCfg=ulBwp->pusch_Config->choice.setup;
5369          if(puschCfg->dataScramblingIdentityPUSCH)
5370          {
5371             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
5372             {
5373                FreePuschTimeDomAllocList(puschCfg);
5374                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
5375                if(dmrsUlCfg->choice.setup)
5376                {
5377                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
5378                   {
5379                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
5380                      {
5381                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
5382                               sizeof(long));
5383                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
5384                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
5385                      }
5386                      DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
5387                            sizeof(long));
5388                   }
5389                   DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
5390                }
5391                DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
5392                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
5393             }
5394             DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
5395          }
5396          DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5397       }
5398       DU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5399
5400       /* Free SRS-Config */
5401       if(ulBwp->srs_Config)
5402       {
5403          if(ulBwp->srs_Config->choice.setup)
5404          {
5405             srsCfg = ulBwp->srs_Config->choice.setup;
5406
5407             /* Free Resource Set to add/mod list */
5408             if(srsCfg->srs_ResourceSetToAddModList)
5409             {
5410                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
5411                if(rsrcSetList->list.array)
5412                {
5413                   rSetIdx = 0;
5414
5415                   /* Free SRS resource Id list in this SRS resource set */
5416                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5417                   {
5418                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5419
5420                      if(rsrcIdList->list.array)
5421                      {
5422                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5423                         {
5424                            DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5425                         }
5426                         DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
5427                      }
5428                      DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5429                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5430                   }
5431
5432                   /* Free resource type info for this SRS resource set */
5433                   DU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5434                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5435
5436                   /* Free memory for each resource set */
5437                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5438                   {
5439                      DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5440                   }
5441                   DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
5442                }
5443                DU_FREE(srsCfg->srs_ResourceSetToAddModList, \
5444                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5445             }
5446
5447             /* Free resource to add/modd list */
5448             if(srsCfg->srs_ResourceToAddModList)
5449             {
5450                resourceList = srsCfg->srs_ResourceToAddModList;
5451                if(resourceList->list.array)
5452                {
5453                   rsrcIdx = 0;
5454                   DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
5455                         sizeof(struct SRS_Resource__transmissionComb__n2));
5456                   DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
5457                         sizeof(struct SRS_Resource__resourceType__aperiodic));
5458
5459                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5460                   {
5461                      DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5462                   }
5463                   DU_FREE(resourceList->list.array, resourceList->list.size);
5464                }
5465                DU_FREE(srsCfg->srs_ResourceToAddModList, \
5466                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
5467             }
5468
5469             DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5470          }
5471          DU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5472       }
5473    }
5474 }
5475 /*******************************************************************
5476  *
5477  * @brief Frees memory allocated for initialUplinkBWP
5478  *
5479  * @details
5480  *
5481  *    Function : FreeinitialUplinkBWP
5482  *
5483  *    Functionality: Deallocating memory of initialUplinkBWP
5484  *
5485  * @params[in] UplinkConfig_t *ulCfg
5486  *
5487  * @return void
5488  *
5489  *
5490  * ****************************************************************/
5491 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
5492 {
5493    BWP_UplinkDedicated_t *ulBwp=NULLP;
5494    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
5495
5496    if(ulCfg->initialUplinkBWP)
5497    {
5498       ulBwp=ulCfg->initialUplinkBWP;
5499       if(ulCfg->firstActiveUplinkBWP_Id)
5500       {
5501          if(ulCfg->pusch_ServingCellConfig)
5502          {
5503             puschCfg=ulCfg->pusch_ServingCellConfig;
5504             if(puschCfg->choice.setup)
5505             {
5506                if(puschCfg->choice.setup->ext1)
5507                {
5508                   DU_FREE(puschCfg->choice.setup->ext1->\
5509                         processingType2Enabled,sizeof(BOOLEAN_t));
5510                   DU_FREE(puschCfg->choice.setup->ext1->\
5511                         maxMIMO_Layers,sizeof(long));
5512                   DU_FREE(puschCfg->choice.setup->ext1, \
5513                         sizeof(struct PUSCH_ServingCellConfig__ext1));
5514                }
5515                DU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5516             }
5517             DU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5518          }
5519          DU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5520       }
5521       FreeInitialUlBWP(ulBwp);
5522       DU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5523    }
5524 }
5525 /*******************************************************************
5526  *
5527  * @brief Frees emmory allocated for BWPDlDedPdschCfg
5528  *
5529  * @details
5530  *
5531  *    Function : FreeBWPDlDedPdschCfg
5532  *
5533  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
5534  *
5535  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5536  *
5537  * @return void
5538  *
5539  *
5540  * ****************************************************************/
5541 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
5542 {
5543    struct PDSCH_Config *pdschCfg=NULLP;
5544    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
5545    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
5546    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
5547
5548    if(dlBwp->pdsch_Config->choice.setup)
5549    {
5550       pdschCfg=dlBwp->pdsch_Config->choice.setup;
5551       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
5552       {
5553          if(pdschCfg->pdsch_TimeDomainAllocationList)
5554          {
5555             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
5556             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
5557             {
5558                prbBndlType=&pdschCfg->prb_BundlingType;
5559                DU_FREE(prbBndlType->choice.staticBundling,\
5560                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
5561                DU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
5562             }
5563             FreePdschTimeDomAllocList(timeDomAllocList);
5564             DU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
5565                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
5566          }
5567          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
5568          if(dmrsDlCfg->choice.setup)
5569          {
5570             DU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
5571                   sizeof(long));
5572             DU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
5573          }
5574          DU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
5575                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
5576       }
5577       DU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
5578    }
5579 }
5580 /*******************************************************************
5581  *
5582  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
5583  *
5584  * @details
5585  *
5586  *    Function : FreeBWPDlDedPdcchCfg
5587  *
5588  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
5589  *
5590  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5591  *
5592  * @return void
5593  *
5594  *
5595  * ****************************************************************/
5596 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
5597 {
5598    uint8_t idx1=0;
5599    uint8_t idx2=0;
5600    struct PDCCH_Config *pdcchCfg=NULLP;
5601    struct ControlResourceSet *controlRSet=NULLP;
5602    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
5603
5604    if(dlBwp->pdcch_Config->choice.setup)
5605    {
5606       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
5607       if(pdcchCfg->controlResourceSetToAddModList)
5608       {
5609          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
5610          if(controlRSetList->list.array)
5611          {
5612             controlRSet = controlRSetList->list.array[idx2];
5613             if(controlRSet)
5614             {
5615                if(controlRSet->frequencyDomainResources.buf)
5616                {
5617                   if(controlRSet->pdcch_DMRS_ScramblingID)
5618                   {
5619                      if(pdcchCfg->searchSpacesToAddModList)
5620                      {
5621                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
5622                         DU_FREE(pdcchCfg->searchSpacesToAddModList, \
5623                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
5624                      }
5625                      DU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
5626                   }
5627                   DU_FREE(controlRSet->frequencyDomainResources.buf, \
5628                         controlRSet->frequencyDomainResources.size);
5629                }
5630             }
5631             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
5632             {
5633                DU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
5634             }
5635             DU_FREE(controlRSetList->list.array, controlRSetList->list.size);
5636          }
5637          DU_FREE(pdcchCfg->controlResourceSetToAddModList, \
5638                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
5639       }
5640       DU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
5641    }
5642 }
5643
5644 /*******************************************************************
5645  *
5646  * @brief Frees emmory allocated for DUToCURRCContainer
5647  *
5648  * @details
5649  *
5650  *    Function : FreeMemDuToCuRrcCont
5651  *
5652  *    Functionality: Deallocating memory of DuToCuRrcContainer
5653  *
5654  * @params[in] DuToCuRRCContainer, DuToCuRRCContainer
5655  *
5656  * @return ROK     - success
5657  *         RFAILED - failure
5658  *
5659  * ****************************************************************/
5660 uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg)
5661 {
5662    uint8_t idx=0;
5663    SpCellConfig_t *spCellCfg=NULLP;
5664    ServingCellConfig_t *srvCellCfg=NULLP;
5665    BWP_DownlinkDedicated_t *dlBwp=NULLP;
5666    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
5667    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
5668    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
5669    struct RLC_Config *rlcConfig=NULLP;
5670    struct LogicalChannelConfig *macLcConfig=NULLP;
5671    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
5672    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
5673    struct TAG_Config *tagConfig=NULLP;
5674    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
5675    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
5676    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
5677
5678    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
5679    if(rlcBearerList)
5680    {
5681       if(rlcBearerList->list.array)
5682       {
5683          for(idx=0; idx<rlcBearerList->list.count; idx++)
5684          {
5685             if(rlcBearerList->list.array[idx])
5686             {
5687                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
5688                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
5689                if(rlcConfig)
5690                {
5691                   if(rlcConfig->choice.am)
5692                   {
5693                      DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5694                      DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5695                      DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
5696                   }
5697                   DU_FREE(rlcConfig, sizeof(struct RLC_Config));
5698                }
5699                DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
5700                if(macLcConfig)
5701                {
5702                   if(macLcConfig->ul_SpecificParameters)
5703                   {
5704                      DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
5705                      DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
5706                      DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
5707                   }
5708                   DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
5709                }
5710                DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
5711             }
5712          }
5713          DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
5714       }
5715       DU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5716    }
5717
5718    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
5719    if(macCellGrpCfg)
5720    {
5721       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
5722       if(schedulingRequestConfig)
5723       {
5724          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
5725          if(schReqList)
5726          {
5727             if(schReqList->list.array)
5728             {
5729                for(idx=0;idx<schReqList->list.count; idx++)
5730                {
5731                   if(schReqList->list.array[idx])
5732                   {
5733                      DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
5734                      DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
5735                   }
5736                }
5737                DU_FREE(schReqList->list.array, schReqList->list.size);
5738             }
5739             DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
5740                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
5741             DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5742       }
5743       if(macCellGrpCfg->bsr_Config)
5744       {
5745          DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5746       }
5747       tagConfig = macCellGrpCfg->tag_Config;
5748       if(tagConfig)
5749       {
5750          tagList = tagConfig->tag_ToAddModList;
5751          if(tagList)
5752          {
5753             if(tagList->list.array)
5754             {
5755                for(idx=0; idx<tagList->list.count; idx++)
5756                {
5757                   DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
5758                }
5759                DU_FREE(tagList->list.array, tagList->list.size);
5760             }
5761             DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
5762          }
5763          DU_FREE(tagConfig, sizeof(struct TAG_Config));
5764       }
5765
5766       phrConfig = macCellGrpCfg->phr_Config;
5767       if(phrConfig)
5768       {
5769          DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
5770          DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
5771       }
5772
5773       DU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
5774    }
5775
5776    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
5777    if(phyCellGrpCfg)
5778    {
5779       DU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5780       DU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
5781    }
5782
5783    spCellCfg = cellGrpCfg->spCellConfig;
5784    if(spCellCfg)
5785    {
5786       if(spCellCfg->servCellIndex)
5787       {
5788          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
5789          {
5790             if(spCellCfg->spCellConfigDedicated)
5791             {
5792                srvCellCfg = spCellCfg->spCellConfigDedicated;
5793                if(srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
5794                {
5795                   if(srvCellCfg->initialDownlinkBWP)
5796                   {
5797                      dlBwp = srvCellCfg->initialDownlinkBWP;
5798                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
5799                      {
5800                         if(srvCellCfg->defaultDownlinkBWP_Id)
5801                         {
5802                            if(srvCellCfg->uplinkConfig)
5803                            {
5804                               if(srvCellCfg->pdsch_ServingCellConfig)
5805                               {
5806                                  pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
5807                                  if(pdschCfg->choice.setup)
5808                                  {
5809                                     DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
5810                                     DU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5811                                  }
5812                                  DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
5813                                           ServingCellConfig__pdsch_ServingCellConfig));
5814                               }
5815                               FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
5816                               DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
5817                            }
5818                            DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
5819                         }
5820                         DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
5821                      }
5822                      if(dlBwp->pdcch_Config)
5823                      {
5824                         if(dlBwp->pdsch_Config)
5825                         {
5826                            FreeBWPDlDedPdschCfg(dlBwp);
5827                            DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
5828                         }
5829                         FreeBWPDlDedPdcchCfg(dlBwp);
5830                         DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
5831                      }
5832                      DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
5833                   }
5834                   DU_FREE(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
5835                }
5836                DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5837             }
5838             DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5839          }
5840          DU_FREE(spCellCfg->servCellIndex, sizeof(long));
5841       }
5842       DU_FREE(spCellCfg,sizeof(SpCellConfig_t));
5843    }
5844    return ROK;
5845 }
5846 /*******************************************************************
5847  *
5848  * @brief Builds DU To CU RRC Container
5849  *
5850  * @details
5851  *
5852  *    Function : BuildDuToCuRrcContainer
5853  *
5854  *    Functionality: Builds DuToCuRrcContainer
5855  *
5856  * @params[in] idx, index in F1AP msg
5857  *             DuToCuRRCContainer, DuToCuRRCContainer
5858  *
5859  * @return ROK     - success
5860  *         RFAILED - failure
5861  *
5862  * ****************************************************************/
5863 uint8_t BuildDuToCuRrcContainer(DUtoCURRCContainer_t *duToCuRrcContainer)
5864 {
5865    uint8_t  ret = ROK;
5866    CellGroupConfigRrc_t  cellGrpCfg;
5867    asn_enc_rval_t        encRetVal;
5868    memset(&cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
5869    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
5870
5871    while(true)
5872    {
5873       cellGrpCfg.cellGroupId = CELL_GRP_ID;
5874
5875       cellGrpCfg.rlc_BearerToAddModList = NULLP;
5876       DU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5877       if(!cellGrpCfg.rlc_BearerToAddModList)
5878       {
5879          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5880          ret = RFAILED;
5881          break;
5882       }
5883       if(BuildRlcBearerToAddModList(cellGrpCfg.rlc_BearerToAddModList) != ROK)
5884       {
5885          DU_LOG("\nERROR  -->  F1AP : BuildRlcBearerToAddModList failed");
5886          ret = RFAILED;
5887          break;
5888       }
5889
5890       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
5891       cellGrpCfg.mac_CellGroupConfig = NULLP;
5892       DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
5893       if(!cellGrpCfg.mac_CellGroupConfig)
5894       {
5895          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5896          ret = RFAILED;
5897          break;
5898       }
5899       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
5900       {
5901          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
5902          ret = RFAILED;
5903          break;
5904       }
5905
5906       cellGrpCfg.physicalCellGroupConfig = NULLP;
5907       DU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
5908       if(!cellGrpCfg.physicalCellGroupConfig)
5909       {
5910          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5911          ret = RFAILED;
5912          break;
5913       }
5914       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
5915       {
5916          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
5917          ret = RFAILED;
5918          break;
5919       }
5920
5921       cellGrpCfg.spCellConfig = NULLP;
5922       DU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
5923       if(!cellGrpCfg.spCellConfig)
5924       {
5925          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5926          ret = RFAILED;
5927          break;
5928       }
5929       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
5930       {
5931          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
5932          ret = RFAILED;
5933          break;
5934       }
5935
5936       cellGrpCfg.sCellToAddModList = NULLP;
5937       cellGrpCfg.sCellToReleaseList = NULLP;
5938       cellGrpCfg.ext1 = NULLP;
5939
5940       /* encode cellGrpCfg into duToCuRrcContainer */
5941       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
5942       memset(encBuf, 0, ENC_BUF_MAX_LEN);
5943       encBufSize = 0;
5944       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
5945       /* Encode results */
5946       if(encRetVal.encoded == ENCODE_FAIL)
5947       {
5948          DU_LOG( "\nERROR  --> F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
5949                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5950          ret = RFAILED;
5951          break;
5952       }
5953       else
5954       {
5955          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
5956          for(int i=0; i< encBufSize; i++)
5957          {
5958             printf("%x",encBuf[i]);
5959          }
5960       }
5961
5962       duToCuRrcContainer->size = encBufSize;
5963       DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
5964       if(!duToCuRrcContainer->buf)
5965       {
5966          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
5967          ret = RFAILED;
5968          break;
5969       }
5970       if(ret == ROK)
5971       {
5972          memcpy(duToCuRrcContainer->buf, encBuf, duToCuRrcContainer->size);
5973       }
5974       break;
5975    }
5976    FreeMemDuToCuRrcCont(&cellGrpCfg);
5977    return ret;
5978 }
5979
5980 /*******************************************************************
5981  *
5982  * @brief Free memory allocated in InitialULRRCMessage
5983  *
5984  * @details
5985  *
5986  *    Function : freeInitUlRrcMsgTransfer
5987  *
5988  *    Functionality: Free memory allocated in InitialULRRCMessage
5989  *
5990  * @params[in]F1AP_PDU_t  *f1apMsg)
5991  *
5992  * @return ROK     - success
5993  *         RFAILED - failure
5994  *
5995  * ****************************************************************/
5996
5997 uint8_t freeInitUlRrcMsgTransfer(F1AP_PDU_t  *f1apMsg)
5998 {
5999    uint8_t ieIdx, arrIdx;
6000    InitialULRRCMessageTransfer_t *initULRRCMsg=NULLP;
6001
6002    if(f1apMsg)
6003    {
6004       if(f1apMsg->choice.initiatingMessage)
6005       {
6006          initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.\
6007             choice.InitialULRRCMessageTransfer;
6008          if(initULRRCMsg->protocolIEs.list.array)
6009          {
6010             for(ieIdx = 0; ieIdx < initULRRCMsg->protocolIEs.list.count; ieIdx++)
6011             {
6012                switch(initULRRCMsg->protocolIEs.list.array[ieIdx]->id)
6013                {
6014                   case ProtocolIE_ID_id_NRCGI:
6015                   {
6016                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf)
6017                      {
6018                         if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf)
6019                         {
6020                            DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf,\
6021                            initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.size);
6022                         }
6023                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf,\
6024                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.size);
6025                      }
6026                      break;
6027                   }
6028                   case ProtocolIE_ID_id_RRCContainer:
6029                   {
6030                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
6031                      {
6032                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,\
6033                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
6034                      }
6035                      break;
6036                   }
6037                   case ProtocolIE_ID_id_DUtoCURRCContainer:
6038                   {
6039                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf)
6040                      {
6041                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf,
6042                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.size);
6043                      }
6044                      break;
6045                   }
6046                   default:
6047                      break;
6048                }
6049              }
6050              for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
6051              {
6052                 if(initULRRCMsg->protocolIEs.list.array[arrIdx])
6053                 {
6054                    DU_FREE(initULRRCMsg->protocolIEs.list.array[arrIdx],\
6055                       sizeof(InitialULRRCMessageTransferIEs_t));
6056                 }
6057              }
6058              DU_FREE(initULRRCMsg->protocolIEs.list.array, initULRRCMsg->protocolIEs.list.size);
6059           }
6060          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
6061       }
6062       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
6063    }
6064    else
6065    {
6066       DU_LOG("\nERROR  -->  DU_APP : Recevied F1ap Pdu is null at freeInitUlRrcMsgTransfer()");
6067       return RFAILED;
6068    }
6069    return ROK;
6070 }
6071
6072 /*******************************************************************
6073  *
6074  * @brief Builds and sends the InitialULRRCMessage
6075  *
6076  * @details
6077  *
6078  *    Function : BuildAndSendInitialRrcMsgTransfer
6079  *
6080  *    Functionality: Constructs the Initial UL RRC Message Transfer and sends
6081  *                   it to the CU through SCTP.
6082  *
6083  * @params[in]
6084  *
6085  * @return ROK     - success
6086  *         RFAILED - failure
6087  *
6088  * ****************************************************************/
6089 uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti,
6090       uint16_t rrcContSize, uint8_t *rrcContainer)
6091 {
6092    uint8_t   ret;
6093    uint8_t   elementCnt;
6094    uint8_t   ieIdx;
6095    asn_enc_rval_t  encRetVal;
6096    F1AP_PDU_t  *f1apMsg = NULLP;
6097    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
6098    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
6099
6100    while(true)
6101    {
6102       DU_LOG("\n INFO   -->  F1AP : Building RRC Setup Request\n");
6103       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
6104       if(f1apMsg == NULLP)
6105       {
6106          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
6107          break;
6108       }
6109       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
6110       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
6111       if(f1apMsg->choice.initiatingMessage == NULLP)
6112       {
6113          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
6114          break;
6115       }
6116       f1apMsg->choice.initiatingMessage->procedureCode =\
6117                                                         ProcedureCode_id_InitialULRRCMessageTransfer;
6118       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
6119       f1apMsg->choice.initiatingMessage->value.present = \
6120                                                          InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
6121       initULRRCMsg =\
6122                     &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
6123       elementCnt = 5;
6124       initULRRCMsg->protocolIEs.list.count = elementCnt;
6125       initULRRCMsg->protocolIEs.list.size = \
6126                                             elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *);
6127       /* Initialize the F1Setup members */
6128       DU_ALLOC(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
6129       if(initULRRCMsg->protocolIEs.list.array == NULLP)
6130       {
6131          DU_LOG(" ERROR  -->  F1AP : Memory allocation for\
6132                RRCSetupRequestMessageTransferIEs failed");
6133          break;
6134       }
6135       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
6136       {
6137          DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx],\
6138                sizeof(InitialULRRCMessageTransferIEs_t));
6139          if(initULRRCMsg->protocolIEs.list.array[ieIdx] == NULLP)
6140          {
6141             break;
6142          }
6143       }
6144       ieIdx = 0;
6145       /*GNB DU UE F1AP ID*/
6146       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6147                                                         ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
6148       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  = Criticality_reject;
6149       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
6150                                                                   InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
6151       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
6152
6153
6154       /*NRCGI*/
6155       ieIdx++;
6156       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6157                                                         ProtocolIE_ID_id_NRCGI;
6158       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  =Criticality_reject;
6159       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
6160                                                                   InitialULRRCMessageTransferIEs__value_PR_NRCGI;
6161
6162       ret =\
6163            BuildNrcgi(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
6164       if(ret!=ROK)
6165       {
6166          break;
6167       }
6168
6169       /*CRNTI*/
6170       ieIdx++;
6171       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6172                                                         ProtocolIE_ID_id_C_RNTI;
6173       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6174       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6175                                                                  InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
6176       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.C_RNTI = crnti;
6177
6178       /*RRCContainer*/
6179       ieIdx++;
6180       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6181                                                         ProtocolIE_ID_id_RRCContainer;
6182       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6183       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6184                                                                  InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
6185
6186       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = rrcContSize;
6187       DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
6188             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size)
6189       if(!initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
6190       {
6191          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
6192          break;
6193
6194       }
6195       memcpy(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, rrcContainer,
6196             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
6197
6198
6199       /*DUtoCURRCContainer*/
6200       ieIdx++;
6201       initULRRCMsg->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCContainer;
6202       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6203       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6204                                                                  InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
6205
6206       ret = BuildDuToCuRrcContainer(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer);
6207       if(ret != ROK)
6208       {
6209          break;
6210       }
6211
6212       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
6213
6214       /* Encode the F1SetupRequest type as APER */
6215       memset(encBuf, 0, ENC_BUF_MAX_LEN);
6216       encBufSize = 0;
6217       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
6218       /* Encode results */
6219       if(encRetVal.encoded == ENCODE_FAIL)
6220       {
6221          DU_LOG( "\nERROR  --> F1AP : Could not encode Initial UL RRC Message Transfer\
6222                structure (at %s)\n",encRetVal.failed_type ? \
6223                encRetVal.failed_type->name : "unknown");
6224          ret = RFAILED;
6225          break;
6226       }
6227       else
6228       {
6229
6230          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for Initial UL RRC\
6231                Message transfer\n");
6232          for(int i=0; i< encBufSize; i++)
6233          {
6234             printf("%x",encBuf[i]);
6235          }
6236       }
6237       /* Sending  msg  */
6238       if(sendF1APMsg() != ROK)
6239       {
6240          DU_LOG("\nERROR  -->  F1AP : Sending Initial UL RRC Message Transfer Failed");
6241          ret = RFAILED;
6242          break;
6243       }
6244       break;
6245    }
6246    freeInitUlRrcMsgTransfer(f1apMsg);
6247    return ret;
6248 }/* End of BuildAndSendInitialRrcMsgTransfer*/
6249
6250 /*****  UE SETUP REQUEST *****/
6251
6252 /*******************************************************************
6253  *
6254  * @brief Free Qos And Snssai Drb Info
6255  *
6256  * @details
6257  *
6258  *    Function : freeDrbQosAndSnssaiInfo
6259  *
6260  *    Functionality: Free Qos And Snssai Drb Info
6261  *
6262  * @params[in] LcCfg *lcCfg,
6263  * @return void
6264  *
6265  * ****************************************************************/
6266 void freeDrbQosAndSnssaiInfo(LcCfg *lcCfg)
6267 {
6268    if(lcCfg->snssai)
6269    {
6270       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6271    }
6272    if(lcCfg->drbQos)
6273    {
6274       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
6275    }
6276 }
6277
6278 /******************************************************************
6279 *
6280 * @brief Function to delete the RLC Lc cfg from UE APP DB
6281 *
6282 * @details
6283 *
6284 *  Function : freeRlcLcCfg
6285 *
6286 *  Functionality: Function to delete the RLC Lc cfg from UE APP DB
6287 *
6288 *
6289  *****************************************************************/
6290
6291 void freeRlcLcCfg(RlcBearerCfg *lcCfg)
6292 {
6293    switch(lcCfg->rlcMode)
6294    {
6295       case RLC_AM :
6296          {
6297             if(lcCfg->u.amCfg)
6298             {
6299                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.amCfg, sizeof(AmBearerCfg));
6300             }
6301             break;
6302          }
6303       case RLC_UM_BI_DIRECTIONAL :
6304          {
6305             if(lcCfg->u.umBiDirCfg)
6306             {
6307                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
6308             }
6309             break;
6310          }
6311       case RLC_UM_UNI_DIRECTIONAL_UL :
6312          {
6313             if(lcCfg->u.umUniDirUlCfg)
6314             {
6315                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
6316             }
6317             break;
6318
6319          }
6320       case RLC_UM_UNI_DIRECTIONAL_DL :
6321          {
6322             if(lcCfg->u.umUniDirDlCfg)
6323             {
6324                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
6325             }
6326             break;
6327          }
6328       default:
6329          DU_LOG("\nERROR  -->  DU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
6330          break;
6331    }
6332 }
6333
6334 /*******************************************************************
6335  *
6336  * @brief Function to free MacLcCfg
6337  *
6338  * @details
6339  *
6340  *    Function : freeMacLcCfg
6341  *
6342  *    Functionality: Function to free MacLcCfg
6343  *
6344  * @params[in] LcCfg *lcCfg,
6345  * @return void
6346  *
6347  * ****************************************************************/
6348
6349 void  freeMacLcCfg(LcCfg *lcCfg)
6350 {
6351     /* Deleting DRBQOS */
6352    if(lcCfg->drbQos)
6353    {
6354       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
6355    }
6356    /* Deleting SNSSAI */
6357    if(lcCfg->snssai)
6358    {
6359       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6360    }
6361 }
6362 /*******************************************************************
6363  *
6364  * @brief Free UE NR Capability received in UE Context setup request
6365  *
6366  * @details
6367  *
6368  *    Function : freeAperDecodeUeNrCapability
6369  *
6370  *    Functionality:
6371  *       Free UE NR Capability received in UE Context setup request
6372  *
6373  * @params[in]
6374  * @return ROK     - success
6375  *         RFAILED - failure
6376  *
6377  * ****************************************************************/
6378 void freeAperDecodeUeNrCapability(void *ueNrCapability)
6379 {
6380    uint8_t arrIdx =0;
6381    FeatureSets_t *featureSets =NULLP;
6382    UE_NR_Capability_t *ueNrCap = (UE_NR_Capability_t *)ueNrCapability;
6383
6384    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
6385    {
6386       for(arrIdx = 0; arrIdx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; arrIdx++)
6387       {
6388          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx])
6389             free(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx]);
6390       }
6391       free(ueNrCap->rf_Parameters.supportedBandListNR.list.array);
6392    }
6393
6394    if(ueNrCap->featureSets)
6395    {
6396       featureSets = ueNrCap->featureSets;
6397       if(featureSets->featureSetsDownlinkPerCC)
6398       {
6399          if(featureSets->featureSetsDownlinkPerCC->list.array)
6400          {
6401             for(arrIdx = 0; arrIdx < featureSets->featureSetsDownlinkPerCC->list.count; arrIdx++)
6402             {
6403                if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx])
6404                {
6405                   if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL)
6406                      free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL);
6407                   free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]);
6408                }
6409             }
6410             free(featureSets->featureSetsDownlinkPerCC->list.array);
6411          }
6412          free(featureSets->featureSetsDownlinkPerCC);
6413       }
6414       if(featureSets->featureSetsUplinkPerCC)
6415       {
6416          if(featureSets->featureSetsUplinkPerCC->list.array)
6417          {
6418             for(arrIdx = 0; arrIdx < featureSets->featureSetsUplinkPerCC->list.count; arrIdx++)
6419             {
6420                if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx])
6421                {
6422                   if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL)
6423                      free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL);
6424                   free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]);
6425                }
6426             }
6427             free(featureSets->featureSetsUplinkPerCC->list.array);
6428          }
6429          free(featureSets->featureSetsUplinkPerCC);
6430       }
6431       free(ueNrCap->featureSets);
6432    }
6433 }
6434
6435 /*******************************************************************
6436 *
6437 * @brief Function to free PdcchSearchSpcToAddModList
6438          where memory allocated by aper_decoder
6439 *
6440 * @details
6441 *
6442 *    Function : freeAperDecodePdcchSearchSpcToAddModList
6443 *
6444 *    Functionality: Function to free PdcchSearchSpcToAddModList
6445 *
6446 * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
6447 * @return void
6448 *
6449 * ****************************************************************/
6450
6451 void freeAperDecodePdcchSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
6452 {
6453    uint8_t searchSpcArrIdx=0;
6454    uint8_t searchSpcArrIdx1=0;
6455    struct  SearchSpace *searchSpc=NULLP;
6456
6457
6458    if(searchSpcList->list.array)
6459    {
6460       if(searchSpcList->list.array[searchSpcArrIdx1])
6461       {
6462          searchSpc = searchSpcList->list.array[searchSpcArrIdx1];
6463          if(searchSpc->controlResourceSetId)
6464          {
6465             if(searchSpc->monitoringSlotPeriodicityAndOffset)
6466             {
6467                if(searchSpc->monitoringSymbolsWithinSlot)
6468                {
6469                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
6470                   {
6471                      if(searchSpc->nrofCandidates)
6472                      {
6473                         if(searchSpc->searchSpaceType)
6474                         {
6475                            free(searchSpc->searchSpaceType->choice.ue_Specific);
6476                            free(searchSpc->searchSpaceType);
6477                         }
6478                         free(searchSpc->nrofCandidates);
6479                      }
6480                      free(searchSpc->monitoringSymbolsWithinSlot->buf);
6481                   }
6482                   free(searchSpc->monitoringSymbolsWithinSlot);
6483                }
6484                free(searchSpc->monitoringSlotPeriodicityAndOffset);
6485             }
6486             free(searchSpc->controlResourceSetId);
6487          }
6488       }
6489       for(searchSpcArrIdx = 0; searchSpcArrIdx < searchSpcList->list.count; searchSpcArrIdx++)
6490       {
6491          free(searchSpcList->list.array[searchSpcArrIdx]);
6492       }
6493       free(searchSpcList->list.array);
6494    }
6495 }
6496 /*******************************************************************
6497 *
6498 * @brief Function for free part for the memory allocated by aper_decoder
6499 *
6500 * @details
6501 *
6502 *    Function : freeAperDecodeBWPDlDedPdcchConfig
6503 *
6504 *    Functionality: Function to free BWPDlDedPdcchConfig
6505 *
6506 * @params[in]
6507 * @return void
6508 *
6509 * ****************************************************************/
6510
6511
6512 void freeAperDecodeBWPDlDedPdcchConfig(BWP_DownlinkDedicated_t *dlBwp)
6513 {
6514    uint8_t arrIdx1=0;
6515    uint8_t arrIdx2=0;
6516    struct PDCCH_Config *pdcchCfg=NULLP;
6517    struct ControlResourceSet *controlRSet=NULLP;
6518    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
6519
6520    if(dlBwp->pdcch_Config->choice.setup)
6521    {
6522       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
6523       if(pdcchCfg->controlResourceSetToAddModList)
6524       {
6525          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
6526          if(controlRSetList->list.array)
6527          {
6528             controlRSet = controlRSetList->list.array[arrIdx2];
6529             if(controlRSet)
6530             {
6531                if(controlRSet->frequencyDomainResources.buf)
6532                {
6533                   if(controlRSet->pdcch_DMRS_ScramblingID)
6534                   {
6535                      if(pdcchCfg->searchSpacesToAddModList)
6536                      {
6537                         freeAperDecodePdcchSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
6538                         free(pdcchCfg->searchSpacesToAddModList);
6539                      }
6540                      free(controlRSet->pdcch_DMRS_ScramblingID);
6541                   }
6542                   free(controlRSet->frequencyDomainResources.buf);
6543                }
6544             }
6545             for(arrIdx1 = 0; arrIdx1 <controlRSetList->list.count; arrIdx1++)
6546             {
6547                free(controlRSetList->list.array[arrIdx1]);
6548             }
6549             free(controlRSetList->list.array);
6550          }
6551          free(pdcchCfg->controlResourceSetToAddModList);
6552       }
6553       free(dlBwp->pdcch_Config->choice.setup);
6554    }
6555 }
6556 /*******************************************************************
6557 *
6558 * @brief Function to free PdschTimeDomAllocationList
6559 *     where the memory allocated by aper_decoder
6560 *
6561 * @details
6562 *
6563 *    Function : freeAperDecodePdschTimeDomAllocationList
6564 *
6565 *    Functionality: Function to free PdschTimeDomAllocationList
6566 *
6567 * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
6568 * @return void
6569 *
6570 * ****************************************************************/
6571
6572
6573 void freeAperDecodePdschTimeDomAllocationList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
6574 {
6575    uint8_t arrIdx=0;
6576
6577    if(timeDomAllocList->choice.setup)
6578    {
6579       if(timeDomAllocList->choice.setup->list.array)
6580       {
6581          for(arrIdx = 0; arrIdx <timeDomAllocList->choice.setup->list.count ; arrIdx++)
6582          {
6583             free(timeDomAllocList->choice.setup->list.array[arrIdx]);
6584          }
6585          free(timeDomAllocList->choice.setup->list.array);
6586       }
6587       free(timeDomAllocList->choice.setup);
6588    }
6589 }
6590
6591 /*******************************************************************
6592 *
6593 * @brief Function to free BWPDlDedPdschConfig
6594 *        where the memory allocated by aper_decoder
6595 *
6596 * @details
6597 *
6598 *    Function : freeAperDecodeBWPDlDedPdschConfig
6599 *
6600 *    Functionality: Function to free BWPDlDedPdschConfig
6601 *
6602 * @params[in] BWP_DownlinkDedicated_t *dlBwp
6603 * @return void
6604 *
6605 * ****************************************************************/
6606
6607
6608 void freeAperDecodeBWPDlDedPdschConfig(BWP_DownlinkDedicated_t *dlBwp)
6609 {
6610    struct PDSCH_Config *pdschCfg=NULLP;
6611    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
6612    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
6613    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
6614
6615    if(dlBwp->pdsch_Config->choice.setup)
6616    {
6617       pdschCfg=dlBwp->pdsch_Config->choice.setup;
6618       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
6619       {
6620          if(pdschCfg->pdsch_TimeDomainAllocationList)
6621          {
6622             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
6623             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
6624             {
6625                prbBndlType=&pdschCfg->prb_BundlingType;
6626                free(prbBndlType->choice.staticBundling);
6627                free(pdschCfg->maxNrofCodeWordsScheduledByDCI);
6628             }
6629             freeAperDecodePdschTimeDomAllocationList(timeDomAllocList);
6630             free(pdschCfg->pdsch_TimeDomainAllocationList);
6631          }
6632          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
6633          if(dmrsDlCfg->choice.setup)
6634          {
6635             free(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition);
6636             free(dmrsDlCfg->choice.setup);
6637          }
6638          free(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA);
6639       }
6640       free(dlBwp->pdsch_Config->choice.setup);
6641    }
6642 }
6643 /*******************************************************************
6644 *
6645 * @brief Function to free PuschTimeDomAllocListCfg
6646                  where the memory allocated by aper_decoder
6647 *
6648 * @details
6649 *
6650 *    Function : freeAperDecodePuschTimeDomAllocListCfg
6651 *
6652 *    Functionality: Function to free PuschTimeDomAllocListCfg
6653 *
6654 * @params[in] PUSCH_Config_t *puschCfg
6655 * @return void
6656 *
6657 * ****************************************************************/
6658
6659
6660 void freeAperDecodePuschTimeDomAllocListCfg(PUSCH_Config_t *puschCfg)
6661 {
6662    uint8_t arrIdx=0;
6663    uint8_t arrIdx1=0;
6664    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
6665
6666    if(puschCfg->pusch_TimeDomainAllocationList)
6667    {
6668       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
6669       if(timeDomAllocList_t->choice.setup)
6670       {
6671          if(timeDomAllocList_t->choice.setup->list.array)
6672          {
6673             free(timeDomAllocList_t->choice.setup->list.array[arrIdx1]->k2);
6674             for(arrIdx = 0; arrIdx<timeDomAllocList_t->choice.setup->list.count; arrIdx++)
6675             {
6676                free(timeDomAllocList_t->choice.setup->list.array[arrIdx]);
6677             }
6678             free(timeDomAllocList_t->choice.setup->list.array);
6679          }
6680          free(timeDomAllocList_t->choice.setup);
6681       }
6682       free(puschCfg->transformPrecoder);
6683       free(puschCfg->pusch_TimeDomainAllocationList);
6684    }
6685 }
6686 /*******************************************************************
6687 *
6688 * @brief Function to free InitialUlBWPConfig where memory allocated by aper_decoder
6689 *
6690 * @details
6691 *
6692 *    Function : freeAperDecodeInitialUlBWPConfig
6693 *
6694 *    Functionality: Function to free InitialUlBWPConfig
6695 *
6696 * @params[in]  BWP_UplinkDedicated_t *ulBwp
6697 * @return void
6698 *
6699 * ****************************************************************/
6700
6701
6702 void freeAperDecodeInitialUlBWPConfig(BWP_UplinkDedicated_t *ulBwp)
6703 {
6704    uint8_t  rSetIdx =0;
6705    uint8_t  rsrcIdx =0;
6706    SRS_Config_t   *srsCfg = NULLP;
6707    PUSCH_Config_t *puschCfg = NULLP;
6708    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
6709    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
6710    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
6711    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
6712
6713    if(ulBwp->pusch_Config)
6714    {
6715       if(ulBwp->pusch_Config->choice.setup)
6716       {
6717          puschCfg=ulBwp->pusch_Config->choice.setup;
6718          if(puschCfg->dataScramblingIdentityPUSCH)
6719          {
6720             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
6721             {
6722                freeAperDecodePuschTimeDomAllocListCfg(puschCfg);
6723                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
6724                if(dmrsUlCfg->choice.setup)
6725                {
6726                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
6727                   {
6728                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
6729                      {
6730                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0);
6731                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled);
6732                      }
6733                      free(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition);
6734                   }
6735                   free(dmrsUlCfg->choice.setup);
6736                }
6737                free(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA);
6738             }
6739             free(puschCfg->dataScramblingIdentityPUSCH);
6740          }
6741          free(ulBwp->pusch_Config->choice.setup);
6742       }
6743       free(ulBwp->pusch_Config);
6744
6745       /* Free SRS-Config */
6746       if(ulBwp->srs_Config)
6747       {
6748          if(ulBwp->srs_Config->choice.setup)
6749          {
6750             srsCfg = ulBwp->srs_Config->choice.setup;
6751
6752             /* Free Resource Set to add/mod list */
6753             if(srsCfg->srs_ResourceSetToAddModList)
6754             {
6755                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
6756                if(rsrcSetList->list.array)
6757                {
6758                   rSetIdx = 0;
6759
6760                   /* Free SRS resource Id list in this SRS resource set */
6761                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
6762                   {
6763                      rsrcIdList =
6764                         rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
6765
6766                      if(rsrcIdList->list.array)
6767                      {
6768                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count;
6769                               rsrcIdx++)
6770                         {
6771                            free(rsrcIdList->list.array[rsrcIdx]);
6772                         }
6773                         free(rsrcIdList->list.array);
6774                      }
6775                      free(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList);
6776                   }
6777
6778                   /* Free resource type info for this SRS resource set */
6779
6780                   free(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic);
6781
6782                   /* Free memory for each resource set */
6783                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
6784                   {
6785                      free(rsrcSetList->list.array[rSetIdx]);
6786                   }
6787                   free(rsrcSetList->list.array);
6788                }
6789                free(srsCfg->srs_ResourceSetToAddModList);
6790             }
6791
6792             /* Free resource to add/modd list */
6793             if(srsCfg->srs_ResourceToAddModList)
6794             {
6795                resourceList = srsCfg->srs_ResourceToAddModList;
6796                if(resourceList->list.array)
6797                {
6798                   rsrcIdx = 0;
6799
6800                   free(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2);
6801                   free(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic);
6802
6803                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
6804                   {
6805                      free(resourceList->list.array[rsrcIdx]);
6806                   }
6807                   free(resourceList->list.array);
6808                }
6809                free(srsCfg->srs_ResourceToAddModList);
6810             }
6811
6812             free(ulBwp->srs_Config->choice.setup);
6813          }
6814          free(ulBwp->srs_Config);
6815       }
6816    }
6817 }
6818 /*******************************************************************
6819 *
6820 * @brief Function to free initialUplinkBWPConfig where memory allocated by aper_decoder
6821 *
6822 * @details
6823 *
6824 *    Function : freeAperDecodeinitialUplinkBWPConfig
6825 *
6826 *    Functionality: Function to free initialUplinkBWPConfig
6827 *
6828 * @params[in] UplinkConfig_t *ulCfg
6829 * @return void
6830 *
6831 * ****************************************************************/
6832
6833
6834 void freeAperDecodeinitialUplinkBWPConfig(UplinkConfig_t *ulCfg)
6835 {
6836    BWP_UplinkDedicated_t *ulBwp=NULLP;
6837    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
6838
6839    if(ulCfg->initialUplinkBWP)
6840    {
6841       ulBwp=ulCfg->initialUplinkBWP;
6842       if(ulCfg->firstActiveUplinkBWP_Id)
6843       {
6844          if(ulCfg->pusch_ServingCellConfig)
6845          {
6846             puschCfg=ulCfg->pusch_ServingCellConfig;
6847             if(puschCfg->choice.setup)
6848             {
6849                if(puschCfg->choice.setup->ext1)
6850                {
6851                   free(puschCfg->choice.setup->ext1->processingType2Enabled);
6852                   free(puschCfg->choice.setup->ext1->maxMIMO_Layers);
6853                   free(puschCfg->choice.setup->ext1);
6854                }
6855                free(puschCfg->choice.setup);
6856             }
6857             free(ulCfg->pusch_ServingCellConfig);
6858          }
6859          free(ulCfg->firstActiveUplinkBWP_Id);
6860       }
6861       freeAperDecodeInitialUlBWPConfig(ulBwp);
6862       free(ulCfg->initialUplinkBWP);
6863    }
6864 }
6865
6866 /*******************************************************************
6867  *
6868  * @brief Function to free DuUeCfg
6869  *
6870  * @details
6871  *
6872  *    Function : freeDuUeCfg
6873  *
6874  *    Functionality: Function to free DuUeCfg
6875  *
6876  * @params[in] DuUeCfg *ueCfg
6877  * @return void
6878  *
6879  * ****************************************************************/
6880 void freeDuUeCfg(DuUeCfg *ueCfg)
6881 {
6882    uint8_t lcIdx = 0;
6883    uint8_t arrIdx = 0;
6884    SpCellConfig_t *spCellCfg = NULLP;
6885    ServingCellConfig_t *srvCellCfg = NULLP;
6886    BWP_DownlinkDedicated_t *dlBwp = NULLP;
6887    MAC_CellGroupConfig_t *macCellGrpCfg = NULLP;
6888    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
6889    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList = NULLP;
6890    struct RLC_Config *rlcConfig = NULLP;
6891    struct LogicalChannelConfig *macLcConfig = NULLP;
6892    struct SchedulingRequestConfig *schedulingRequestConfig = NULLP;
6893    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList = NULLP;
6894    struct TAG_Config *tagConfig = NULLP;
6895    struct TAG_Config__tag_ToAddModList *tagList = NULLP;
6896    struct MAC_CellGroupConfig__phr_Config *phrConfig = NULLP;
6897    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg = NULLP;
6898    CellGroupConfigRrc_t *cellGrpCfg = ueCfg->cellGrpCfg;
6899
6900    if(ueCfg->ueNrCapability)
6901    {
6902       freeAperDecodeUeNrCapability(ueCfg->ueNrCapability);
6903       DU_FREE(ueCfg->ueNrCapability, sizeof(UE_NR_Capability_t));
6904       ueCfg->ueNrCapability = NULLP;
6905    }
6906
6907    if(ueCfg->cellGrpCfg)
6908    {
6909
6910       rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6911       if(rlcBearerList)
6912       {
6913          if(rlcBearerList->list.array)
6914          {
6915             for(arrIdx=0; arrIdx<rlcBearerList->list.count; arrIdx++)
6916             {
6917                if(rlcBearerList->list.array[arrIdx])
6918                {
6919                   rlcConfig   = rlcBearerList->list.array[arrIdx]->rlc_Config;
6920                   macLcConfig = rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig;
6921
6922                   if(rlcBearerList->list.array[arrIdx]->servedRadioBearer)
6923                   {
6924                      free(rlcBearerList->list.array[arrIdx]->servedRadioBearer);
6925                   }
6926                   if(rlcConfig)
6927                   {
6928                      if(rlcConfig->choice.am)
6929                      {
6930                         free(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength);
6931                         free(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength);
6932                         free(rlcConfig->choice.am);
6933                      }
6934                      free(rlcBearerList->list.array[arrIdx]->rlc_Config);
6935                   }
6936                   if(macLcConfig)
6937                   {
6938                      if(macLcConfig->ul_SpecificParameters)
6939                      {
6940                         free(macLcConfig->ul_SpecificParameters->schedulingRequestID);
6941                         free(macLcConfig->ul_SpecificParameters->logicalChannelGroup);
6942                         free(macLcConfig->ul_SpecificParameters);
6943                      }
6944                      free(rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig);
6945                   }
6946                   free(rlcBearerList->list.array[arrIdx]);
6947                }
6948             }
6949             free(rlcBearerList->list.array);
6950          }
6951          free(cellGrpCfg->rlc_BearerToAddModList);
6952       }
6953
6954       macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
6955       if(macCellGrpCfg)
6956       {
6957          schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
6958          if(schedulingRequestConfig)
6959          {
6960             schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
6961             if(schReqList)
6962             {
6963                if(schReqList->list.array)
6964                {
6965                   for(arrIdx=0;arrIdx<schReqList->list.count; arrIdx++)
6966                   {
6967                      if(schReqList->list.array[arrIdx])
6968                      {
6969                         free(schReqList->list.array[arrIdx]->sr_ProhibitTimer);
6970                         free(schReqList->list.array[arrIdx]);
6971                      }
6972                   }
6973                   free(schReqList->list.array);
6974                }
6975                free(schedulingRequestConfig->schedulingRequestToAddModList);
6976             }
6977             free(macCellGrpCfg->schedulingRequestConfig);
6978          }
6979          if(macCellGrpCfg->bsr_Config)
6980          {
6981             free(macCellGrpCfg->bsr_Config);
6982          }
6983          tagConfig = macCellGrpCfg->tag_Config;
6984          if(tagConfig)
6985          {
6986             tagList = tagConfig->tag_ToAddModList;
6987             if(tagList)
6988             {
6989                if(tagList->list.array)
6990                {
6991                   for(arrIdx=0; arrIdx<tagList->list.count; arrIdx++)
6992                   {
6993                      free(tagList->list.array[arrIdx]);
6994                   }
6995                   free(tagList->list.array);
6996                }
6997                free(tagConfig->tag_ToAddModList);
6998             }
6999             free(tagConfig);
7000          }
7001
7002          phrConfig = macCellGrpCfg->phr_Config;
7003          if(phrConfig)
7004          {
7005             free(phrConfig->choice.setup);
7006             free(phrConfig);
7007          }
7008
7009          free(macCellGrpCfg);
7010       }
7011
7012       phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
7013       if(phyCellGrpCfg)
7014       {
7015          free(phyCellGrpCfg->p_NR_FR1);
7016          free(phyCellGrpCfg);
7017       }
7018
7019       spCellCfg = cellGrpCfg->spCellConfig;
7020       if(spCellCfg)
7021       {
7022          if(spCellCfg->servCellIndex)
7023          {
7024             if(spCellCfg->rlmInSyncOutOfSyncThreshold)
7025             {
7026                if(spCellCfg->spCellConfigDedicated)
7027                {
7028                   srvCellCfg = spCellCfg->spCellConfigDedicated;
7029                   if(srvCellCfg->initialDownlinkBWP)
7030                   {
7031                      dlBwp = srvCellCfg->initialDownlinkBWP;
7032                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
7033                      {
7034                         if(srvCellCfg->defaultDownlinkBWP_Id)
7035                         {
7036                            if(srvCellCfg->uplinkConfig)
7037                            {
7038
7039                               if(srvCellCfg->pdsch_ServingCellConfig)
7040                               {
7041                                  pdschCfg=
7042                                     srvCellCfg->pdsch_ServingCellConfig;
7043                                  if(pdschCfg->choice.setup)
7044                                  {
7045
7046                                     free(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH);
7047                                     free(pdschCfg->choice.setup);
7048                                  }
7049
7050                                  free(srvCellCfg->pdsch_ServingCellConfig);
7051                               }
7052
7053                               freeAperDecodeinitialUplinkBWPConfig(srvCellCfg->uplinkConfig);
7054                               free(srvCellCfg->uplinkConfig);
7055                            }
7056                            free(srvCellCfg->defaultDownlinkBWP_Id);
7057                         }
7058
7059                         free(srvCellCfg->firstActiveDownlinkBWP_Id);
7060                      }
7061                      if(dlBwp->pdcch_Config)
7062                      {
7063                         if(dlBwp->pdsch_Config)
7064                         {
7065                            freeAperDecodeBWPDlDedPdschConfig(dlBwp);
7066                            free(dlBwp->pdsch_Config);
7067                         }
7068                         freeAperDecodeBWPDlDedPdcchConfig(dlBwp);
7069                         free(dlBwp->pdcch_Config);
7070                      }
7071                      free(srvCellCfg->initialDownlinkBWP);
7072                   }
7073
7074                   free(spCellCfg->spCellConfigDedicated);
7075                }
7076                free(spCellCfg->rlmInSyncOutOfSyncThreshold);
7077             }
7078             free(spCellCfg->servCellIndex);
7079          }
7080          free(spCellCfg);
7081       }
7082       DU_FREE(ueCfg->cellGrpCfg, sizeof(CellGroupConfigRrc_t));
7083       ueCfg->cellGrpCfg = NULLP;
7084    }
7085    if(ueCfg->ambrCfg)
7086    {
7087       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->ambrCfg, sizeof(AmbrCfg));
7088    }
7089    for(lcIdx = 0; lcIdx < ueCfg->numRlcLcs; lcIdx++)
7090    {
7091       freeRlcLcCfg(&ueCfg->rlcLcCfg[lcIdx]);
7092    }
7093    for(lcIdx = 0; lcIdx < ueCfg->numMacLcs; lcIdx++)
7094    {
7095       freeMacLcCfg(&ueCfg->macLcCfg[lcIdx]);
7096    }
7097    for(lcIdx = 0; lcIdx < ueCfg->numDrb; lcIdx++)
7098    {
7099       DU_FREE(ueCfg->upTnlInfo[lcIdx].tnlCfg1, sizeof(GtpTnlCfg));
7100    }
7101 }
7102
7103 /*******************************************************************
7104  *
7105  * @brief Function to free UecontextSetupDb
7106  *
7107  * @details
7108  *
7109  *    Function : freeF1UeDb
7110  *
7111  *    Functionality: Function to free UecontextSetupDb
7112  *
7113  * @params[in] UecontextSetupDb *
7114  * @return void
7115  *
7116  * ****************************************************************/
7117
7118 void freeF1UeDb(F1UeContextSetupDb *f1UeDb)
7119 {
7120
7121    if(f1UeDb->dlRrcMsg)
7122    {
7123       if(f1UeDb->dlRrcMsg->rrcMsgPdu)
7124       {
7125         //DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,\
7126                f1UeDb->dlRrcMsg->rrcMsgPdu, f1UeDb->dlRrcMsg->rrcMsgSize);
7127       }
7128       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
7129    }
7130    freeDuUeCfg(&f1UeDb->duUeCfg);
7131    memset(f1UeDb, 0, sizeof(F1UeContextSetupDb));
7132    DU_FREE(f1UeDb, sizeof(F1UeContextSetupDb));
7133 }
7134
7135 /*******************************************************************
7136  *
7137  * @brief Function to build Am cfg Info
7138  *
7139  * @details
7140  *
7141  *    Function : extractRlcAmCfg
7142  *
7143  *    Functionality: Function to build Am cfg Info
7144  *
7145  * @params[in] AmBearerCfg *
7146  *             void *
7147  *
7148  * @return ROK/RFAILED
7149  *
7150  * ****************************************************************/
7151
7152 void extractRlcAmCfg(AmBearerCfg *amCfgToSet, struct RLC_Config__am *rlcAmCfg)
7153 {
7154    if(rlcAmCfg)
7155    {
7156       /* UL AM */
7157       if(rlcAmCfg->dl_AM_RLC.sn_FieldLength)
7158       {
7159          amCfgToSet->ulAmCfg.snLenUl = *(rlcAmCfg->dl_AM_RLC.sn_FieldLength);
7160          /*TODO: Check the timer value when sent by real CU */
7161          amCfgToSet->ulAmCfg.reAssemTmr = rlcAmCfg->dl_AM_RLC.t_Reassembly;
7162          amCfgToSet->ulAmCfg.statProhTmr = rlcAmCfg->dl_AM_RLC.t_StatusProhibit;
7163       }
7164
7165       /* DL AM */
7166       if(rlcAmCfg->ul_AM_RLC.sn_FieldLength)
7167       {
7168          amCfgToSet->dlAmCfg.snLenDl = *(rlcAmCfg->ul_AM_RLC.sn_FieldLength);
7169          amCfgToSet->dlAmCfg.pollRetxTmr = rlcAmCfg->ul_AM_RLC.t_PollRetransmit;
7170          amCfgToSet->dlAmCfg.pollPdu   = rlcAmCfg->ul_AM_RLC.pollPDU;
7171          amCfgToSet->dlAmCfg.pollByte  = rlcAmCfg->ul_AM_RLC.pollByte;
7172          amCfgToSet->dlAmCfg.maxRetxTh = rlcAmCfg->ul_AM_RLC.maxRetxThreshold;
7173       }
7174    }
7175 }
7176
7177 /*******************************************************************
7178  *
7179  * @brief Function to build Um Bi Info
7180  *
7181  * @details
7182  *
7183  *    Function : extractRlcUmBiCfg
7184  *
7185  *    Functionality: Function to build Um Bi Info
7186  *
7187  * @params[in] UmBiDirBearerCfg *
7188  *             void *
7189  *
7190  * @return ROK/RFAILED
7191  *
7192  * ****************************************************************/
7193
7194 void extractRlcUmBiCfg(UmBiDirBearerCfg *umBiCfgToSet, struct RLC_Config__um_Bi_Directional *rlcBiCfg)
7195 {
7196    if(rlcBiCfg)
7197    {
7198       /* UL UM BI DIR Cfg */
7199       if(rlcBiCfg->dl_UM_RLC.sn_FieldLength)
7200       {
7201          umBiCfgToSet->ulUmCfg.snLenUlUm  = *(rlcBiCfg->dl_UM_RLC.sn_FieldLength);
7202          umBiCfgToSet->ulUmCfg.reAssemTmr = rlcBiCfg->dl_UM_RLC.t_Reassembly;
7203       }
7204
7205       /* DL UM BI DIR Cfg */
7206       if(rlcBiCfg->ul_UM_RLC.sn_FieldLength)
7207          umBiCfgToSet->dlUmCfg.snLenDlUm  = *(rlcBiCfg->ul_UM_RLC.sn_FieldLength);
7208    }
7209 }
7210
7211 /*******************************************************************
7212  *
7213  * @brief Function to build Um Ul Info
7214  *
7215  * @details
7216  *
7217  *    Function : extractRlcUmUlCfg
7218  *
7219  *    Functionality: Function to build Um Ul Info
7220  *
7221  * @params[in] UmUniDirUlBearerCfg *
7222  *             void *
7223  *
7224  * @return ROK/RFAILED
7225  *
7226  * ****************************************************************/
7227
7228 void extractRlcUmUlCfg(UmUniDirUlBearerCfg *umUlCfgToSet, struct RLC_Config__um_Uni_Directional_DL *umUlCfg)
7229 {
7230    if(umUlCfg)
7231    {
7232       if(umUlCfg->dl_UM_RLC.sn_FieldLength)
7233       {
7234          umUlCfgToSet->ulUmCfg.snLenUlUm  = *(umUlCfg->dl_UM_RLC.sn_FieldLength);
7235          umUlCfgToSet->ulUmCfg.reAssemTmr = umUlCfg->dl_UM_RLC.t_Reassembly;
7236       }
7237    }
7238 }
7239
7240 /*******************************************************************
7241  *
7242  * @brief Function to build Um Uni Dl Info
7243  *
7244  * @details
7245  *
7246  *    Function : extractRlcUmDlCfg
7247  *
7248  *    Functionality: Function to build Um Uni Dl Info
7249  *
7250  * @params[in] UmUniDirDlBearerCfg *
7251  *             void *
7252  *
7253  * @return ROK/RFAILED
7254  *
7255  * ****************************************************************/
7256 void extractRlcUmDlCfg(UmUniDirDlBearerCfg *umDlCfgToSet, struct RLC_Config__um_Uni_Directional_UL *umDlCfg)
7257 {
7258    if(umDlCfg)
7259    {
7260       if(umDlCfg->ul_UM_RLC.sn_FieldLength)
7261          umDlCfgToSet->dlUmCfg.snLenDlUm  = *(umDlCfg->ul_UM_RLC.sn_FieldLength);
7262    }
7263 }
7264
7265 /*******************************************************************
7266  *
7267  * @brief Function to extractRlcModeCfg
7268  *
7269  * @details
7270  *
7271  *    Function : extractRlcModeCfg
7272  *
7273  *    Functionality: Function to extractRlcModeCfg
7274  *
7275  * @params[in] RLC_Config_t *
7276  *             RlcBearerCfg *
7277  *             void  *
7278  * @return ROK/RFAILED
7279  *
7280  * ****************************************************************/
7281 void extractRlcModeCfg(uint8_t rlcMode, RlcBearerCfg *rlcDbCfg, RLC_Config_t *lcCfg)
7282 {
7283    if(lcCfg)
7284    {
7285       switch(rlcMode)
7286       {
7287          case RLC_AM :
7288             {
7289                if(lcCfg->choice.am)
7290                {
7291                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.amCfg, sizeof(AmBearerCfg));
7292                   if(rlcDbCfg->u.amCfg)
7293                      extractRlcAmCfg(rlcDbCfg->u.amCfg, lcCfg->choice.am);
7294                }
7295                break;
7296             }
7297          case RLC_UM_BI_DIRECTIONAL :
7298             {
7299                if(lcCfg->choice.um_Bi_Directional)
7300                {
7301                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
7302                   if(rlcDbCfg->u.umBiDirCfg)
7303                      extractRlcUmBiCfg(rlcDbCfg->u.umBiDirCfg, lcCfg->choice.um_Bi_Directional);
7304                }
7305                break;
7306             }
7307          case RLC_UM_UNI_DIRECTIONAL_UL :
7308             {
7309                if(lcCfg->choice.um_Uni_Directional_DL)
7310                {
7311                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
7312                   if(rlcDbCfg->u.umUniDirUlCfg)
7313                      extractRlcUmUlCfg(rlcDbCfg->u.umUniDirUlCfg, lcCfg->choice.um_Uni_Directional_DL);
7314                }
7315                break;
7316             }
7317          case RLC_UM_UNI_DIRECTIONAL_DL :
7318             {
7319                if(lcCfg->choice.um_Uni_Directional_UL)
7320                {
7321                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
7322                   if(rlcDbCfg->u.umUniDirDlCfg)
7323                      extractRlcUmDlCfg(rlcDbCfg->u.umUniDirDlCfg, lcCfg->choice.um_Uni_Directional_UL);
7324                }
7325                break;
7326             }
7327          default:
7328             DU_LOG("\nERROR  -->  DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
7329             break;
7330       }
7331    }
7332 }
7333
7334 /*******************************************************************
7335  *
7336  * @brief Function to extract extractUlLcCfg
7337  *
7338  * @details
7339  *
7340  *    Function : extractUlLcCfg
7341  *
7342  *    Functionality: Function to extract extractUlLcCfg
7343  *
7344  * @params[in] UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg
7345  * @return void
7346  *
7347  * ****************************************************************/
7348
7349 void extractUlLcCfg(UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg)
7350 {
7351    if(ulLcCfg)
7352    {
7353       if(ulLcCfg->ul_SpecificParameters)
7354       {
7355          f1UlLcCfg->priority = \
7356             ulLcCfg->ul_SpecificParameters->priority;
7357       if(ulLcCfg->ul_SpecificParameters->logicalChannelGroup)
7358       {
7359          f1UlLcCfg->lcGroup = \
7360            *(ulLcCfg->ul_SpecificParameters->logicalChannelGroup);
7361       }
7362       if(ulLcCfg->ul_SpecificParameters->schedulingRequestID)
7363       {
7364          f1UlLcCfg->schReqId = \
7365            *(ulLcCfg->ul_SpecificParameters->schedulingRequestID);
7366       }
7367       f1UlLcCfg->pbr = \
7368          ulLcCfg->ul_SpecificParameters->prioritisedBitRate;
7369       f1UlLcCfg->bsd = \
7370          ulLcCfg->ul_SpecificParameters->bucketSizeDuration;
7371       }
7372    }
7373 }
7374
7375 /*******************************************************************
7376  *
7377  * @brief Function to procRlcLcCfg
7378  *
7379  * @details
7380  *
7381  *    Function : procRlcLcCfg
7382  *
7383  *    Functionality: Function to procRlcLcCfg
7384  *
7385  * @params[in] rbId, lcId, rbType, rlcMod
7386  *             RLC_Config_t *, RlcBearerCfg * ,
7387  * @return void
7388  *
7389  * ****************************************************************/
7390
7391 void procRlcLcCfg(uint8_t rbId, uint8_t lcId, uint8_t rbType, uint8_t rlcMode,\
7392    uint8_t configType, RLC_Config_t *f1RlcCfg, RlcBearerCfg *lcCfg)
7393 {
7394
7395    lcCfg->rbId   = rbId;
7396    lcCfg->configType = configType;
7397
7398    if(rbType == RB_TYPE_SRB)
7399    {
7400       lcCfg->rbType = RB_TYPE_SRB;
7401       lcCfg->lcId   = rbId;
7402       lcCfg->lcType = LCH_DCCH;
7403       lcCfg->rlcMode = RLC_AM;
7404    }
7405    else if(rbType == RB_TYPE_DRB)
7406    {
7407       lcCfg->rbType = RB_TYPE_DRB;
7408       lcCfg->lcId   = lcId;
7409       lcCfg->lcType = LCH_DTCH;
7410       lcCfg->rlcMode = rlcMode;
7411    }
7412    if(f1RlcCfg) /* rlc mode config recived */
7413    {
7414       extractRlcModeCfg(lcCfg->rlcMode, lcCfg, f1RlcCfg);
7415    }
7416 }
7417
7418
7419
7420 /*******************************************************************
7421  *
7422  * @brief Fills DrbQos Info received by CU
7423  *
7424  * @details
7425  *
7426  *    Function : extractQosInfo
7427  *
7428  *    Functionality: Fills DrbQos Info received  by CU
7429  *
7430  * @params[in] DrbQosInfo *qosToAdd,
7431  *             QoSFlowLevelQoSParameters_t *qosFlowCfg
7432  * @return void
7433  *
7434  * ****************************************************************/
7435
7436 void extractQosInfo(DrbQosInfo *qosToAdd, QoSFlowLevelQoSParameters_t *qosFlowCfg)
7437 {
7438    qosToAdd->fiveQiType = qosFlowCfg->qoS_Characteristics.present;
7439    qosToAdd->u.nonDyn5Qi.fiveQi     =\
7440          qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
7441    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow)
7442    {
7443       qosToAdd->u.nonDyn5Qi.avgWindow = \
7444         *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
7445    }
7446    qosToAdd->u.nonDyn5Qi.maxDataBurstVol = \
7447       *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
7448    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel)
7449    {
7450       qosToAdd->u.nonDyn5Qi.priorLevel = \
7451          *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel);
7452    }
7453    qosToAdd->ngRanRetPri.priorityLevel = \
7454       qosFlowCfg->nGRANallocationRetentionPriority.priorityLevel;
7455    qosToAdd->ngRanRetPri.preEmptionCap = \
7456       qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionCapability;
7457    qosToAdd->ngRanRetPri.preEmptionVul = \
7458       qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionVulnerability;
7459    if(qosFlowCfg->gBR_QoS_Flow_Information)
7460    {
7461       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateDl, \
7462          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.buf, \
7463          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.size);
7464       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateUl, \
7465          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.buf, \
7466          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.size);
7467       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateDl,\
7468          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.buf, \
7469          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.size);
7470       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateUl,\
7471          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.buf, \
7472          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.size);
7473    }
7474    qosToAdd->pduSessionId = 0;
7475    qosToAdd->ulPduSessAggMaxBitRate = 0;
7476 }
7477
7478 /*******************************************************************
7479  *
7480  * @brief Function to extract GTP Tunnel Info from CU
7481  *
7482  * @details
7483  *
7484  *    Function : extractUpTnlInfo
7485  *
7486  *    Functionality: Function to extract GTP Tunnel Info from CU
7487  *
7488  * @params[in] F1AP message
7489  * @return ROK/RFAILED
7490  *
7491  * ****************************************************************/
7492
7493 uint8_t extractUpTnlInfo(uint8_t drbId, uint8_t configType,\
7494    ULUPTNLInformation_ToBeSetup_List_t *tnlInfo, UpTnlCfg *upTnlInfo)
7495 {
7496    uint8_t tnlIdx;
7497    uint32_t ipv4_du = 0;
7498    GTPTunnel_t *gtpTunnel = NULLP;
7499
7500    upTnlInfo->drbId = drbId;
7501    upTnlInfo->configType = configType;
7502 #ifdef O1_ENABLE
7503    cmInetAddr((S8*)g_cfg.DU_IPV4_Addr, &ipv4_du);
7504 #else
7505    cmInetAddr((char *)DU_IP_V4_ADDR, &ipv4_du);
7506 #endif
7507
7508    for(tnlIdx=0; tnlIdx < tnlInfo->list.count; tnlIdx++)
7509    {
7510       if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
7511       {
7512          if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel)
7513          {
7514             gtpTunnel = tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel;
7515             DU_ALLOC(upTnlInfo->tnlCfg1, sizeof(GtpTnlCfg));
7516             if(upTnlInfo->tnlCfg1 == NULLP)
7517             {
7518                DU_LOG("\nERROR  -->  F1AP : extractUpTnlInfo: Failed to allocate mmeory for tunnel cfg 1");
7519                return RFAILED;
7520             }
7521             bitStringToInt(&gtpTunnel->transportLayerAddress, &upTnlInfo->tnlCfg1->ulTnlAddress);
7522             upTnlInfo->tnlCfg1->dlTnlAddress = ipv4_du;
7523             if(gtpTunnel->gTP_TEID.size > 0)
7524             {
7525                teIdStringToInt(gtpTunnel->gTP_TEID.buf, &upTnlInfo->tnlCfg1->teId);
7526             }
7527          }
7528          break;
7529       }
7530    }
7531    return ROK;
7532 }
7533 /*******************************************************************
7534 *
7535 * @brief Function to extract Drb Qos Cfg Info from CU
7536 *
7537 * @details
7538 *
7539 *    Function : extractDrbQosCfg
7540 *
7541 *    Functionality: Function to extract Drb Qos Cfg Info from CU
7542 *
7543 * @params[in] DRB_Information_t *drbInfo, LcCfg *macLcToAdd
7544 * @return ROK/RFAILED
7545 *
7546 * ****************************************************************/
7547
7548 uint8_t extractDrbQosCfg(DRB_Information_t *drbInfo, LcCfg *macLcToAdd )
7549 {
7550    if(!macLcToAdd->drbQos)
7551    {
7552       DU_ALLOC_SHRABL_BUF(macLcToAdd->drbQos, sizeof(DrbQosInfo));
7553       if(macLcToAdd->drbQos == NULLP)
7554       {
7555          DU_LOG("\nERROR  -->  DUAPP:Memory failed at allocating DrbQos at extractDrbQosCfg()");
7556          return RFAILED;
7557       }
7558
7559    }
7560    if(drbInfo->dRB_QoS.qoS_Characteristics.present == QoS_Characteristics_PR_non_Dynamic_5QI)
7561    {
7562       extractQosInfo(macLcToAdd->drbQos, &drbInfo->dRB_QoS);
7563       macLcToAdd->dlLcCfg.lcp = macLcToAdd->drbQos->ngRanRetPri.priorityLevel;
7564    }
7565    if(!macLcToAdd->snssai)
7566    {
7567       DU_ALLOC_SHRABL_BUF(macLcToAdd->snssai, sizeof(Snssai));
7568       if(macLcToAdd->snssai == NULLP)
7569       {
7570          DU_LOG("\nERROR  -->  DUAPP : Memory failed at allocating SNSSAI at extractDrbQosCfg()");
7571          return RFAILED;
7572       }
7573    }
7574    memcpy(&macLcToAdd->snssai->sst, drbInfo->sNSSAI.sST.buf, \
7575          drbInfo->sNSSAI.sST.size);
7576    if(drbInfo->sNSSAI.sD)
7577    {
7578       memcpy(macLcToAdd->snssai->sd, drbInfo->sNSSAI.sD->buf, \
7579             drbInfo->sNSSAI.sD->size);
7580    }
7581    return ROK;
7582 }
7583 /*******************************************************************
7584  *
7585  * @brief Function to extract DRB info received from CU
7586  *
7587  * @details
7588  *
7589  *    Function : extractDrbCfg
7590  *
7591  *    Functionality: Function to extract DRB info received from CU
7592  *
7593  * @params[in] F1AP message
7594  * @return void
7595  *
7596  * ****************************************************************/
7597 uint8_t extractDrbCfg(DRBs_ToBeSetup_Item_t *drbItem, DRBs_ToBeSetupMod_Item_t *drbSetupModItem,\
7598 DRBs_ToBeModified_Item_t *drbModItem,  LcCfg *macLcToAdd, UpTnlCfg *upTnlInfo)
7599 {
7600    DRB_Information_t *drbInfo = NULLP;
7601
7602    if(drbItem != NULLP)
7603    {
7604       if(extractUpTnlInfo(drbItem->dRBID, CONFIG_ADD, &drbItem->uLUPTNLInformation_ToBeSetup_List, upTnlInfo) != ROK)
7605       {
7606          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7607          return RFAILED;
7608       }
7609       if(drbItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7610       {
7611          if(drbItem->qoSInformation.choice.choice_extension->value.present == QoSInformation_ExtIEs__value_PR_DRB_Information)
7612          {
7613             drbInfo = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7614             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7615             {
7616                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7617                return RFAILED;
7618             }
7619          }
7620       }
7621    }
7622    else if(drbSetupModItem != NULLP)
7623    {
7624       if(extractUpTnlInfo(drbSetupModItem->dRBID, CONFIG_ADD, &drbSetupModItem->uLUPTNLInformation_ToBeSetup_List,\
7625       upTnlInfo) != ROK)
7626       {
7627          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7628          return RFAILED;
7629       }
7630       if(drbSetupModItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7631       {
7632          if(drbSetupModItem->qoSInformation.choice.choice_extension->value.present ==\
7633          QoSInformation_ExtIEs__value_PR_DRB_Information)
7634          {
7635             drbInfo = &drbSetupModItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7636             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7637             {
7638                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7639                return RFAILED;
7640             }
7641
7642          }
7643       }
7644    }
7645    else if(drbModItem != NULLP)
7646    {
7647       if(extractUpTnlInfo(drbModItem->dRBID, CONFIG_MOD, &drbModItem->uLUPTNLInformation_ToBeSetup_List,\
7648       upTnlInfo) != ROK)
7649       {
7650          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7651          return RFAILED;
7652       }
7653       if(drbModItem->qoSInformation != NULLP)
7654       {
7655          if(drbModItem->qoSInformation->present == QoSInformation_PR_choice_extension)
7656          {
7657             if(drbModItem->qoSInformation->choice.choice_extension->value.present ==\
7658                   QoSInformation_ExtIEs__value_PR_DRB_Information)
7659             {
7660                drbInfo = &drbModItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information;
7661                if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7662                {
7663                   DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7664                   return RFAILED;
7665                }
7666
7667             }
7668          }
7669       }
7670    }
7671    return ROK;
7672 }
7673
7674 /*******************************************************************
7675  *
7676  * @brief Function to extract RB info received from CU
7677  *
7678  * @details
7679  *
7680  *    Function : extractMacRbCfg
7681  *
7682  *    Functionality: Function to extract RB info received from CU
7683  *
7684  * @params[in] F1AP message
7685  * @return ROK/RFAILED
7686  *
7687  * ****************************************************************/
7688
7689 uint8_t extractMacRbCfg(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbCfg,\
7690 DRBs_ToBeSetupMod_Item_t *drbSetupModCfg,  DRBs_ToBeModified_Item_t *drbModCfg, LogicalChannelConfig_t *ulLcCfg, LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7691 {
7692    if(drbCfg != NULLP)
7693    {
7694       if(extractDrbCfg(drbCfg, NULL, NULL, lcCfg, upTnlInfo) != ROK)
7695       {
7696          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7697          return RFAILED;
7698       }
7699    }
7700    else if(drbSetupModCfg != NULLP)
7701    {
7702       if(extractDrbCfg(NULL, drbSetupModCfg, NULL, lcCfg, upTnlInfo) != ROK)
7703       {
7704          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7705          return RFAILED;
7706       }
7707    }
7708    else if(drbModCfg != NULLP)
7709    {
7710       if(extractDrbCfg(NULL, NULL, drbModCfg, lcCfg, upTnlInfo) != ROK)
7711       {
7712          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7713          return RFAILED;
7714       }
7715    }
7716    else
7717    {
7718       lcCfg->drbQos = NULLP;
7719       lcCfg->snssai = NULLP;
7720       if(lcCfg->lcId == SRB2_LCID)
7721          lcCfg->dlLcCfg.lcp = LC_PRIORITY_3;
7722       else
7723          lcCfg->dlLcCfg.lcp = LC_PRIORITY_1;
7724    }
7725    if(ulLcCfg)
7726    {
7727       lcCfg->ulLcCfgPres = true;
7728       extractUlLcCfg(&lcCfg->ulLcCfg, ulLcCfg);
7729    }
7730    else
7731       lcCfg->ulLcCfgPres = false;
7732    return ROK;
7733 }
7734
7735 /*******************************************************************
7736  *
7737  * @brief Function processing LC config info received from CU
7738  *
7739  * @details
7740  *
7741  *    Function : procMacLcCfg
7742  *
7743  *    Functionality: Function processing LC config info received from CU
7744  *
7745  * @params[in] F1AP message
7746  * @return ROK/RFAILED
7747  *
7748  * ****************************************************************/
7749
7750 uint8_t procMacLcCfg(uint8_t lcId, uint8_t rbType, uint8_t configType, DRBs_ToBeSetup_Item_t *drbItem,\
7751 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, LogicalChannelConfig_t *ulLcCfg,\
7752 LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7753 {
7754    uint8_t ret = ROK;
7755
7756    lcCfg->lcId = lcId;
7757    lcCfg->configType = configType;
7758    if(rbType == RB_TYPE_SRB)
7759    {
7760       ret = extractMacRbCfg(lcId, NULL, NULL, NULL, ulLcCfg, lcCfg, NULL);
7761    }
7762    else if(rbType == RB_TYPE_DRB)
7763    {
7764       if(drbItem != NULL)
7765         ret = extractMacRbCfg(lcId, drbItem, NULL, NULL, ulLcCfg, lcCfg, upTnlInfo);
7766       else if(drbSetupModItem != NULL)
7767         ret = extractMacRbCfg(lcId, NULL, drbSetupModItem, NULL, ulLcCfg, lcCfg, upTnlInfo);
7768       else if(drbModItem != NULL)
7769         ret = extractMacRbCfg(lcId, NULL, NULL, drbModItem, ulLcCfg, lcCfg, upTnlInfo);
7770    }
7771    return ret;
7772 }
7773
7774 /*******************************************************************
7775  *
7776  * @brief Function to extract Rlc cfg To Add/Mod in CellGrp Info
7777  *
7778  * @details
7779  *
7780  *    Function : extractRlcCfgToAddMod
7781  *
7782  *    Functionality: Function to extract Rlc cfg To Add/Mod in CellGrp Info
7783  *
7784  * @params[in] CellGroupConfigRrc__rlc_BearerTo pointer
7785  *             DuUeCfg Pointer
7786  * @return ROK/RFAILED
7787  *
7788  * ****************************************************************/
7789
7790 uint8_t extractRlcCfgToAddMod(struct CellGroupConfigRrc__rlc_BearerToAddModList *lcCfg, DuUeCfg *ueCfgDb)
7791 {
7792   uint8_t idx, rbId, lcId, rlcMode, rbType;
7793   RLC_Config_t *f1RlcCfg = NULLP;
7794   LogicalChannelConfig_t *macUlLcCfg = NULLP;
7795
7796   for(idx = 0; idx < lcCfg->list.count; idx++)
7797   {
7798      lcId = lcCfg->list.array[idx]->logicalChannelIdentity;
7799      if(lcCfg->list.array[idx]->servedRadioBearer)
7800      {
7801         /* RadioBearer for SRB/DRB */
7802         if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7803         RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
7804         {
7805            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.srb_Identity;
7806            rbType = RB_TYPE_SRB;
7807         }
7808         else if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7809         RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
7810         {
7811            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.drb_Identity;
7812            rbType = RB_TYPE_DRB;
7813         }
7814         else
7815         {
7816            DU_LOG("\nERROR  -->  No components present in Bearer config to ADD/MOD");
7817            return RFAILED;
7818         }
7819         /* MAC UL LC Config */
7820         if(lcCfg->list.array[idx]->mac_LogicalChannelConfig)
7821         {
7822            macUlLcCfg = lcCfg->list.array[idx]->mac_LogicalChannelConfig;
7823         }
7824      }
7825      else
7826      {
7827         DU_LOG("\nERROR  -->  DUAPP: Received RadioBearer config is NULL");
7828         return RFAILED;
7829      }
7830      /* RLC Mode Config */
7831      if(lcCfg->list.array[idx]->rlc_Config)
7832      {
7833         rlcMode  = lcCfg->list.array[idx]->rlc_Config->present;
7834         f1RlcCfg = lcCfg->list.array[idx]->rlc_Config;
7835      }
7836
7837      /* Filling RLC/MAC Config*/
7838      memset(&ueCfgDb->macLcCfg[idx], 0, sizeof(LcCfg));
7839      memset(&ueCfgDb->rlcLcCfg[idx], 0, sizeof(RlcBearerCfg));
7840      procRlcLcCfg(rbId, lcId, rbType, rlcMode, CONFIG_UNKNOWN, f1RlcCfg, &(ueCfgDb->rlcLcCfg[idx]));
7841      if(procMacLcCfg(lcId, rbType, CONFIG_UNKNOWN, NULL, NULL, NULL, macUlLcCfg, &ueCfgDb->macLcCfg[idx], NULL) != ROK)
7842      {
7843         DU_LOG("\nERROR  -->  DU APP : Failed while filling MAC LC config at extractRlcCfgToAddMod()");
7844         return RFAILED;
7845      }
7846      (ueCfgDb->numRlcLcs)++;
7847      (ueCfgDb->numMacLcs)++;
7848          DU_LOG("\nDEBUG  -> DUAPP: extractRlcCfgToAddMod:RBType:%d, DrbID: %d,lcId:%d, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
7849                             rbType, rbId, lcId, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
7850   }
7851   //TODO: To send the failure cause in UeContextSetupRsp
7852   return ROK;
7853 }
7854
7855 /*******************************************************************
7856  *
7857  * @brief DeAlloc pdsch serv cell config info
7858  *
7859  * @details
7860  *
7861  *    Function : freeMacPdschServCellInfo
7862  *
7863  *    Functionality: DeAlloc pdsch serv cell config info
7864  *
7865  * @params[in] PdschServCellCfg pointer
7866  * @return void
7867  *
7868  * ****************************************************************/
7869
7870 void freeMacPdschServCellInfo(PdschServCellCfg *pdsch)
7871 {
7872    if(pdsch->xOverhead)
7873    {
7874       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->xOverhead, sizeof(PdschXOverhead));
7875    }
7876    if(pdsch->codeBlkGrpFlushInd)
7877    {
7878       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->codeBlkGrpFlushInd, sizeof(bool));
7879    }
7880    if(pdsch->maxCodeBlkGrpPerTb)
7881    {
7882       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
7883    }
7884    if(pdsch->maxMimoLayers)
7885    {
7886       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxMimoLayers, sizeof(uint8_t));
7887    }
7888 }
7889
7890 /*******************************************************************
7891  *
7892  * @brief Free Serving cell Info
7893  *
7894  * @details
7895  *
7896  *    Function : freeMacServingCellInfo
7897  *
7898  *    Functionality: Free Serving cell Info
7899  *
7900  * @params[in] ServCellCfgInfo *srvCellCfg
7901  * @return void
7902  *
7903  * ****************************************************************/
7904 void freeMacServingCellInfo(ServCellCfgInfo *srvCellCfg)
7905 {
7906    uint8_t timeDomRsrcIdx;
7907
7908    if(srvCellCfg->initDlBwp.pdschPresent)
7909    {
7910       for(timeDomRsrcIdx = 0; timeDomRsrcIdx < srvCellCfg->initDlBwp.pdschCfg.numTimeDomRsrcAlloc; timeDomRsrcIdx++)
7911       {
7912          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, \
7913             srvCellCfg->initDlBwp.pdschCfg.timeDomRsrcAllociList[timeDomRsrcIdx].k0, sizeof(uint8_t));
7914       }
7915    }
7916
7917    freeMacPdschServCellInfo(&srvCellCfg->pdschServCellCfg);
7918    if(srvCellCfg->bwpInactivityTmr)
7919    {
7920       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
7921    }
7922
7923    if(srvCellCfg->initUlBwp.pucchPresent)
7924    {
7925       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->initUlBwp.pucchCfg.dlDataToUlAck, sizeof(PucchDlDataToUlAck));
7926    }
7927 }
7928
7929 /*******************************************************************
7930  *
7931  * @brief Free cell Grp Cfg Info
7932  *
7933  * @details
7934  *
7935  *    Function : freeUeReCfgCellGrpInfo
7936  *
7937  *    Functionality: Free cell Grp Cfg Info
7938  *
7939  * @params[in] MacUeCfg*  duUeCfg
7940  * @return void
7941  *
7942  * ****************************************************************/
7943
7944 void freeUeReCfgCellGrpInfo(MacUeCfg *macUeCfg)
7945 {
7946    freeMacServingCellInfo(&macUeCfg->spCellCfg.servCellCfg);
7947 }
7948
7949 /*******************************************************************
7950  *
7951  * @brief Fills Reconfig SchReqReConfig
7952  *
7953  * @details
7954  *
7955  *    Function : extractSchReqReConfig
7956  *
7957  *    Functionality: Fills Reconfig SchReqReConfig
7958  *
7959  * @params[in] SchedulingRequestConfig_t *cuSchedReq
7960  *             SchedReqCfg*  macSchedReq
7961  * @return void
7962  *
7963  * ****************************************************************/
7964 void extractSchReqReConfig(SchedulingRequestConfig_t *cuSchedReq, SchedReqCfg *macSchedReq)
7965 {
7966    uint8_t schReqIdx = 0;
7967    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqListToAdd = NULLP;
7968    struct SchedulingRequestConfig__schedulingRequestToReleaseList *schReqListToRel = NULLP;
7969
7970    if(cuSchedReq->schedulingRequestToAddModList)
7971    {
7972       schReqListToAdd = cuSchedReq->schedulingRequestToAddModList;
7973       if(schReqListToAdd->list.count)
7974       {
7975          macSchedReq->addModListCount = schReqListToAdd->list.count;
7976          for(schReqIdx = 0; schReqIdx < schReqListToAdd->list.count; schReqIdx++)
7977          {
7978             macSchedReq->addModList[schReqIdx].schedReqId = \
7979                schReqListToAdd->list.array[schReqIdx]->schedulingRequestId;
7980             macSchedReq->addModList[schReqIdx].srProhibitTmr = \
7981                *(schReqListToAdd->list.array[schReqIdx]->sr_ProhibitTimer);
7982             macSchedReq->addModList[schReqIdx].srTransMax    =\
7983                schReqListToAdd->list.array[schReqIdx]->sr_TransMax;
7984          }
7985       }
7986    }
7987    /* Scheduling Req To release */
7988    if(cuSchedReq->schedulingRequestToReleaseList)
7989    {
7990       schReqListToRel = cuSchedReq->schedulingRequestToReleaseList;
7991       if(schReqListToRel->list.count)
7992       {
7993          macSchedReq->relListCount = schReqListToRel->list.count;
7994          for(schReqIdx = 0; schReqIdx < schReqListToRel->list.count; schReqIdx++)
7995          {
7996             macSchedReq->relList[schReqIdx] = \
7997                *schReqListToRel->list.array[schReqIdx];
7998          }
7999       }
8000    }
8001 }
8002
8003 /*******************************************************************
8004  *
8005  * @brief Fills TagReconfig
8006  *
8007  * @details
8008  *
8009  *    Function : extractTagReconfig
8010  *
8011  *    Functionality: Fills extractTagReconfig
8012  *
8013  * @params[in] TAG_Config_t *cuTagCfg
8014  *             TagCfg *macTagCfg
8015  * @return void
8016  *
8017  * ****************************************************************/
8018
8019 void extractTagReconfig(TAG_Config_t *cuTagCfg, TagCfg *macTagCfg)
8020 {
8021   uint8_t tagIdx = 0;
8022   struct TAG_Config__tag_ToAddModList  *tagListToAddMod = NULLP;
8023   struct TAG_Config__tag_ToReleaseList *tagListToRel = NULLP;
8024
8025   /* Tag config to AddMod */
8026   if(cuTagCfg->tag_ToAddModList)
8027   {
8028      tagListToAddMod = cuTagCfg->tag_ToAddModList;
8029      if(tagListToAddMod->list.count)
8030      {
8031         macTagCfg->addModListCount = tagListToAddMod->list.count;
8032         for(tagIdx = 0; tagIdx < tagListToAddMod->list.count; tagIdx++)
8033         {
8034            macTagCfg->addModList[tagIdx].tagId =\
8035               tagListToAddMod->list.array[tagIdx]->tag_Id;
8036            macTagCfg->addModList[tagIdx].timeAlignTimer = \
8037
8038               tagListToAddMod->list.array[tagIdx]->timeAlignmentTimer;
8039         }
8040      }
8041   }
8042   /* Tag config to release */
8043   if(cuTagCfg->tag_ToReleaseList)
8044   {
8045      tagListToRel = cuTagCfg->tag_ToReleaseList;
8046      if(tagListToRel->list.count)
8047      {
8048         macTagCfg->relListCount = tagListToRel->list.count;
8049         for(tagIdx = 0; tagIdx < tagListToRel->list.count; tagIdx++)
8050         {
8051            macTagCfg->relList[tagIdx] = *tagListToRel->list.array[tagIdx];
8052         }
8053      }
8054   }
8055 }
8056
8057 /*******************************************************************
8058  *
8059  * @brief Fills PdcchCfg received by CU
8060  *
8061  * @details
8062  *
8063  *    Function : extractPdcchCfg
8064  *
8065  *    Functionality: Fills PdcchCfg received  by CU
8066  *
8067  * @params[in] PDCCH_Config_t *cuPdcchCfg,
8068  *             PdcchConfig *duPdcchCfg
8069  * @return void
8070  *
8071  * ****************************************************************/
8072
8073 void extractPdcchCfg(PDCCH_Config_t *cuPdcchCfg, PdcchConfig *macPdcchCfg)
8074 {
8075    uint8_t cRsetIdx = 0;
8076    uint8_t srchSpcIdx = 0;
8077
8078    struct PDCCH_Config__controlResourceSetToAddModList *cRsetToAddModList = NULLP;
8079    struct PDCCH_Config__controlResourceSetToReleaseList *cRsetToRelList = NULLP;
8080    struct PDCCH_Config__searchSpacesToAddModList *srchSpcToAddModList = NULLP;
8081    struct PDCCH_Config__searchSpacesToReleaseList *srchSpcToRelList = NULLP;
8082
8083
8084    /* Control Resource Set To Add/Mod List */
8085    if(cuPdcchCfg->controlResourceSetToAddModList)
8086    {
8087       cRsetToAddModList = cuPdcchCfg->controlResourceSetToAddModList;
8088       if(cRsetToAddModList->list.count)
8089       {
8090          macPdcchCfg->numCRsetToAddMod = cRsetToAddModList->list.count;
8091          for(cRsetIdx = 0; cRsetIdx < cRsetToAddModList->list.count; cRsetIdx++)
8092          {
8093             macPdcchCfg->cRSetToAddModList[cRsetIdx].cRSetId = \
8094               cRsetToAddModList->list.array[cRsetIdx]->controlResourceSetId;
8095             bitStringToInt(&cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources,\
8096                macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc);
8097             macPdcchCfg->cRSetToAddModList[cRsetIdx].duration = \
8098               cRsetToAddModList->list.array[cRsetIdx]->duration;
8099
8100             macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType = \
8101               cRsetToAddModList->list.array[cRsetIdx]->cce_REG_MappingType.present;
8102             if(macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType == CCE_REG_MAPPINGTYPE_PR_INTERLEAVED)
8103             {
8104                //TODO: handle the case for Interleaved
8105             }
8106             macPdcchCfg->cRSetToAddModList[cRsetIdx].precoderGranularity = \
8107               cRsetToAddModList->list.array[cRsetIdx]->precoderGranularity;
8108             if(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID)
8109             {
8110                macPdcchCfg->cRSetToAddModList[cRsetIdx].dmrsScramblingId= \
8111                   *(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID);
8112             }
8113          }
8114       }
8115
8116    }
8117    /* Control Resource Set To Release List */
8118    if(cuPdcchCfg->controlResourceSetToReleaseList)
8119    {
8120       cRsetToRelList = cuPdcchCfg->controlResourceSetToReleaseList;
8121       if(cRsetToRelList->list.count)
8122       {
8123          macPdcchCfg->numCRsetToRel = cRsetToRelList->list.count;
8124          for(cRsetIdx = 0; cRsetIdx < cRsetToRelList->list.count; cRsetIdx++)
8125          {
8126             macPdcchCfg->cRSetToRelList[cRsetIdx] = *(cRsetToRelList->list.array[cRsetIdx]);
8127          }
8128       }
8129    }
8130
8131    /* Search space To Add/Mod List */
8132    if(cuPdcchCfg->searchSpacesToAddModList)
8133    {
8134       srchSpcToAddModList = cuPdcchCfg->searchSpacesToAddModList;
8135       if(srchSpcToAddModList->list.count)
8136       {
8137          macPdcchCfg->numSearchSpcToAddMod = srchSpcToAddModList->list.count;
8138          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToAddModList->list.count; srchSpcIdx++)
8139          {
8140             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceId =\
8141                srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceId;
8142             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].cRSetId =\
8143                *(srchSpcToAddModList->list.array[srchSpcIdx]->controlResourceSetId);
8144             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset)
8145             {
8146                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset =\
8147                   srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset->present;
8148             }
8149             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot)
8150             {
8151                bitStringToInt(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot,\
8152                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSymbolsWithinSlot);
8153             }
8154             if(srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates)
8155             {
8156               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel1 = \
8157                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel1;
8158               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel2 = \
8159                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel2;
8160               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel4 = \
8161                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel4;
8162
8163               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel8 = \
8164                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel8;
8165
8166               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel16 = \
8167                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel16;
8168             }
8169             if(srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType)
8170             {
8171                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType =\
8172                   srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->present;
8173                if(macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType == SEARCHSPACETYPE_PR_UE_SPECIFIC)
8174                {
8175                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].ueSpecificDciFormat =\
8176                      srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->choice.ue_Specific->dci_Formats;
8177                }
8178
8179             }
8180          }
8181       }
8182    }
8183    /* Search space To Rel List */
8184    if(cuPdcchCfg->searchSpacesToReleaseList)
8185    {
8186       srchSpcToRelList = cuPdcchCfg->searchSpacesToReleaseList;
8187       if(srchSpcToRelList->list.count)
8188       {
8189          macPdcchCfg->numSearchSpcToRel = srchSpcToRelList->list.count;
8190          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToRelList->list.count; srchSpcIdx++)
8191          {
8192             macPdcchCfg->searchSpcToRelList[srchSpcIdx] =\
8193                *(srchSpcToRelList->list.array[srchSpcIdx]);
8194          }
8195       }
8196    }
8197 }
8198
8199 /*******************************************************************
8200  *
8201  * @brief Fills PdschCfg received by CU
8202  *
8203  * @details
8204  *
8205  *    Function : extractPdschCfg
8206  *
8207  *    Functionality: Fills PdschCfg received  by CU
8208  *
8209  * @params[in] PDSCH_Config_t *cuPdschCfg = Information which is send by CU,
8210  *                   which we have stored in F1UeContextSetupDb,
8211  *             PdschConfig *macPdschCfg = Used to Store the information which
8212  *                   needs to send in other layer, as well as this can be the variable
8213  *                   which stores the information in DuCb,
8214  *             PdschConfig *storedPdschCfg =  Null in case of sending the
8215  *                   information to other layer else it will have stored pdsch
8216  *                   configuration in copyOfmacUeCfg.
8217  * @return void
8218  *
8219  * ****************************************************************/
8220
8221 void extractPdschCfg(PDSCH_Config_t *cuPdschCfg, PdschConfig *macPdschCfg, PdschConfig *storedPdschCfg)
8222 {
8223    uint8_t timeDomIdx;
8224    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAlloc = NULLP;
8225
8226    if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
8227    {
8228       if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->present == \
8229             PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup)
8230       {
8231          if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup)
8232          {
8233             macPdschCfg->dmrsDlCfgForPdschMapTypeA.addPos = \
8234                *(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_AdditionalPosition);
8235          }
8236       }
8237    }
8238    macPdschCfg->resourceAllocType = cuPdschCfg->resourceAllocation;
8239    if(cuPdschCfg->pdsch_TimeDomainAllocationList)
8240    {
8241       timeDomAlloc = cuPdschCfg->pdsch_TimeDomainAllocationList;
8242       if(timeDomAlloc->present ==\
8243             PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup)
8244       {
8245          if(timeDomAlloc->choice.setup)
8246          {
8247             macPdschCfg->numTimeDomRsrcAlloc  = timeDomAlloc->choice.setup->list.count;
8248             for(timeDomIdx = 0; timeDomIdx < timeDomAlloc->choice.setup->list.count; timeDomIdx++)
8249             {
8250                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 = NULLP;
8251                if(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0)
8252                {
8253                   if(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 == NULL)
8254                   {
8255                      if(storedPdschCfg)
8256                      {
8257                         if(storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
8258                         {
8259                            macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 =\
8260                            storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0;
8261                         }
8262                         else
8263                         {
8264                            DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
8265                         }
8266                      }
8267                      else
8268                      {
8269                         DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
8270                      }
8271                      if(!macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
8272                      {
8273                         DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for k0 at extractPdschCfg()");
8274                         return RFAILED;
8275                      }
8276                   }
8277                   *(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0) = \
8278                   *(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0);
8279                }
8280                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
8281                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
8282                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
8283                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8284             }
8285          }
8286       }
8287    }
8288    macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
8289    if(cuPdschCfg->maxNrofCodeWordsScheduledByDCI)
8290       macPdschCfg->numCodeWordsSchByDci = *(cuPdschCfg->maxNrofCodeWordsScheduledByDCI);
8291    if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_staticBundling)
8292    {
8293       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
8294       if(cuPdschCfg->prb_BundlingType.choice.staticBundling)
8295       {
8296          if(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize)
8297          {
8298             macPdschCfg->bundlingInfo.StaticBundling.size = \
8299                *(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize);
8300          }
8301       }
8302    }
8303    else if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_dynamicBundling)
8304    {
8305       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
8306    }
8307
8308 }
8309
8310 /*******************************************************************
8311  *
8312  * @brief Fills PdschServingCellCfg received by CU
8313  *
8314  * @details
8315  *
8316  *    Function : extractPdschServingCellCfg
8317  *
8318  *    Functionality: Fills PdschCfg received  by CU
8319  *
8320  * @params[in] PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg,
8321  *             PdschServCellCfg *macUePdschSrvCellCfg
8322  * @return ROK/RFAILED
8323  *
8324  * ****************************************************************/
8325
8326 uint8_t extractPdschServingCellCfg(PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg, PdschServCellCfg *macUePdschSrvCellCfg)
8327 {
8328    if(cuPdschSrvCellCfg->codeBlockGroupTransmission)
8329    {
8330       if(cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup)
8331       {
8332          if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
8333          {
8334             *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
8335                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
8336          }
8337          else
8338          {
8339             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
8340             if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
8341             {
8342                *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
8343                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
8344             }
8345             else
8346             {
8347                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
8348                return RFAILED;
8349             }
8350          }
8351          if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
8352          {
8353             *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
8354                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
8355          }
8356          else
8357          {
8358             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->codeBlkGrpFlushInd , sizeof(bool));
8359             if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
8360             {
8361                *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
8362                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
8363             }
8364             else
8365             {
8366                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
8367                return RFAILED;
8368             }
8369          }
8370       }
8371    }
8372    if(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH)
8373    {
8374       macUePdschSrvCellCfg->numHarqProcForPdsch = *(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH);
8375    }
8376    if(cuPdschSrvCellCfg->ext1)
8377    {
8378       if(cuPdschSrvCellCfg->ext1->maxMIMO_Layers)
8379       {
8380         if(macUePdschSrvCellCfg->maxMimoLayers)
8381         {
8382            *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
8383         }
8384         else
8385         {
8386            DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxMimoLayers, sizeof(uint8_t));
8387            if(macUePdschSrvCellCfg->maxMimoLayers)
8388            {
8389               *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
8390            }
8391            else
8392            {
8393               DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
8394               return RFAILED;
8395            }
8396         }
8397       }
8398    }
8399    if(cuPdschSrvCellCfg->xOverhead)
8400    {
8401       if(macUePdschSrvCellCfg->xOverhead)
8402       {
8403          *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
8404       }
8405       else
8406       {
8407          DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->xOverhead, sizeof(PdschXOverhead));
8408          if(macUePdschSrvCellCfg->xOverhead)
8409          {
8410             *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
8411          }
8412          else
8413          {
8414             DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
8415             return RFAILED;
8416          }
8417       }
8418    }
8419    return ROK;
8420 }
8421
8422 /*******************************************************************
8423  *
8424  * @brief Fills PuschCfg received by CU
8425  *
8426  * @details
8427  *
8428  *    Function : extractPuschCfg
8429  *
8430  *    Functionality: Fills PuschCfg received  by CU
8431  *
8432  * @params[in] BWP_UplinkDedicated__pusch_Config *cuPuschCfg,
8433  *             PuschCfg *macPuschCfg
8434  * @return void
8435  *
8436  * ****************************************************************/
8437
8438 void extractPuschCfg(struct BWP_UplinkDedicated__pusch_Config *cuPuschCfg, PuschCfg *macPuschCfg)
8439 {
8440    uint8_t timeDomIdx = 0;
8441    DMRS_UplinkConfig_t *dmrsUlCfg = NULLP;
8442    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList = NULLP;
8443
8444    if(cuPuschCfg->present == BWP_UplinkDedicated__pusch_Config_PR_setup)
8445    {
8446       if(cuPuschCfg->choice.setup)
8447       {
8448          if(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH)
8449          {
8450              macPuschCfg->dataScramblingId = \
8451                 *(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH);
8452          }
8453          if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA)
8454          {
8455             if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->present == PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup)
8456             {
8457                if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup)
8458                {
8459                   dmrsUlCfg = (cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup);
8460                   if(dmrsUlCfg->dmrs_AdditionalPosition)
8461                   {
8462                      macPuschCfg->dmrsUlCfgForPuschMapTypeA.addPos =\
8463                         *(dmrsUlCfg->dmrs_AdditionalPosition);
8464                   }
8465                   if(dmrsUlCfg->transformPrecodingDisabled)
8466                   {
8467                      if(dmrsUlCfg->transformPrecodingDisabled->scramblingID0)
8468                      {
8469                         macPuschCfg->dmrsUlCfgForPuschMapTypeA.transPrecodDisabled.scramblingId0 = \
8470                            *(dmrsUlCfg->transformPrecodingDisabled->scramblingID0);
8471                      }
8472                   }
8473                }
8474             }
8475          }
8476          /*Res Alloc Type for UL */
8477          if(cuPuschCfg->choice.setup->resourceAllocation)
8478          {
8479             macPuschCfg->resourceAllocType = \
8480                cuPuschCfg->choice.setup->resourceAllocation;
8481          }
8482          if(cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList)
8483          {
8484             timeDomAllocList = cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList;
8485             if(timeDomAllocList->present == PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup)
8486             {
8487                if(timeDomAllocList->choice.setup)
8488                {
8489                   macPuschCfg->numTimeDomRsrcAlloc = timeDomAllocList->choice.setup->list.count;
8490                   for(timeDomIdx = 0; timeDomIdx <timeDomAllocList->choice.setup->list.count; timeDomIdx++)
8491                   {
8492                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].k2 = \
8493                         *(timeDomAllocList->choice.setup->list.array[timeDomIdx]->k2);
8494                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].mappingType = \
8495                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->mappingType;
8496                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbolAndLength = \
8497                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8498                   }
8499                }
8500             }
8501          }
8502          if(cuPuschCfg->choice.setup->transformPrecoder)
8503             macPuschCfg->transformPrecoder = *(cuPuschCfg->choice.setup->transformPrecoder);
8504       }
8505    }
8506 }
8507
8508 /*******************************************************************
8509  *
8510  * @brief Function to fill pucch Power Control
8511  *
8512  * @details
8513  *
8514  *    Function : extractPucchPowerControl
8515  *
8516  *    Functionality: Function to fill pucch Power Control
8517  *
8518  * @params[in] PucchPowerControl *pwrCtrl,
8519  *             struct PUCCH_PowerControl *cuPwrCtrlCfg
8520  * @return void
8521  *
8522  * ****************************************************************/
8523
8524 void extractPucchPowerControl(PucchPowerControl *pwrCtrl, struct PUCCH_PowerControl *cuPwrCtrlCfg)
8525 {
8526    uint8_t arrIdx;
8527
8528    if(cuPwrCtrlCfg->deltaF_PUCCH_f0)
8529       pwrCtrl->deltaF_Format0 = *cuPwrCtrlCfg->deltaF_PUCCH_f0;
8530    if(cuPwrCtrlCfg->deltaF_PUCCH_f1)
8531       pwrCtrl->deltaF_Format1 = *cuPwrCtrlCfg->deltaF_PUCCH_f1;
8532    if(cuPwrCtrlCfg->deltaF_PUCCH_f2)
8533       pwrCtrl->deltaF_Format2 = *cuPwrCtrlCfg->deltaF_PUCCH_f2;
8534    if(cuPwrCtrlCfg->deltaF_PUCCH_f3)
8535       pwrCtrl->deltaF_Format3 = *cuPwrCtrlCfg->deltaF_PUCCH_f3;
8536    if(cuPwrCtrlCfg->deltaF_PUCCH_f4)
8537       pwrCtrl->deltaF_Format4 = *cuPwrCtrlCfg->deltaF_PUCCH_f4;
8538    if(cuPwrCtrlCfg->p0_Set)
8539    {
8540       pwrCtrl->p0SetCount = cuPwrCtrlCfg->p0_Set->list.count;
8541       for(arrIdx=0; arrIdx < pwrCtrl->p0SetCount; arrIdx++)
8542       {
8543          pwrCtrl->p0Set[arrIdx].p0PucchId =\
8544             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Id;
8545          pwrCtrl->p0Set[arrIdx].p0PucchVal =\
8546             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Value;
8547       }
8548    }
8549    if(cuPwrCtrlCfg->pathlossReferenceRSs)
8550    {
8551       pwrCtrl->pathLossRefRSListCount = cuPwrCtrlCfg->pathlossReferenceRSs->list.count;
8552       for(arrIdx = 0; arrIdx < pwrCtrl->pathLossRefRSListCount; arrIdx++)
8553       {
8554          pwrCtrl->pathLossRefRSList[arrIdx].pathLossRefRSId =\
8555             cuPwrCtrlCfg->pathlossReferenceRSs->list.array[arrIdx]->pucch_PathlossReferenceRS_Id;
8556       }
8557    }
8558 }
8559
8560  /*******************************************************************
8561  *
8562  * @brief Function to extractResrcSetToAddModList sent by CU
8563  *
8564  * @details
8565  *
8566  *    Function : extractResrcSetToAddModList
8567  *
8568  *    Functionality: Fucntion to extractResrcSetToAddModList
8569  *
8570  * @params[in] PucchResrcSetCfg pointer,
8571  *             struct PUCCH_Config__resourceSetToAddModList pointer
8572  * @return void
8573  *
8574  * ****************************************************************/
8575
8576 void extractResrcSetToAddModList(PucchResrcSetCfg *macRsrcSetList, struct PUCCH_Config__resourceSetToAddModList *cuRsrcSetList)
8577 {
8578    uint8_t arrIdx, rsrcListIdx;
8579
8580    macRsrcSetList->resrcSetToAddModListCount = cuRsrcSetList->list.count;
8581    for(arrIdx = 0; arrIdx < macRsrcSetList->resrcSetToAddModListCount; arrIdx++)
8582    {
8583       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcSetId     =\
8584          cuRsrcSetList->list.array[arrIdx]->pucch_ResourceSetId;
8585       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount =\
8586          cuRsrcSetList->list.array[arrIdx]->resourceList.list.count;
8587       for(rsrcListIdx = 0; rsrcListIdx < macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount; rsrcListIdx++)
8588       {
8589          macRsrcSetList->resrcSetToAddModList[arrIdx].resrcList[rsrcListIdx] =\
8590             *cuRsrcSetList->list.array[arrIdx]->resourceList.list.array[rsrcListIdx];
8591       }
8592       macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize =\
8593          *cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1;
8594    }
8595 }/* End of extractResrcSetToAddModList */
8596
8597 /*******************************************************************
8598  *
8599  * @brief Fills extractResrcToAddModList sent by CU
8600  *
8601  * @details
8602  *
8603  *    Function : extractResrcToAddModList
8604  *
8605  *    Functionality: Fills extractResrcToAddModList
8606  *
8607  * @params[in] PucchResrcCfg pointer,
8608  *             struct PUCCH_Config__resourceToAddModList pointer
8609  * @return ROk/RFAILED
8610  *
8611  * ****************************************************************/
8612
8613 uint8_t extractResrcToAddModList(PucchResrcCfg *macResrcList, struct PUCCH_Config__resourceToAddModList *cuResrcList)
8614 {
8615    uint8_t arrIdx;
8616
8617    macResrcList->resrcToAddModListCount = cuResrcList->list.count;
8618    for(arrIdx = 0; arrIdx < macResrcList->resrcToAddModListCount; arrIdx++)
8619    {
8620       macResrcList->resrcToAddModList[arrIdx].resrcId      =\
8621         cuResrcList->list.array[arrIdx]->pucch_ResourceId;
8622       macResrcList->resrcToAddModList[arrIdx].startPrb     =\
8623         cuResrcList->list.array[arrIdx]->startingPRB;
8624       if(cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping)
8625       {
8626          macResrcList->resrcToAddModList[arrIdx].intraFreqHop =\
8627            *cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping;
8628       }
8629       if(cuResrcList->list.array[arrIdx]->secondHopPRB)
8630       {
8631          macResrcList->resrcToAddModList[arrIdx].secondPrbHop =\
8632            *cuResrcList->list.array[arrIdx]->secondHopPRB;
8633       }
8634       /* PUCCH RSRC FORMAT */
8635       if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format0)
8636       {
8637          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_0;
8638          if(cuResrcList->list.array[arrIdx]->format.choice.format0)
8639          {
8640             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0, sizeof(PucchFormat0));
8641             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0 == NULLP)
8642             {
8643                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
8644                return RFAILED;
8645             }
8646             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->initialCyclicShift =\
8647                cuResrcList->list.array[arrIdx]->format.choice.format0->initialCyclicShift;
8648             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->numSymbols =\
8649                cuResrcList->list.array[arrIdx]->format.choice.format0->nrofSymbols;
8650             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->startSymbolIdx =\
8651                cuResrcList->list.array[arrIdx]->format.choice.format0->startingSymbolIndex;
8652          }
8653       }
8654       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format1)
8655       {
8656          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_1;
8657          if(cuResrcList->list.array[arrIdx]->format.choice.format1)
8658          {
8659             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1, sizeof(PucchFormat1));
8660             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1 == NULLP)
8661             {
8662                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
8663                return RFAILED;
8664             }
8665             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->initialCyclicShift =\
8666                 cuResrcList->list.array[arrIdx]->format.choice.format1->initialCyclicShift;
8667             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->numSymbols =\
8668                 cuResrcList->list.array[arrIdx]->format.choice.format1->nrofSymbols;
8669             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->startSymbolIdx =\
8670                 cuResrcList->list.array[arrIdx]->format.choice.format1->startingSymbolIndex;
8671             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->timeDomOCC =\
8672                 cuResrcList->list.array[arrIdx]->format.choice.format1->timeDomainOCC;
8673          }
8674       }
8675       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format2)
8676       {
8677          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_2;
8678          if(cuResrcList->list.array[arrIdx]->format.choice.format2)
8679          {
8680             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
8681             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2 == NULLP)
8682             {
8683                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
8684                return RFAILED;
8685             }
8686             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numPrbs =\
8687                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofPRBs;
8688             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numSymbols =\
8689                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofSymbols;
8690             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->startSymbolIdx =\
8691                 cuResrcList->list.array[arrIdx]->format.choice.format2->startingSymbolIndex;
8692          }
8693       }
8694       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format3)
8695       {
8696          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_3;
8697          if(cuResrcList->list.array[arrIdx]->format.choice.format3)
8698          {
8699             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
8700             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3 == NULLP)
8701             {
8702                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
8703                return RFAILED;
8704             }
8705             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numPrbs =\
8706                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofPRBs;
8707             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numSymbols =\
8708                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofSymbols;
8709             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->startSymbolIdx =\
8710                 cuResrcList->list.array[arrIdx]->format.choice.format3->startingSymbolIndex;
8711          }
8712       }
8713       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format4)
8714       {
8715          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_4;
8716          if(cuResrcList->list.array[arrIdx]->format.choice.format4)
8717          {
8718             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4, sizeof(PucchFormat4));
8719             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4 == NULLP)
8720             {
8721                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
8722                return RFAILED;
8723             }
8724             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->numSymbols =\
8725                 cuResrcList->list.array[arrIdx]->format.choice.format4->nrofSymbols;
8726             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occLen =\
8727                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Length;
8728             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occIdx =\
8729                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Index;
8730             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->startSymbolIdx =\
8731                 cuResrcList->list.array[arrIdx]->format.choice.format4->startingSymbolIndex;
8732          }
8733       }
8734    }
8735    return ROK;
8736
8737 }/* End of extractResrcToAddModList */
8738
8739 /*******************************************************************
8740  *
8741  * @brief Fills fillPucchSchedReqPeriodAndOffset sent by CU
8742  *
8743  * @details
8744  *
8745  *    Function : fillPucchSchedReqPeriodAndOffset
8746  *
8747  *    Functionality: To fillPucchSchedReqPeriodAndOffset
8748  *
8749  * @params[in] macPeriodicty,
8750  *     SchedulingRequestResourceConfig__periodicityAndOffset pointer
8751  * @return void
8752  *
8753  * ****************************************************************/
8754
8755 void fillPucchSchedReqPeriodAndOffset(uint8_t macPeriodicty, uint16_t  macOffset,\
8756    struct SchedulingRequestResourceConfig__periodicityAndOffset *cuPeriodicty)
8757 {
8758    macPeriodicty = cuPeriodicty->present;
8759    switch(macPeriodicty)
8760    {
8761       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
8762          {
8763             macOffset     = cuPeriodicty->choice.sym2;
8764             break;
8765          }
8766       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
8767          {
8768             macOffset     = cuPeriodicty->choice.sym6or7;
8769             break;
8770          }
8771       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
8772          {
8773             macOffset     = cuPeriodicty->choice.sl1;
8774             break;
8775          }
8776       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
8777          {
8778             macOffset = cuPeriodicty->choice.sl2;
8779             break;
8780          }
8781       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
8782          {
8783             macOffset = cuPeriodicty->choice.sl4;
8784             break;
8785          }
8786       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
8787          {
8788             macOffset = cuPeriodicty->choice.sl5;
8789             break;
8790          }
8791       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
8792          {
8793             macOffset = cuPeriodicty->choice.sl8;
8794             break;
8795          }
8796       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
8797          {
8798             macOffset = cuPeriodicty->choice.sl10;
8799             break;
8800          }
8801       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
8802          {
8803             macOffset = cuPeriodicty->choice.sl16;
8804             break;
8805          }
8806       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
8807          {
8808             macOffset = cuPeriodicty->choice.sl20;
8809             break;
8810          }
8811       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
8812          {
8813             macOffset = cuPeriodicty->choice.sl40;
8814             break;
8815          }
8816       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
8817          {
8818             macOffset = cuPeriodicty->choice.sl80;
8819             break;
8820          }
8821       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
8822          {
8823             macOffset = cuPeriodicty->choice.sl160;
8824             break;
8825          }
8826       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
8827          {
8828             macOffset = cuPeriodicty->choice.sl320;
8829             break;
8830          }
8831       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
8832          {
8833             macOffset = cuPeriodicty->choice.sl640;
8834             break;
8835          }
8836       default :
8837          DU_LOG("\nERROR  -->  F1AP : Invalid periodicity %d", macPeriodicty);
8838    }
8839 }
8840
8841 /*******************************************************************
8842  *
8843  * @brief Function to extractPucchFormatCfg sent by CU
8844  *
8845  * @details
8846  *
8847  *    Function : extractPucchFormatCfg
8848  *
8849  *    Functionality: Function to extractPucchFormatCfg
8850  *
8851  * @params[in] PucchFormatCfg pointer,
8852  *             PUCCH_FormatConfig_t pointer
8853  * @return void
8854  *
8855  * ****************************************************************/
8856
8857 void extractPucchFormatCfg(PucchFormatCfg *macFormatCfg, PUCCH_FormatConfig_t *cuFormatCfg)
8858  {
8859     if(cuFormatCfg->interslotFrequencyHopping)
8860        macFormatCfg->interSlotFreqHop = *cuFormatCfg->interslotFrequencyHopping;
8861     if(cuFormatCfg->additionalDMRS)
8862        macFormatCfg->addDmrs = *cuFormatCfg->additionalDMRS;
8863     if(cuFormatCfg->maxCodeRate)
8864        macFormatCfg->maxCodeRate = *cuFormatCfg->maxCodeRate;
8865     if(cuFormatCfg->nrofSlots)
8866        macFormatCfg->numSlots = *cuFormatCfg->nrofSlots;
8867     if(cuFormatCfg->pi2BPSK)
8868        macFormatCfg->pi2BPSK = *cuFormatCfg->pi2BPSK;
8869     if(cuFormatCfg->simultaneousHARQ_ACK_CSI)
8870        macFormatCfg->harqAckCSI = *cuFormatCfg->simultaneousHARQ_ACK_CSI;
8871  }/* End of extractPucchFormatCfg */
8872
8873 /*******************************************************************
8874  *
8875  * @brief Function to extractSchedReqCfgToAddMod sent by CU
8876  *
8877  * @details
8878  *
8879  *    Function : extractSchedReqCfgToAddMod
8880  *
8881  *    Functionality: Function to extractSchedReqCfgToAddMod
8882  *
8883  * @params[in] PucchSchedReqCfg pointer,
8884  *      PUCCH_Config__schedulingRequestResourceToAddModList pointer
8885  * @return void
8886  *
8887  * ****************************************************************/
8888
8889 void extractSchedReqCfgToAddMod(PucchSchedReqCfg *macSchedReqCfg, struct PUCCH_Config__schedulingRequestResourceToAddModList *cuSchedReqList)
8890 {
8891    uint8_t arrIdx;
8892
8893    macSchedReqCfg->schedAddModListCount = cuSchedReqList->list.count;
8894    for(arrIdx = 0; arrIdx <  macSchedReqCfg->schedAddModListCount; arrIdx++)
8895    {
8896       macSchedReqCfg->schedAddModList[arrIdx].resrcId =\
8897          cuSchedReqList->list.array[arrIdx]->schedulingRequestResourceId;
8898       macSchedReqCfg->schedAddModList[arrIdx].requestId =\
8899          cuSchedReqList->list.array[arrIdx]->schedulingRequestID;
8900       if(cuSchedReqList->list.array[arrIdx]->periodicityAndOffset)
8901       {
8902          fillPucchSchedReqPeriodAndOffset(macSchedReqCfg->schedAddModList[arrIdx].periodicity,\
8903             macSchedReqCfg->schedAddModList[arrIdx].offset, cuSchedReqList->list.array[arrIdx]->periodicityAndOffset);
8904       }
8905       if(cuSchedReqList->list.array[arrIdx]->resource)
8906       {
8907          macSchedReqCfg->schedAddModList[arrIdx].resrc =\
8908             *cuSchedReqList->list.array[arrIdx]->resource;
8909       }
8910    }
8911
8912 }/* End of extractSchedReqCfgToAddMod */
8913
8914  /*******************************************************************
8915  *
8916  * @brief Fills PucchCfg received by CU
8917  *
8918  * @details
8919  *
8920  *    Function : extractPucchCfg
8921  *
8922  *    Functionality: Fills PucchCfg received  by CU
8923  *
8924  * @params[in] BWP_UplinkDedicated__pucch_Config *cuPucchCfg = Information which
8925  *                is send by CU, which we have stored in F1UeContextSetupDb,
8926  *             PucchCfg *macPucchCfg = Used to Store the information which
8927  *                needs to send in other layer, as well as this can be the variable
8928  *                which stores the information in DuCb,
8929  *             PucchCfg *storedPucchCfg = Null in case of sending the
8930  *                information to other layer else it will have Pucch Cfg which
8931  *                we have stored in copyOfmacUeCfg.
8932  * @return ROK/RFAILED
8933  *
8934  * ****************************************************************/
8935
8936 uint8_t extractPucchCfg(struct BWP_UplinkDedicated__pucch_Config *cuPucchCfg, PucchCfg *macPucchCfg,\
8937 PucchCfg *storedPucchCfg)
8938 {
8939    uint8_t arrIdx;
8940
8941    if(cuPucchCfg->present == BWP_UplinkDedicated__pucch_Config_PR_setup)
8942    {
8943       if(cuPucchCfg->choice.setup)
8944       {
8945          /* Resource Set Cfg */
8946          if(cuPucchCfg->choice.setup->resourceSetToAddModList)
8947          {
8948             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrcSet, sizeof(PucchResrcSetCfg));
8949             if(macPucchCfg->resrcSet == NULLP)
8950             {
8951                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
8952                return RFAILED;
8953             }
8954             memset(macPucchCfg->resrcSet, 0, sizeof(PucchResrcSetCfg));
8955             extractResrcSetToAddModList(macPucchCfg->resrcSet, cuPucchCfg->choice.setup->resourceSetToAddModList);
8956          }
8957
8958          /* Resource Cfg */
8959          if(cuPucchCfg->choice.setup->resourceToAddModList)
8960          {
8961             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrc, sizeof(PucchResrcCfg));
8962             if(macPucchCfg->resrc == NULLP)
8963             {
8964                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
8965                return RFAILED;
8966             }
8967             memset(macPucchCfg->resrc, 0, sizeof(PucchResrcCfg));
8968             extractResrcToAddModList(macPucchCfg->resrc, cuPucchCfg->choice.setup->resourceToAddModList);
8969          }
8970
8971          /* Format 1 Cfg */
8972          if(cuPucchCfg->choice.setup->format1)
8973          {
8974             DU_ALLOC_SHRABL_BUF(macPucchCfg->format1, sizeof(PucchFormatCfg));
8975             if(macPucchCfg->format1 == NULLP)
8976             {
8977                DU_LOG("\nERROR --> F1AP : Failed to extract format 1 Cfg in  extractPucchCfg()");
8978                return RFAILED;
8979             }
8980             memset(macPucchCfg->format1, 0, sizeof(PucchFormatCfg));
8981             extractPucchFormatCfg(macPucchCfg->format1,\
8982                cuPucchCfg->choice.setup->format1->choice.setup);
8983          }
8984
8985          /* Format 2 Cfg */
8986          if(cuPucchCfg->choice.setup->format2)
8987          {
8988             DU_ALLOC_SHRABL_BUF(macPucchCfg->format2, sizeof(PucchFormatCfg));
8989             if(macPucchCfg->format2 == NULLP)
8990             {
8991                DU_LOG("\nERROR --> F1AP : Failed to extract format 2 Cfg in  extractPucchCfg()");
8992                return RFAILED;
8993             }
8994             memset(macPucchCfg->format2, 0, sizeof(PucchFormatCfg));
8995             extractPucchFormatCfg(macPucchCfg->format2,\
8996                cuPucchCfg->choice.setup->format2->choice.setup);
8997          }
8998
8999          /* Format 3 Cfg */
9000          if(cuPucchCfg->choice.setup->format3)
9001          {
9002             DU_ALLOC_SHRABL_BUF(macPucchCfg->format3, sizeof(PucchFormatCfg));
9003             if(macPucchCfg->format3 == NULLP)
9004             {
9005                DU_LOG("\nERROR --> F1AP : Failed to extract format 3 Cfg in  extractPucchCfg()");
9006                return RFAILED;
9007             }
9008             memset(macPucchCfg->format3, 0, sizeof(PucchFormatCfg));
9009             extractPucchFormatCfg(macPucchCfg->format3,\
9010                cuPucchCfg->choice.setup->format3->choice.setup);
9011          }
9012
9013          /* Format 4 Cfg */
9014          if(cuPucchCfg->choice.setup->format4)
9015          {
9016             DU_ALLOC_SHRABL_BUF(macPucchCfg->format4, sizeof(PucchFormatCfg));
9017             if(macPucchCfg->format4 == NULLP)
9018             {
9019                DU_LOG("\nERROR --> F1AP : Failed to extract format 4 Cfg in  extractPucchCfg()");
9020                return RFAILED;
9021             }
9022             memset(macPucchCfg->format4, 0, sizeof(PucchFormatCfg));
9023             extractPucchFormatCfg(macPucchCfg->format4,\
9024                cuPucchCfg->choice.setup->format4->choice.setup);
9025          }
9026
9027          /* Sched Req List */
9028          if(cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList)
9029          {
9030             DU_ALLOC_SHRABL_BUF(macPucchCfg->schedReq, sizeof(PucchSchedReqCfg));
9031             if(macPucchCfg->schedReq == NULLP)
9032             {
9033                DU_LOG("\nERROR --> F1AP : Failed to extract schedReqCfg in  extractPucchCfg()");
9034                return RFAILED;
9035             }
9036             memset(macPucchCfg->schedReq, 0, sizeof(PucchSchedReqCfg));
9037             extractSchedReqCfgToAddMod(macPucchCfg->schedReq,\
9038             cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList);
9039          }
9040
9041          /*TODO: Add support for  Spatial Info */
9042
9043          /* MultiCsiCfg */
9044          if(cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList)
9045          {
9046             DU_ALLOC_SHRABL_BUF(macPucchCfg->multiCsiCfg, sizeof(PucchMultiCsiCfg));
9047             if(macPucchCfg->multiCsiCfg == NULLP)
9048             {
9049                DU_LOG("\nERROR --> F1AP : Failed to extract multiCsiCfg in  extractPucchCfg()");
9050                return RFAILED;
9051             }
9052             memset(macPucchCfg->multiCsiCfg, 0, sizeof(PucchMultiCsiCfg));
9053             macPucchCfg->multiCsiCfg->multiCsiResrcListCount = cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.count;
9054             for(arrIdx =0; arrIdx < macPucchCfg->multiCsiCfg->multiCsiResrcListCount; arrIdx++)
9055             {
9056                macPucchCfg->multiCsiCfg->multiCsiResrcList[arrIdx] =\
9057                  *cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.array[arrIdx];
9058             }
9059          }
9060
9061          /* Dl_DataToUL_ACK */
9062          if(cuPucchCfg->choice.setup->dl_DataToUL_ACK)
9063     {
9064        if(storedPucchCfg)
9065        {
9066           if(storedPucchCfg->dlDataToUlAck)
9067           {
9068              macPucchCfg->dlDataToUlAck = storedPucchCfg->dlDataToUlAck;
9069           }
9070           else
9071           {
9072             DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
9073           }
9074        }
9075        else
9076        {
9077           DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
9078        }
9079        if(macPucchCfg->dlDataToUlAck == NULLP)
9080        {
9081           DU_LOG("\nERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
9082           return RFAILED;
9083        }
9084        memset(macPucchCfg->dlDataToUlAck, 0, sizeof(PucchDlDataToUlAck));
9085        macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount = cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.count;
9086        for(arrIdx = 0; arrIdx < macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount; arrIdx++)
9087        {
9088           macPucchCfg->dlDataToUlAck->dlDataToUlAckList[arrIdx] =\
9089           *cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.array[arrIdx];
9090        }
9091          }
9092
9093          /* Power Control */
9094          if(cuPucchCfg->choice.setup->pucch_PowerControl)
9095          {
9096             DU_ALLOC_SHRABL_BUF(macPucchCfg->powerControl, sizeof(PucchPowerControl));
9097             if(macPucchCfg->powerControl == NULLP)
9098             {
9099                DU_LOG("\nERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
9100                return RFAILED;
9101             }
9102             extractPucchPowerControl(macPucchCfg->powerControl,\
9103                cuPucchCfg->choice.setup->pucch_PowerControl);
9104          }
9105       }
9106    }
9107    return ROK;
9108 }
9109
9110 /*******************************************************************
9111  *
9112  * @brief Fills ServingCellReconfig received by CU
9113  *
9114  * @details
9115  *
9116  *    Function : extractSpCellDedicatedCfg
9117  *
9118  *    Functionality: Fills ServingCellReconfig received  by CU
9119  *
9120  * @params[in] ServingCellConfig_t *cuSrvCellCfg = Information which is send by
9121  *                  CU, which we have stored in F1UeContextSetupDb,
9122  *             ServCellCfgInfo *macSrvCellCfg = Used to Store the information
9123  *                  which  needs to send in other layer, as well as this can be the
9124  *                  variable which stores the information in DuCb,
9125  *             ServCellCfgInfo *storedSrvCellCfg = Null in case of sending the
9126  *                  information to other layer else it will have ServCellCfgInfo which
9127  *                  we have stored in copyOfmacUeCfg.
9128  * @return ROK/RFAILD
9129  *
9130  * ****************************************************************/
9131 uint8_t extractSpCellDedicatedCfg(ServingCellConfig_t *cuSrvCellCfg, ServCellCfgInfo *macSrvCellCfg,\
9132 ServCellCfgInfo *storedSrvCellCfg)
9133 {
9134    uint8_t ret = ROK;
9135    BWP_DownlinkDedicated_t *dlBwp = NULLP;
9136    BWP_UplinkDedicated_t   *ulBwp = NULLP;
9137
9138    if(cuSrvCellCfg->initialDownlinkBWP)
9139    {
9140       dlBwp = ((BWP_DownlinkDedicated_t *)(cuSrvCellCfg->initialDownlinkBWP));
9141       if(dlBwp->pdcch_Config)
9142       {
9143          if(dlBwp->pdcch_Config->choice.setup)
9144          {
9145             macSrvCellCfg->initDlBwp.pdcchPresent = true;
9146             extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
9147          }
9148       }
9149       if(dlBwp->pdsch_Config)
9150       {
9151          if(dlBwp->pdsch_Config->choice.setup)
9152          {
9153             macSrvCellCfg->initDlBwp.pdschPresent = true;
9154
9155             if(storedSrvCellCfg)
9156             {
9157                if(!storedSrvCellCfg->initDlBwp.pdschPresent)
9158                {
9159                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
9160                }
9161                else
9162                {
9163                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg,\
9164                         &storedSrvCellCfg->initDlBwp.pdschCfg);
9165                }
9166             }
9167             else
9168             {
9169                extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
9170             }
9171          }
9172       }
9173    }
9174    if(cuSrvCellCfg->firstActiveDownlinkBWP_Id)
9175       macSrvCellCfg->firstActvDlBwpId = *(cuSrvCellCfg->firstActiveDownlinkBWP_Id);
9176    if(cuSrvCellCfg->defaultDownlinkBWP_Id)
9177       macSrvCellCfg->defaultDlBwpId = *(cuSrvCellCfg->defaultDownlinkBWP_Id);
9178    if(cuSrvCellCfg->bwp_InactivityTimer)
9179    {
9180       if(macSrvCellCfg->bwpInactivityTmr)
9181       {
9182          memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
9183       }
9184       else
9185       {
9186          macSrvCellCfg->bwpInactivityTmr = NULLP;
9187          DU_ALLOC_SHRABL_BUF(macSrvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
9188          if(macSrvCellCfg->bwpInactivityTmr)
9189          {
9190             memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
9191          }
9192          else
9193          {
9194             DU_LOG("\nERROR  --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
9195             return RFAILED;
9196          }
9197       }
9198    }
9199    if(cuSrvCellCfg->pdsch_ServingCellConfig)
9200    {
9201       if(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup)
9202       {
9203          ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
9204          if(ret == RFAILED)
9205          {
9206             DU_LOG("\nERROR --> F1AP : Failed at extractPdschServingCellCfg()");
9207             return RFAILED;
9208          }
9209       }
9210    }
9211    if(cuSrvCellCfg->uplinkConfig)
9212    {
9213       if(cuSrvCellCfg->uplinkConfig->initialUplinkBWP)
9214       {
9215          ulBwp = ((BWP_UplinkDedicated_t *)(cuSrvCellCfg->uplinkConfig->initialUplinkBWP));
9216          if(ulBwp->pusch_Config)
9217          {
9218             macSrvCellCfg->initUlBwp.puschPresent = true;
9219             extractPuschCfg(ulBwp->pusch_Config, &macSrvCellCfg->initUlBwp.puschCfg);
9220          }
9221          if(ulBwp->pucch_Config)
9222          {
9223             macSrvCellCfg->initUlBwp.pucchPresent = true;
9224             memset(&macSrvCellCfg->initUlBwp.pucchCfg, 0, sizeof(PucchCfg));
9225             if(storedSrvCellCfg)
9226             {
9227                if(!storedSrvCellCfg->initUlBwp.pucchPresent)
9228                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
9229                else
9230                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg,\
9231                   &storedSrvCellCfg->initUlBwp.pucchCfg);
9232             }
9233             else
9234             {
9235                extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
9236             }
9237          }
9238       }
9239       if(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id)
9240          macSrvCellCfg->firstActvUlBwpId = *(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id);
9241    }
9242    return ret;
9243 }
9244 /*******************************************************************
9245  *
9246  * @brief Fills Reconfig Cell group Info received by CU
9247  *
9248  * @details
9249  *
9250  *    Function : extractUeReCfgCellInfo
9251  *
9252  *    Functionality: Fills Reconfig Cell group Info received by CU
9253  *
9254  * @params[in] CellGroupConfigRrc_t *cellGrp = CellGroupConfigRrc_t information which
9255  *                       is send by CU, which we have stored in F1UeContextSetupDb
9256  *             MacUeCfg *MacUeCfg = Used to Store the information,
9257  *                      which needs to send in other layer, as well as this can be
9258  *                      the variable which stores the information in DuCb,
9259  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
9260  *                      information to other layer else it will have copyOfmacUeCfg
9261  *                      which we have stored in F1UeContextSetupDb.
9262  *
9263  * @return ROK/RFAILED
9264  *
9265  * ****************************************************************/
9266 uint8_t extractUeReCfgCellInfo(CellGroupConfigRrc_t *cellGrp, MacUeCfg *macUeCfg, MacUeCfg *storedMacUeCfg)
9267 {
9268    uint8_t ret = ROK;
9269    MAC_CellGroupConfig_t     *macCellGroup = NULLP;
9270    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
9271    SpCellConfig_t            *spcellCfg = NULLP;
9272    ServingCellConfig_t       *servCellCfg = NULLP;
9273
9274    if(cellGrp)
9275    {
9276       /* Fill MacCell Group Reconfig  */
9277       if(cellGrp->mac_CellGroupConfig)
9278       {
9279          macUeCfg->macCellGrpCfgPres = true;
9280          macCellGroup = ((MAC_CellGroupConfig_t *)(cellGrp->mac_CellGroupConfig));
9281          if(macCellGroup->schedulingRequestConfig)
9282          {
9283             extractSchReqReConfig(macCellGroup->schedulingRequestConfig, &macUeCfg->macCellGrpCfg.schReqCfg);
9284          }
9285          if(macCellGroup->tag_Config)
9286          {
9287             extractTagReconfig(macCellGroup->tag_Config, &macUeCfg->macCellGrpCfg.tagCfg);
9288          }
9289          if(macCellGroup->bsr_Config)
9290          {
9291             macUeCfg->macCellGrpCfg.bsrTmrCfg.periodicTimer = macCellGroup->bsr_Config->periodicBSR_Timer;
9292             macUeCfg->macCellGrpCfg.bsrTmrCfg.retxTimer     = macCellGroup->bsr_Config->retxBSR_Timer;
9293             if(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer)
9294             {
9295                macUeCfg->macCellGrpCfg.bsrTmrCfg.srDelayTimer  =\
9296                *(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer);
9297             }
9298          }
9299          if(macCellGroup->phr_Config)
9300          {
9301             if(macCellGroup->phr_Config->present == MAC_CellGroupConfig__phr_Config_PR_setup)
9302             {
9303                macUeCfg->macCellGrpCfg.phrCfgSetupPres = true;
9304                if(macCellGroup->phr_Config->choice.setup)
9305                {
9306                   macUeCfg->macCellGrpCfg.phrCfg.periodicTimer     = \
9307                   macCellGroup->phr_Config->choice.setup->phr_PeriodicTimer;
9308                   macUeCfg->macCellGrpCfg.phrCfg.prohibitTimer     = \
9309                   macCellGroup->phr_Config->choice.setup->phr_ProhibitTimer;
9310                   macUeCfg->macCellGrpCfg.phrCfg.txPowerFactor     = \
9311                   macCellGroup->phr_Config->choice.setup->phr_Tx_PowerFactorChange;
9312                   macUeCfg->macCellGrpCfg.phrCfg.multiplePHR       = \
9313                   macCellGroup->phr_Config->choice.setup->multiplePHR;
9314                   macUeCfg->macCellGrpCfg.phrCfg.dummy             = \
9315                   macCellGroup->phr_Config->choice.setup->dummy;
9316                   macUeCfg->macCellGrpCfg.phrCfg.phrType2OtherCell = \
9317                   macCellGroup->phr_Config->choice.setup->phr_Type2OtherCell;
9318                   macUeCfg->macCellGrpCfg.phrCfg.phrOtherCG        = \
9319                   macCellGroup->phr_Config->choice.setup->phr_ModeOtherCG;
9320                }
9321             }
9322          }
9323       }
9324       /* Fill Physical Cell Group Reconfig */
9325       if(cellGrp->physicalCellGroupConfig)
9326       {
9327          macUeCfg->phyCellGrpCfgPres = true;
9328          phyCellGrpCfg = ((PhysicalCellGroupConfig_t *)(cellGrp->physicalCellGroupConfig));
9329          if(phyCellGrpCfg->p_NR_FR1)
9330          {
9331             if(*(phyCellGrpCfg->p_NR_FR1) != macUeCfg->phyCellGrpCfg.pNrFr1)
9332                macUeCfg->phyCellGrpCfg.pNrFr1 = *(phyCellGrpCfg->p_NR_FR1);
9333          }
9334          macUeCfg->phyCellGrpCfg.pdschHarqAckCodebook = phyCellGrpCfg->pdsch_HARQ_ACK_Codebook;
9335       }
9336       /* Fill SpCell Reconfig */
9337       if(cellGrp->spCellConfig)
9338       {
9339          macUeCfg->spCellCfgPres = true;
9340          spcellCfg = ((SpCellConfig_t *)(cellGrp->spCellConfig));
9341          if(spcellCfg->servCellIndex)
9342          {
9343             macUeCfg->spCellCfg.servCellIdx = *(spcellCfg->servCellIndex);
9344          }
9345          /* Fill Serving cell Reconfig info */
9346          if(cellGrp->spCellConfig->spCellConfigDedicated)
9347          {
9348             servCellCfg = ((ServingCellConfig_t *)(cellGrp->spCellConfig->spCellConfigDedicated));
9349             if(storedMacUeCfg)
9350             {
9351                if(!storedMacUeCfg->spCellCfgPres)
9352                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
9353                else
9354                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg,\
9355                         &storedMacUeCfg->spCellCfg.servCellCfg);
9356             }
9357             else
9358             {
9359                ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
9360             }
9361             if(ret == RFAILED)
9362             {
9363                DU_LOG("\nERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
9364             }
9365          }
9366       }
9367    }
9368    return ret;
9369 }
9370 /*******************************************************************
9371 *
9372 * @brief free the memory allocated by decoder
9373 *
9374 * @details
9375 *
9376 *    Function : freeAperDecodeNrcgi
9377 *
9378 *    Functionality: Free Nrcgi values
9379 *
9380 * @params[in] NRCGI_t *nrcgi
9381 * @return void
9382 *
9383 * ****************************************************************/
9384
9385
9386 void freeAperDecodeNrcgi(NRCGI_t *nrcgi)
9387 {
9388     if(nrcgi->pLMN_Identity.buf != NULLP)
9389     {
9390        free(nrcgi->pLMN_Identity.buf);
9391     }
9392     if(nrcgi->nRCellIdentity.buf != NULLP)
9393     {
9394        free(nrcgi->nRCellIdentity.buf);
9395     }
9396 }
9397 /*******************************************************************
9398 *
9399 * @brief free the memory allocated by decoder
9400 *
9401 * @details
9402 *
9403 *    Function : freeAperDecodeCuToDuInfo
9404 *
9405 *    Functionality:  Free Cu To Du Information
9406 *
9407 * @params[in] CUtoDURRCInformation_t *rrcMsg
9408 * @return void
9409 *
9410 * ****************************************************************/
9411
9412
9413 void freeAperDecodeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
9414 {
9415    uint8_t ieIdx =0;
9416    uint8_t arrIdx =0;
9417
9418    if(rrcMsg->uE_CapabilityRAT_ContainerList)
9419    {
9420       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
9421          free(rrcMsg->uE_CapabilityRAT_ContainerList->buf);
9422       free(rrcMsg->uE_CapabilityRAT_ContainerList);
9423    }
9424
9425    if(rrcMsg->iE_Extensions)
9426    {
9427       if(rrcMsg->iE_Extensions->list.array)
9428       {
9429          for(ieIdx= 0; ieIdx < rrcMsg->iE_Extensions->list.count; ieIdx++)
9430          {
9431             if(rrcMsg->iE_Extensions->list.array[ieIdx])
9432             {
9433                switch(rrcMsg->iE_Extensions->list.array[ieIdx]->id)
9434                {
9435                   case ProtocolIE_ID_id_CellGroupConfig:
9436                      if(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
9437                      {
9438                         free(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf);
9439                      }
9440                      break;
9441                   default:
9442                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
9443                            rrcMsg->iE_Extensions->list.array[ieIdx]->id);
9444                      break;
9445                }
9446             }
9447          }
9448          for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
9449          {
9450             free(rrcMsg->iE_Extensions->list.array[arrIdx]);
9451          }
9452          free(rrcMsg->iE_Extensions->list.array);
9453
9454       }
9455
9456       free(rrcMsg->iE_Extensions);
9457    }
9458 }
9459 /*******************************************************************
9460 *
9461 * @brief free the memory allocated by decoder
9462 *
9463 * @details
9464 *
9465 *    Function : freeAperDecodeSplCellList
9466 *
9467 *    Functionality: Free Spl Cell List
9468                     where memory allocated by aper_decoder
9469 *
9470 * @params[in]  SCell_ToBeSetup_List_t *spCellLst
9471 * @return void
9472 *
9473 * ****************************************************************/
9474
9475
9476 void freeAperDecodeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
9477 {
9478     uint8_t  cellIdx =0;
9479
9480     if(spCellLst->list.array != NULLP)
9481     {
9482        for(cellIdx=0; cellIdx<spCellLst->list.count; cellIdx++)
9483        {
9484           if(cellIdx==0&&spCellLst->list.array[cellIdx]!=NULLP)
9485           {
9486              freeAperDecodeNrcgi(&spCellLst->list.array[cellIdx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
9487           }
9488           if(spCellLst->list.array[cellIdx]!=NULLP)
9489           {
9490              free(spCellLst->list.array[cellIdx]);
9491           }
9492        }
9493        free(spCellLst->list.array);
9494     }
9495 }
9496 /*******************************************************************
9497 *
9498 * @brief free the memory allocated by decoder
9499 *
9500 * @details
9501 *
9502 *    Function : freeAperDecodeSRBSetup
9503 *
9504 *    Functionality: added free part for the memory allocated by aper_decoder
9505 *
9506 * @params[in] SRBs_ToBeSetup_List_t *srbSet
9507 * @return void
9508 *
9509 ****************************************************************/
9510
9511
9512 void freeAperDecodeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
9513 {
9514     uint8_t srbIdx =0;
9515     if(srbSet->list.array != NULLP)
9516     {
9517        for(srbIdx=0; srbIdx<srbSet->list.count; srbIdx++)
9518        {
9519           if(srbSet->list.array[srbIdx]!=NULLP)
9520           {
9521              free(srbSet->list.array[srbIdx]);
9522           }
9523        }
9524        free(srbSet->list.array);
9525     }
9526 }
9527
9528 /*******************************************************************
9529 *
9530 * @brief free the memory allocated by decoder
9531 *
9532 * @details
9533 *
9534 *    Function : freeAperDecodeULTnlInfo
9535 *
9536 *    Functionality: added free part for the memory allocated by aper_decoder
9537 *
9538 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
9539 * @return void
9540 *
9541 * ****************************************************************/
9542
9543
9544 void freeAperDecodeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
9545 {
9546    uint8_t ulIdx=0;
9547    if(ulInfo->list.array != NULLP)
9548    {
9549       for(ulIdx=0; ulIdx<ulInfo->list.count; ulIdx++)
9550       {
9551          if(ulIdx==0&&ulInfo->list.array[ulIdx]!=NULLP)
9552          {
9553             if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
9554             {
9555                if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9556                      transportLayerAddress.buf != NULLP)
9557                {
9558                   if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
9559                         !=NULLP)
9560                   {
9561                      free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf);
9562                   }
9563                   free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9564                         transportLayerAddress.buf);
9565                }
9566                free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel);
9567             }
9568          }
9569          if(ulInfo->list.array[ulIdx]!=NULLP)
9570          {
9571             free(ulInfo->list.array[ulIdx]);
9572          }
9573       }
9574       free(ulInfo->list.array);
9575    }
9576 }
9577 /*******************************************************************
9578 *
9579 * @brief free the memory allocated by decoder
9580 *
9581 * @details
9582 *
9583 *    Function : freeAperDecodeDRBSetup
9584 *
9585 *    Functionality: free DRBSetup which is allocated by decoder
9586 *
9587 * @params[in]  DRBs_ToBeSetup_List_t *drbSet
9588 * @return void
9589 *
9590 * ****************************************************************/
9591
9592 void freeAperDecodeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
9593 {
9594    DRBs_ToBeSetup_Item_t *drbSetItem = NULLP;
9595    uint8_t  flowIdx =0;
9596    uint8_t  drbIdx =0;
9597
9598    if(drbSet->list.array != NULLP)
9599    {
9600       for(drbIdx=0; drbIdx<drbSet->list.count; drbIdx++)
9601       {
9602          if(drbIdx==0&&drbSet->list.array[drbIdx] != NULLP)
9603          {
9604             drbSetItem =&drbSet->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
9605             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
9606             {
9607                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9608                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
9609                {
9610                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9611                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9612                   {
9613                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9614                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9615                      {
9616
9617                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
9618                         {
9619
9620                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
9621                            {
9622
9623                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->\
9624                                     buf!=NULLP)
9625                               {
9626
9627                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
9628                                        flows_Mapped_To_DRB_List.list.array != NULLP)
9629                                  {
9630
9631                                     for(flowIdx=0;flowIdx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9632                                           DRB_Information.flows_Mapped_To_DRB_List.list.count; flowIdx++)
9633                                     {
9634
9635                                        if(flowIdx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9636                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9637                                        {
9638                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9639                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9640                                                 qoSFlowLevelQoSParameters.\
9641                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
9642                                           {
9643                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9644                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9645                                                    qoSFlowLevelQoSParameters.\
9646                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9647                                              {
9648
9649                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9650                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9651                                                       qoSFlowLevelQoSParameters.\
9652                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9653                                                 {
9654
9655
9656                                                    free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9657                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9658                                                          qoSFlowLevelQoSParameters.\
9659                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9660                                                 }
9661
9662                                                 free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9663                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9664                                                       qoSFlowLevelQoSParameters.\
9665                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9666                                              }
9667
9668                                              free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9669
9670                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9671                                                    qoSFlowLevelQoSParameters.\
9672                                                    qoS_Characteristics.choice.non_Dynamic_5QI);
9673                                           }
9674                                        }
9675                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9676                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9677                                        {
9678
9679                                           free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9680                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]);
9681                                        }
9682                                     }
9683
9684                                     free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9685                                           DRB_Information.flows_Mapped_To_DRB_List.list.array);
9686                                  }
9687
9688                                  free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9689                                        DRB_Information.sNSSAI.sD->buf);
9690                               }
9691
9692                               free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD);
9693                            }
9694
9695                            free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf);
9696
9697                         }
9698
9699                         free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9700
9701                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9702                      }
9703
9704                      free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9705                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9706                   }
9707
9708                   free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9709                         qoS_Characteristics.choice.non_Dynamic_5QI);
9710                }
9711                free(drbSetItem->qoSInformation.choice.choice_extension);
9712             }
9713             freeAperDecodeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
9714             if(drbSetItem->uLConfiguration)
9715             {
9716                free(drbSetItem->uLConfiguration);
9717             }
9718          }
9719          if(drbSet->list.array[drbIdx]!=NULLP)
9720          {
9721             free(drbSet->list.array[drbIdx]);
9722          }
9723       }
9724       free(drbSet->list.array);
9725    }
9726 }
9727
9728
9729 /*******************************************************************
9730  *
9731  * @brief builds Mac Cell Cfg
9732  *
9733  * @details
9734  *
9735  *    Function : procUeReCfgCellInfo
9736  *
9737  *    Functionality: builds Mac Cell Cfg
9738  *
9739  * @params[in] MacUeCfg *macUeCfgToSend = Used to Store the information which
9740  *                       needs to send in other layer, as well as this can be
9741  *                       the variable which stores the information in DuCb.
9742  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
9743  *                       information to other layer else it will have copyOfmacUeCfg
9744  *                       which we have stored in F1UeContextSetupDb
9745  *             void *cellInfo = CellGroupConfigRrc_t information which is send
9746  *                        by CU, which we have stored in F1UeContextSetupDb
9747  *
9748  * @return void
9749  *
9750  * ****************************************************************/
9751 uint8_t procUeReCfgCellInfo(MacUeCfg *macUeCfgToSend,MacUeCfg *storedMacUeCfg, void *cellInfo)
9752 {
9753    uint8_t ret = ROK;
9754    CellGroupConfigRrc_t *cellGrp = NULLP;
9755
9756    if(cellInfo)
9757    {
9758       cellGrp = (CellGroupConfigRrc_t *)cellInfo;
9759       ret = extractUeReCfgCellInfo(cellGrp, macUeCfgToSend, storedMacUeCfg);
9760       if(ret == RFAILED)
9761          DU_LOG("\nERROR  -->  F1AP : Failed at procUeReCfgCellInfo()");
9762    }
9763    if(ret == RFAILED)
9764    {
9765       freeUeReCfgCellGrpInfo(macUeCfgToSend);
9766    }
9767    return ret;
9768 }
9769
9770 /*******************************************************************
9771  *
9772  * @brief Filling modulation info in mac ue cfg
9773  *
9774  * @details
9775  *
9776  *    Function : duFillModulationDetails
9777  *
9778  *    Functionality: Filling modulation info in mac ue cfg
9779  *
9780  * @params[in] MAC UE Config to be updated
9781  *             Current UE configuration
9782  *             UE NR capability from CU
9783  * @return ROK     - success
9784  *         RFAILED - failure
9785  *
9786  * ****************************************************************/
9787 void duFillModulationDetails(MacUeCfg *ueCfg, MacUeCfg *oldUeCfg, void *ueCap)
9788 {
9789    UE_NR_Capability_t *ueNrCap=NULLP;
9790
9791    if(!ueCap)
9792    {
9793       memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9794       memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9795    }
9796    else
9797    {
9798       ueNrCap = (UE_NR_Capability_t *)ueCap;
9799
9800       /* Filling DL modulation info */
9801       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsDownlinkPerCC && \
9802          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0] && \
9803          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL)
9804       {
9805          switch(*(ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL))
9806          {
9807             case ModulationOrder_qpsk:
9808                {
9809                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
9810                   break;
9811                }
9812             case ModulationOrder_qam16:
9813                {
9814                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM16;
9815                   break;
9816                }
9817             case ModulationOrder_qam64:
9818                {
9819                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM64;
9820                   ueCfg->dlModInfo.mcsIndex = PDSCH_MCS_INDEX;
9821                   ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64;
9822                   break;
9823                }
9824             case ModulationOrder_qam256:
9825                {
9826                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM256;
9827                   break;
9828                }
9829             default:
9830                {
9831                   DU_LOG("\nERROR  -->  DU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
9832                   memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9833                   break;
9834                }
9835          }
9836       }
9837       else
9838       {
9839          memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9840       }
9841
9842       /* Filling UL modulation info */
9843       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsUplinkPerCC && \
9844          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0] && \
9845          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL)
9846       {
9847          switch(*(ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL))
9848          {
9849             case ModulationOrder_qpsk:
9850                {
9851                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
9852                   break;
9853                }
9854             case ModulationOrder_qam16:
9855                {
9856                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM16;
9857                   ueCfg->ulModInfo.mcsIndex = PUSCH_MCS_INDEX;
9858                   ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64;
9859                   break;
9860                }
9861             case ModulationOrder_qam64:
9862                {
9863                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM64;
9864                   break;
9865                }
9866             case ModulationOrder_qam256:
9867                {
9868                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM256;
9869                   break;
9870                }
9871             default:
9872                {
9873                   DU_LOG("\nERROR  -->  DU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
9874                   memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9875                   break;
9876                }
9877          }
9878       }
9879       else
9880       {
9881          memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9882       }
9883    }
9884 }
9885
9886 /*******************************************************************
9887  *
9888  * @brief Function to extract cellGrp Info present in cutoDu cont
9889  *
9890  * @details
9891  *
9892  *    Function : extractCellGrpInfo
9893  *
9894  *    Functionality: Function to extract cellGrp Info present
9895  *                   in cutoDu cont
9896  *
9897  * @params[in] ProtocolExtensionContainer_4624P16_t pointer
9898  *
9899  * @return CellGroupConfigRrc_t *
9900  *
9901  * ****************************************************************/
9902
9903 CellGroupConfigRrc_t *extractCellGrpInfo(ProtocolExtensionContainer_4624P16_t *protocolIeExtn,\
9904       DuUeCfg *ueCfgDb)
9905 {
9906    uint8_t idx2 =0;
9907    uint16_t id =0;
9908    uint16_t recvBufLen =0;
9909    CellGroupConfigRrc_t *cellGrpCfg = NULLP;
9910    CUtoDURRCInformation_ExtIEs_t *extIeInfo = NULLP;
9911    asn_dec_rval_t rval; /* Decoder return value */
9912    memset(&rval, 0, sizeof(asn_dec_rval_t));
9913
9914    if(protocolIeExtn)
9915    {
9916       for(idx2 = 0; idx2 < protocolIeExtn->list.count; idx2++)
9917       {
9918          extIeInfo = ((CUtoDURRCInformation_ExtIEs_t *)(protocolIeExtn->list.array[idx2]));
9919          id = extIeInfo->id;
9920          switch(id)
9921          {
9922             case ProtocolIE_ID_id_CellGroupConfig:
9923             {
9924                recvBufLen = extIeInfo->extensionValue.choice.CellGroupConfig.size;
9925                /* decoding the CellGroup Buf received */
9926                DU_ALLOC(cellGrpCfg, sizeof(CellGroupConfigRrc_t));
9927                if(cellGrpCfg)
9928                {
9929                   memset(cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
9930                   rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfg,
9931                      extIeInfo->extensionValue.choice.CellGroupConfig.buf, recvBufLen, 0, 0);
9932                   if(rval.code == RC_FAIL || rval.code == RC_WMORE)
9933                   {
9934                      DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
9935                      return NULLP;
9936                   }
9937                   xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfg);
9938                   if(extractRlcCfgToAddMod(cellGrpCfg->rlc_BearerToAddModList, ueCfgDb))
9939                      return NULLP;
9940                }
9941                break;
9942             }
9943             default:
9944                DU_LOG("\nERROR  -->  F1AP : Invalid IE received CUtoDURRCInformation:%d at decodeCellGrpCfg()", id);
9945                break;
9946          }
9947       }
9948    }
9949    return cellGrpCfg;
9950 }
9951
9952 /*******************************************************************
9953  *
9954  * @brief Fills Srb List received by CU
9955  *
9956  * @details
9957  *
9958  *    Function : procSrbListToSetup
9959  *
9960  *    Functionality: Fills Srb List received  by CU
9961  *
9962  * @params[in] SRBs_ToBeSetup_Item_t *cuSrbItem
9963  *             LcCfg pointer
9964  *             RlcBearerCfg pointer
9965  * @return void
9966  *
9967  * ****************************************************************/
9968 uint8_t procSrbListToSetup(SRBs_ToBeSetup_Item_t * srbItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd)
9969 {
9970    uint8_t ret = ROK;
9971
9972    /* Filling RLC INFO */
9973    procRlcLcCfg(srbItem->sRBID, srbItem->sRBID, RB_TYPE_SRB, RLC_AM, CONFIG_ADD, NULL, rlcLcToAdd);
9974
9975    /* Filling MAC INFO */
9976    ret = procMacLcCfg(srbItem->sRBID, RB_TYPE_SRB, CONFIG_ADD, NULL,NULL, NULL, NULL, macLcToAdd, NULL);
9977    if(ret == RFAILED)
9978    {
9979       DU_LOG("\nERROR  -->  F1AP : Failed at MAC LC Cfg in procSrbListToSetup()");
9980       return ret;
9981    }
9982    return ret;
9983 }
9984
9985
9986
9987 /*******************************************************************
9988  *
9989  * @brief extract Srb List received by CU
9990  *
9991  * @details
9992  *
9993  *    Function : extractSrbListToSetup
9994  *
9995  *    Functionality: extract Srb List received by CU
9996  *                   for both MAC and RLC
9997  *
9998  * @params[in] SRBs_ToBeSetup_Item_t pointer
9999  *             DuUeCfg pointer
10000  * @return ROK/RFAIED
10001  *
10002  * ****************************************************************/
10003
10004 uint8_t extractSrbListToSetup(SRBs_ToBeSetup_List_t *srbCfg, DuUeCfg *ueCfgDb)
10005 {
10006    uint8_t ret, srbIdx;
10007    SRBs_ToBeSetup_Item_t *srbItem = NULLP;
10008
10009    if(srbCfg)
10010    {
10011       for(srbIdx = 0; srbIdx < srbCfg->list.count; srbIdx++)
10012       {
10013          srbItem = &srbCfg->list.array[srbIdx]->value.choice.SRBs_ToBeSetup_Item;
10014          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
10015          {
10016             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in MAC");
10017             ret = RFAILED;
10018             break;
10019          }
10020          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
10021          {
10022             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in RLC");
10023             ret = RFAILED;
10024             break;
10025          }
10026          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
10027          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
10028          ret = procSrbListToSetup(srbItem, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
10029             &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs]);
10030          ueCfgDb->numRlcLcs++;
10031          ueCfgDb->numMacLcs++;
10032          DU_LOG("\nDEBUG --> DUAPP: extractSrbListToSetup: SRBID: %d [RLC,MAC,NumDrb]:[%x,%x,%x]",\
10033                             srbItem->sRBID, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
10034          if(ret == RFAILED)
10035          {
10036             DU_LOG("\nERROR  -->  F1AP:  Failed at extractSrbListToSetup()");
10037             break;
10038          }
10039       }
10040    }
10041    else
10042       ret = RFAILED;
10043
10044    return ret;
10045 }
10046
10047 /*******************************************************************
10048  *
10049  * @brief Fills Drb List received by CU
10050  *
10051  * @details
10052  *
10053  *    Function : procDrbListToSetupMod
10054  *
10055  *    Functionality: Fills Drb List received by CU
10056  *                   for both MAC and RLC
10057  *
10058  * @params[in] SRBs_ToBeSetup_Item_t pointer
10059  *             LcCfg pointer,
10060  *             RlcBearerCfg pointer
10061  * @return void
10062  *
10063  * ****************************************************************/
10064
10065 uint8_t procDrbListToSetupMod(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbItem,\
10066 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd, UpTnlCfg *upTnlInfo)
10067 {
10068
10069    if(drbItem != NULLP)
10070    {
10071       /* Filling RLC INFO */
10072       procRlcLcCfg(drbItem->dRBID, lcId, RB_TYPE_DRB, drbItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd);
10073
10074       /* Filling MAC INFO */
10075       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, drbItem, NULL, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
10076       {
10077          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
10078          return RFAILED;
10079       }
10080    }
10081    else if(drbSetupModItem != NULLP)
10082    {
10083       procRlcLcCfg(drbSetupModItem->dRBID, lcId, RB_TYPE_DRB, drbSetupModItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd);
10084
10085       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, NULL, drbSetupModItem, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
10086       {
10087          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
10088          return RFAILED;
10089       }
10090    }
10091    else if(drbModItem != NULLP)
10092    {
10093       /* Drb to Mod IEs doesnot have rlcMode to be modified
10094        * in ASN. Hence no change in RLC configurations */
10095       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_MOD, NULL, NULL, drbModItem, NULL, macLcToAdd, upTnlInfo) != ROK)
10096       {
10097          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
10098          return RFAILED;
10099       }
10100    }
10101    return ROK;
10102 }
10103
10104 /*******************************************************************
10105  *
10106  * @brief extract Drb List received by CU
10107  *
10108  * @details
10109  *
10110  *    Function : extractDrbListToSetupMod
10111  *
10112  *    Functionality: extract Drb List received by CU
10113  *                   for both MAC and RLC
10114  *
10115  * @params[in] DRBs_ToBeSetup_Item_t pointer
10116  *             DuUeCfg pointer
10117  * @return ROK/RFAIED
10118  *
10119  * ****************************************************************/
10120
10121 uint8_t extractDrbListToSetupMod(DRBs_ToBeSetup_List_t *drbCfg, DRBs_ToBeSetupMod_List_t *drbSetupModCfg,\
10122  DRBs_ToBeModified_List_t *drbModCfg, uint8_t drbCount, DuUeCfg *ueCfgDb, uint32_t *drbBitMap)
10123 {
10124    uint8_t ret, drbIdx, lcId = 0;
10125    DRBs_ToBeSetup_Item_t *drbItem = NULLP;
10126    DRBs_ToBeSetupMod_ItemIEs_t *drbSetupModItem = NULLP;
10127    DRBs_ToBeModified_ItemIEs_t *drbModItem = NULLP;
10128
10129    ret = ROK;
10130    if(drbCount > 0)
10131    {
10132       for(drbIdx = 0; drbIdx < drbCount; drbIdx++)
10133       {
10134          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
10135          {
10136             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in MAC at extractDrbListToSetupMod()");
10137             ret = RFAILED;
10138             break;
10139          }
10140          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
10141          {
10142             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in RLC at extractDrbListToSetupMod()");
10143             ret = RFAILED;
10144             break;
10145          }
10146          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
10147          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
10148
10149          if(drbModCfg != NULLP)
10150          {
10151             drbModItem = (DRBs_ToBeModified_ItemIEs_t *) drbModCfg->list.array[drbIdx];
10152             lcId = fetchLcId(drbModItem->value.choice.DRBs_ToBeModified_Item.dRBID);
10153             if(lcId < MIN_DRB_LCID)
10154             {
10155                DU_LOG("\nERROR  --> F1AP : Failed fetching LCID %d in extractDrbListToSetupMod() for Modified List", lcId);
10156                break;
10157             }
10158             ret = procDrbListToSetupMod(lcId, NULL, NULL, &(drbModItem->value.choice.DRBs_ToBeModified_Item),\
10159             &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs],\
10160             &ueCfgDb->upTnlInfo[ueCfgDb->numDrb]);
10161             if(ret == RFAILED)
10162             {
10163                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for Modified List");
10164                break;
10165             }
10166
10167          }
10168          else
10169          {
10170             lcId = getDrbLcId(drbBitMap);
10171             if(lcId == RFAILED)
10172             {
10173                DU_LOG("\nERROR  -->  F1AP :  InCorrect LCID extractDrbListToSetupMod()");
10174                ret = RFAILED;
10175                break;
10176             }
10177             if(drbCfg != NULL)
10178             {
10179                drbItem = &drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
10180                ret = procDrbListToSetupMod(lcId, drbItem, NULL, NULL, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
10181                      &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], &ueCfgDb->upTnlInfo[ueCfgDb->numDrb]);
10182                if(ret == RFAILED)
10183                {
10184                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetup List");
10185                   break;
10186                }
10187             }
10188             else if(drbSetupModCfg != NULL)
10189             {
10190                drbSetupModItem = (DRBs_ToBeSetupMod_ItemIEs_t *) drbSetupModCfg->list.array[drbIdx];
10191                ret = procDrbListToSetupMod(lcId, NULL, &(drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item), NULL,\
10192                      &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs],\
10193                      &ueCfgDb->upTnlInfo[ueCfgDb->numDrb]);
10194                if(ret == RFAILED)
10195                {
10196                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetupMod List");
10197                   break;
10198                }
10199             }
10200             ueCfgDb->numRlcLcs++;
10201          }
10202          ueCfgDb->numMacLcs++;
10203          ueCfgDb->numDrb++;
10204
10205          DU_LOG("\nDEBUG --> DUAPP: extractDrbListToSetupMod:lcId:%x ,BitMap:%x, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
10206                             lcId,*drbBitMap, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
10207          if(ret == RFAILED)
10208          {
10209             DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod()");
10210             break;
10211          }
10212       }
10213    }
10214    else
10215       ret = RFAILED;
10216
10217    return ret;
10218 }
10219
10220 /*******************************************************************
10221  *
10222  * @brief Function to extract Dl RRC Msg received from CU
10223  *
10224  * @details
10225  *
10226  *    Function : extractDlRrcMsg
10227  *
10228  *    Functionality: Function to extract Dl RRC Msg received from CU
10229  *
10230  * @params[in] F1AP message
10231  * @return ROK     - success
10232  *         RFAILED - failure
10233  *
10234  * ****************************************************************/
10235
10236 uint8_t extractDlRrcMsg(uint32_t gnbDuUeF1apId, uint32_t gnbCuUeF1apId, \
10237    F1DlRrcMsg *dlRrcMsg, RRCContainer_t *rrcContainer)
10238 {
10239    uint8_t ret = ROK;
10240    dlRrcMsg->rrcMsgSize = rrcContainer->size;
10241    if(dlRrcMsg->rrcMsgSize > 0)
10242    {
10243       DU_ALLOC_SHRABL_BUF(dlRrcMsg->rrcMsgPdu, dlRrcMsg->rrcMsgSize);
10244       if(!dlRrcMsg->rrcMsgPdu)
10245       {
10246          DU_LOG("\nERROR  --> DU APP : Memory allocation failed for RRC Msg in extractDlRrcMsg()");
10247          ret = RFAILED;
10248       }
10249       else
10250       {
10251          dlRrcMsg->gnbDuUeF1apId = gnbDuUeF1apId;
10252          dlRrcMsg->gnbCuUeF1apId = gnbCuUeF1apId;
10253          dlRrcMsg->srbId = SRB1_LCID;
10254          memcpy(dlRrcMsg->rrcMsgPdu, rrcContainer->buf, dlRrcMsg->rrcMsgSize);
10255       }
10256    }
10257    return ret;
10258 }
10259
10260 /*******************************************************************
10261  *
10262  * @brief Extract UE capability info
10263  *
10264  * @details
10265  *
10266  *    Function : extractUeCapability
10267  *
10268  *    Functionality: Extract UE capability info and stores in ue Cb
10269  *
10270  * @params[in] Octet string of UE capability RAT container list
10271  * @return ROK     - success
10272  *         RFAILED - failure
10273  *
10274  * ****************************************************************/
10275 UE_NR_Capability_t *extractUeCapability(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf, DuUeCb *ueCb)
10276 {
10277    uint8_t  idx;
10278    uint16_t recvBufLen;
10279    asn_dec_rval_t rval;
10280    UE_NR_Capability_t  *ueNrCap = NULLP;
10281    UE_CapabilityRAT_ContainerListRRC_t  *ueCapRatContList = NULLP;
10282
10283    /* Decoding UE Capability RAT Container List */
10284    recvBufLen = ueCapablityListBuf->size;
10285    DU_ALLOC(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10286    if(!ueCapRatContList)
10287    {
10288       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
10289       return NULLP;
10290    }
10291    memset(ueCapRatContList, 0, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10292    memset(&rval, 0, sizeof(asn_dec_rval_t));
10293    rval = aper_decode(0, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, (void **)&ueCapRatContList,
10294           ueCapablityListBuf->buf, recvBufLen, 0, 0);
10295    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10296    {
10297       DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
10298       return NULLP;
10299    }
10300    xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, ueCapRatContList);
10301
10302    /* Free encoded buffer after decoding */
10303
10304    for(idx = 0; idx < ueCapRatContList->list.count; idx++)
10305    {
10306       if(ueCapRatContList->list.array[idx]->rat_Type == RAT_Type_nr)
10307       {
10308          /* Decoding UE NR Capability */
10309           recvBufLen = ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.size;
10310           DU_ALLOC(ueNrCap, sizeof(UE_NR_Capability_t));
10311           if(!ueNrCap)
10312           {
10313              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
10314              DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10315              return NULLP;
10316           }
10317           memset(ueNrCap, 0, sizeof(UE_NR_Capability_t));
10318           memset(&rval, 0, sizeof(asn_dec_rval_t));
10319           rval = aper_decode(0, &asn_DEF_UE_NR_Capability, (void **)&ueNrCap,
10320                  ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf, recvBufLen, 0, 0);
10321           if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10322           {
10323              DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
10324              return NULLP;
10325           }
10326           xer_fprint(stdout, &asn_DEF_UE_NR_Capability, ueNrCap);
10327
10328           /* Free encoded buffer after decoding */
10329           free(ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf);
10330       }
10331       free(ueCapRatContList->list.array[idx]);
10332    }
10333
10334    /* Free Memory*/
10335    free(ueCapRatContList->list.array);
10336    DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10337    return ueNrCap;
10338 }
10339
10340 /*******************************************************************
10341 *
10342 * @brief free UE context setup request from CU
10343 *
10344 * @details
10345 *
10346 *    Function : freeAperDecodeF1UeContextSetupReq
10347 *
10348 *    Functionality: freeing part for the memory allocated by aper_decoder
10349 *
10350 * @params[in] F1AP message
10351 * @return ROK     - success
10352 *         RFAILED - failure
10353 *
10354 * ****************************************************************/
10355 void freeAperDecodeF1UeContextSetupReq(UEContextSetupRequest_t   *ueSetReq)
10356 {
10357    uint8_t ieIdx = 0;
10358
10359    if(ueSetReq->protocolIEs.list.array != NULLP)
10360    {
10361       for(ieIdx = 0; ieIdx < ueSetReq->protocolIEs.list.count; ieIdx++)
10362       {
10363          if(ueSetReq->protocolIEs.list.array[ieIdx])
10364          {
10365             switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
10366             {
10367                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10368                   break;
10369                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10370                   break;
10371                case ProtocolIE_ID_id_SpCell_ID:
10372                   freeAperDecodeNrcgi(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
10373                   break;
10374                case ProtocolIE_ID_id_ServCellIndex:
10375                   break;
10376                case ProtocolIE_ID_id_SpCellULConfigured:
10377                   break;
10378                case ProtocolIE_ID_id_CUtoDURRCInformation:
10379
10380                   freeAperDecodeCuToDuInfo(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation);
10381                   break;
10382                case ProtocolIE_ID_id_SCell_ToBeSetup_List:
10383
10384                   freeAperDecodeSplCellList(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SCell_ToBeSetup_List);
10385                   break;
10386                case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
10387
10388                   freeAperDecodeSRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List);
10389                   break;
10390                case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
10391
10392                   freeAperDecodeDRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List);
10393                   break;
10394                case ProtocolIE_ID_id_RRCContainer:
10395                   {
10396
10397                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf != NULLP)
10398                      {
10399
10400                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
10401                      }
10402                      break;
10403                   }
10404                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10405                   break;
10406                case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
10407                   {
10408                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf)
10409                      {
10410                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf);
10411                      }
10412                      break;
10413                   }
10414                default:
10415                   DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld " ,ueSetReq->protocolIEs.list.array[ieIdx]->id);
10416             }
10417             free(ueSetReq->protocolIEs.list.array[ieIdx]);
10418          }
10419       }
10420       free(ueSetReq->protocolIEs.list.array);
10421    }
10422 }
10423 /*******************************************************************
10424  *
10425  * @brief Process UE context setup request from CU
10426  *
10427  * @details
10428  *
10429  *    Function : procF1UeContextSetupReq
10430  *
10431  *    Functionality: Process UE context setup request from CU
10432  *
10433  * @params[in] F1AP message
10434  * @return ROK     - success
10435  *         RFAILED - failure
10436  *
10437  * ****************************************************************/
10438 uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
10439 {
10440    uint8_t  ret=0, ieIdx=0, ueIdx=0, cellIdx=0;
10441    bool ueCbFound = false;
10442    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0, bitRateSize=0;
10443    DuUeCb   *duUeCb = NULL;
10444    UEContextSetupRequest_t   *ueSetReq = NULL;
10445    DRBs_ToBeSetup_List_t *drbCfg = NULL;
10446
10447    ret = ROK;
10448
10449    ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
10450    for(ieIdx=0; (ieIdx < ueSetReq->protocolIEs.list.count && ret == ROK); ieIdx++)
10451    {
10452       switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
10453       {
10454          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10455             {
10456                gnbCuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
10457                break;
10458             }
10459          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10460             {
10461                gnbDuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
10462                break;
10463             }
10464          case ProtocolIE_ID_id_ServCellIndex:
10465             {
10466                cellIdx = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.ServCellIndex;
10467                for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
10468                {
10469                   if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
10470                         (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
10471                   {
10472                      ueCbFound = true;
10473                      duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
10474                      DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
10475                      if(duUeCb->f1UeDb)
10476                      {
10477                         memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
10478                         duUeCb->f1UeDb->actionType = UE_CTXT_SETUP;
10479                         duUeCb->f1UeDb->cellIdx = cellIdx;
10480                      }
10481                      else
10482                      {
10483                         DU_LOG("\nERROR  -->  F1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
10484                         ret = RFAILED;
10485                      }
10486                      break;
10487                   }
10488                   else
10489                      ueCbFound = false;
10490
10491                }
10492                if(!ueCbFound)
10493                {
10494                   DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
10495                   ret = RFAILED;
10496                }
10497                break;
10498             }
10499          case ProtocolIE_ID_id_SpCellULConfigured:
10500             /* Indicates whether the gNB-CU requests the gNB-DU to configure the uplink as no UL,
10501                UL, SUL or UL+SUL for the indicated cell for the UE */
10502             break;
10503          case ProtocolIE_ID_id_CUtoDURRCInformation:
10504             {
10505                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.uE_CapabilityRAT_ContainerList)
10506                {
10507                   duUeCb->f1UeDb->duUeCfg.ueNrCapability = \
10508                   extractUeCapability(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.\
10509                   uE_CapabilityRAT_ContainerList, duUeCb);
10510                }
10511                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.iE_Extensions)
10512                {
10513                   duUeCb->f1UeDb->duUeCfg.cellGrpCfg = extractCellGrpInfo(ueSetReq->protocolIEs.list.array[ieIdx]->\
10514                         value.choice.CUtoDURRCInformation.iE_Extensions, &duUeCb->f1UeDb->duUeCfg);
10515                   if(!duUeCb->f1UeDb->duUeCfg.cellGrpCfg)
10516                   {
10517                      DU_LOG("\nERROR  -->  F1AP: Failed to extract cell Grp Info");
10518                      //TODO: Update the failure cause in ue context Setup Response
10519                      ret = RFAILED;
10520                   }
10521                }
10522                break;
10523             }
10524          case ProtocolIE_ID_id_SCell_ToBeSetup_List:
10525             {
10526                DU_LOG("\nINFO   -->  DU_APP: Received SCell_ToBeSetup_List but  Not processing the list");
10527                break;
10528             }
10529          case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
10530             {
10531                if(extractSrbListToSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List,\
10532                &duUeCb->f1UeDb->duUeCfg))
10533                {
10534                   DU_LOG("\nERROR  -->  DU APP : Failed at extractSrbListToSetup()");
10535                   //TODO: Update the failure cause in ue context Setup Response
10536                   ret = RFAILED;
10537                }
10538                break;
10539             }
10540          case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
10541             {
10542                   drbCfg = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List;
10543
10544                   if(extractDrbListToSetupMod(drbCfg, NULL, NULL, drbCfg->list.count, &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap))
10545                   {
10546                      DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod()");
10547                      //TODO: Update the failure cause in ue context Setup Response
10548                      ret = RFAILED;
10549                   }
10550                break;
10551             }
10552          case ProtocolIE_ID_id_RRCContainer:
10553             {
10554                /* Filling Dl RRC Msg Info */
10555                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
10556                if(!duUeCb->f1UeDb->dlRrcMsg)
10557                {
10558                   DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
10559                   ret = RFAILED;
10560                }
10561                else
10562                {
10563                   duUeCb->f1UeDb->dlRrcMsgPres = true;
10564                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
10565                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
10566                         &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer);
10567                }
10568                break;
10569             }
10570          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10571             {
10572                if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
10573                {
10574                   duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
10575                }
10576                else
10577                {
10578                   DU_LOG("\nERROR  -->  Ignoring delivery report, since rrcContainer is not present");
10579                }
10580                break;
10581             }
10582          case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
10583             {
10584                /* MaximumBitRate Uplink */
10585                bitRateSize = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.size;
10586                if(bitRateSize > 0)
10587                {
10588                   DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.ambrCfg, bitRateSize);
10589                   if(!duUeCb->f1UeDb->duUeCfg.ambrCfg)
10590                   {
10591                      DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
10592                      ret = RFAILED;
10593                   }
10594                   else
10595                   {
10596                      memset(duUeCb->f1UeDb->duUeCfg.ambrCfg, 0, sizeof(AmbrCfg));
10597                      memcpy(&duUeCb->f1UeDb->duUeCfg.ambrCfg->ulBr,
10598                            ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf, bitRateSize);
10599                   }
10600                }
10601                else
10602                   ret = RFAILED;
10603                break;
10604             }
10605          default:
10606             {
10607                break;
10608             }
10609       }
10610    }
10611    if(ret == RFAILED)
10612    {
10613       /*TODO : Negative case*/
10614       // BuildAndSendUeContextSetupRsp(cellId,ueIdx);
10615       DU_LOG("\nERROR  -->  F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
10616    }
10617    else
10618       ret = duProcUeContextSetupRequest(duUeCb);
10619
10620    freeAperDecodeF1UeContextSetupReq(ueSetReq);
10621    return ret;
10622
10623 }
10624 /*******************************************************************
10625  * @brief Free the memory allocated for Dl Tunnel Info
10626  *
10627  * @details
10628  *
10629  *    Function : freeDlTnlInfo
10630  *
10631  *    Functionality:
10632  *       Free the memory allocated for Dl Tunnel Info
10633  *
10634  * @params[in] DLUPTNLInformation_ToBeSetup_List_t *
10635  * @return void
10636  *
10637  * ****************************************************************/
10638
10639 void freeDlTnlInfo(DLUPTNLInformation_ToBeSetup_List_t *tnlInfo)
10640 {
10641    uint8_t arrIdx = 0;
10642
10643    if(tnlInfo)
10644    {
10645       for(arrIdx=0; arrIdx < tnlInfo->list.count; arrIdx++)
10646       {
10647          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf,\
10648                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
10649          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf,\
10650                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
10651          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
10652          DU_FREE(tnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
10653       }
10654       DU_FREE(tnlInfo->list.array, tnlInfo->list.size);
10655    }
10656 }
10657
10658 /*******************************************************************
10659  * @brief Free the memory allocated for DRB setup List
10660  *
10661  * @details
10662  *
10663  *    Function : freeDrbSetupList
10664  *
10665  *    Functionality:
10666  *       Free the memory allocated for DRB setup list
10667  *
10668  * @params[in] DRBs_Setup_List_t *
10669  * @return void
10670  *
10671  * ****************************************************************/
10672 void freeDrbSetupList(DRBs_Setup_List_t *drbSetupList)
10673 {
10674    uint8_t arrIdx = 0;
10675    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
10676
10677    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
10678    {
10679       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
10680       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
10681       DU_FREE(drbSetupList->list.array[arrIdx],  sizeof(DRBs_Setup_Item_t));
10682    }
10683    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
10684 }
10685
10686 /*******************************************************************
10687  * @brief Free the memory allocated for UE Setup response
10688  *
10689  * @details
10690  *
10691  *    Function : FreeUeContextSetupRsp
10692  *
10693  *    Functionality:
10694  *       Free the memory allocated for UE Setup response
10695  *
10696  * @params[in] F1AP PDU for UE setup response
10697  * @return ROK     - success
10698  *         RFAILED - failure
10699  *
10700  * ****************************************************************/
10701 void FreeUeContextSetupRsp(F1AP_PDU_t *f1apMsg)
10702 {
10703    uint8_t idx;
10704    UEContextSetupResponse_t *ueSetRsp = NULLP;
10705
10706    if(f1apMsg)
10707    {
10708       if(f1apMsg->choice.successfulOutcome)
10709       {
10710          ueSetRsp = &f1apMsg->choice.successfulOutcome->value.choice.\
10711                     UEContextSetupResponse;
10712          if(ueSetRsp->protocolIEs.list.array)
10713          {
10714             for(idx = 0; idx < ueSetRsp->protocolIEs.list.count; idx++)
10715             {
10716                if(ueSetRsp->protocolIEs.list.array[idx])
10717                {
10718                   switch(ueSetRsp->protocolIEs.list.array[idx]->id)
10719                   {
10720                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10721                         break;
10722                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10723                         break;
10724                      case ProtocolIE_ID_id_DUtoCURRCInformation:
10725                         {
10726                            CellGroupConfig_t *cellGrpCfg = NULLP;
10727                            cellGrpCfg  = &ueSetRsp->protocolIEs.list.array[idx]->value.choice.\
10728                                          DUtoCURRCInformation.cellGroupConfig;
10729                            if(cellGrpCfg->buf != NULLP)
10730                            {
10731                               DU_FREE(cellGrpCfg->buf, cellGrpCfg->size);
10732                               cellGrpCfg = NULLP;
10733                            }
10734                            break;
10735                         }
10736                     case ProtocolIE_ID_id_DRBs_Setup_List:
10737                         {
10738                            freeDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
10739                            break;
10740                         }
10741                      default:
10742                         DU_LOG("\nERROR  -->  DUAPP: Invalid Id %ld at FreeUeContextSetupRsp()",\
10743                         ueSetRsp->protocolIEs.list.array[idx]->id);
10744                         break;
10745                   }
10746                   DU_FREE(ueSetRsp->protocolIEs.list.array[idx],\
10747                         sizeof(UEContextSetupResponseIEs_t));
10748                }
10749             }
10750             DU_FREE(ueSetRsp->protocolIEs.list.array, \
10751                   ueSetRsp->protocolIEs.list.size);
10752          }
10753          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
10754       }
10755       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10756    }
10757 }
10758
10759 /*******************************************************************
10760  *
10761  * @brief Builds Ue context Setup Rsp DU To CU Info
10762  *
10763  * @details
10764  *
10765  *    Function : EncodeUeCntxtDuToCuInfo
10766  *
10767  *    Functionality: Builds Ue context Setup Rsp DU To CU Info
10768  *
10769  * @params[in] CellGroupConfig_t *, CellGroupConfigRrc_t *
10770  *
10771  * @return ROK     - success
10772  *         RFAILED - failure
10773  *
10774  ******************************************************************/
10775
10776 uint8_t EncodeUeCntxtDuToCuInfo(CellGroupConfig_t *duToCuCellGrp, CellGroupConfigRrc_t *duCellGrpCfg)
10777 {
10778    asn_enc_rval_t        encRetVal;
10779
10780    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, duCellGrpCfg);
10781    memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
10782    encBufSize = 0;
10783    encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, duCellGrpCfg, PrepFinalEncBuf, encBuf);
10784    /* Encode results */
10785    if(encRetVal.encoded == ENCODE_FAIL)
10786    {
10787       DU_LOG( "\nERROR  -->  F1AP : Could not encode UeCntxtDuToCuInfo (at %s)\n",\
10788             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10789       return RFAILED;
10790    }
10791    else
10792    {
10793       DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
10794       for(int i=0; i< encBufSize; i++)
10795       {
10796          printf("%x",encBuf[i]);
10797       }
10798    }
10799    duToCuCellGrp->size = encBufSize;
10800    DU_ALLOC(duToCuCellGrp->buf, duToCuCellGrp->size);
10801    if(!duToCuCellGrp->buf)
10802    {
10803       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in UeCntxtDuToCuInfo");
10804    }
10805    memcpy(duToCuCellGrp->buf, encBuf, duToCuCellGrp->size);
10806    return ROK;
10807 }
10808
10809 /*******************************************************************
10810  *
10811  * @brief Fills Dl Gtp tunnel Info
10812  *
10813  * @details
10814  *
10815  *    Function : fillGtpTunnelforDl
10816  *
10817  *    Functionality: Fills Dl Gtp tunnel Info
10818  *
10819  * @params[in]
10820  *
10821  * @return ROK     - success
10822  *         RFAILED - failure
10823  *
10824  * ****************************************************************/
10825
10826 uint8_t fillGtpTunnelforDl(GTPTunnel_t *gtpDl, GtpTnlCfg *gtpUeCfg)
10827 {
10828    uint8_t bufSize = 0;
10829
10830    gtpDl->transportLayerAddress.size    = 4*sizeof(uint8_t);
10831    DU_ALLOC(gtpDl->transportLayerAddress.buf, gtpDl->transportLayerAddress.size);
10832    if(gtpDl->transportLayerAddress.buf == NULLP)
10833    {
10834       return RFAILED;
10835    }
10836    memcpy(gtpDl->transportLayerAddress.buf, &gtpUeCfg->dlTnlAddress, gtpDl->transportLayerAddress.size);
10837
10838    /*GTP TEID*/
10839    gtpDl->gTP_TEID.size = 4 * sizeof(uint8_t);
10840    DU_ALLOC(gtpDl->gTP_TEID.buf, gtpDl->gTP_TEID.size);
10841    if(gtpDl->gTP_TEID.buf == NULLP)
10842    {
10843       return RFAILED;
10844    }
10845    bufSize = 3; /*forming an Octect String*/
10846    fillTeIdString(bufSize, gtpUeCfg->teId, gtpDl->gTP_TEID.buf);
10847
10848    return ROK;
10849 }
10850
10851 /*******************************************************************
10852  *
10853  * @brief Fills DL Tunnel Setup List
10854  *
10855  * @details
10856  *
10857  *    Function : fillDlTnlSetupList
10858  *
10859  *    Functionality: Fills the DL Tunnel Setup List
10860  *
10861  * @params[in]
10862  *
10863  * @return ROK     - success
10864  *         RFAILED - failure
10865  *
10866  * ****************************************************************/
10867
10868 uint8_t fillDlTnlSetupList(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo, UpTnlCfg *tnlCfg)
10869 {
10870    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
10871
10872    eleCount = 1;
10873    dlTnlInfo->list.count = eleCount;
10874    dlTnlInfo->list.size = (eleCount * sizeof(DLUPTNLInformation_ToBeSetup_Item_t *));
10875
10876    /* Initialize the DL Tnl Setup List Members */
10877    DU_ALLOC(dlTnlInfo->list.array, dlTnlInfo->list.size);
10878    if(dlTnlInfo->list.array == NULLP)
10879    {
10880       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL Tnl Setup List in fillDlTnlSetupList()");
10881       ret = RFAILED;
10882    }
10883    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
10884    {
10885       DU_ALLOC(dlTnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
10886       if(dlTnlInfo->list.array[arrIdx] == NULLP)
10887       {
10888          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDlTnlSetupList()", arrIdx);
10889          return RFAILED;
10890       }
10891       dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
10892       DU_ALLOC(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
10893       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel == NULLP)
10894       {
10895          DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL tunnel info in fillDlTnlSetupList()");
10896          return RFAILED;
10897       }
10898       ret = fillGtpTunnelforDl(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel,\
10899                tnlCfg->tnlCfg1);
10900       if(ret != ROK)
10901          break;
10902    }
10903    return ret;
10904 }
10905
10906 /*******************************************************************
10907  *
10908  * @brief Fills the Drb Setup List for Ue Context Setup Response
10909  *
10910  * @details
10911  *
10912  *    Function : fillDrbSetupList
10913  *
10914  *    Functionality: Fills the Drb Setup List for Ue Context Setup Response
10915  *
10916  * @params[in]
10917  *
10918  * @return ROK     - success
10919  *         RFAILED - failure
10920  *
10921  * ****************************************************************/
10922 uint8_t fillDrbSetupList(DRBs_Setup_List_t *drbSetupList, DuUeCfg *ueCfg)
10923 {
10924    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
10925    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
10926
10927    eleCount = ueCfg->numDrb;
10928    drbSetupList->list.count = eleCount;
10929    drbSetupList->list.size = \
10930         (eleCount * sizeof(DRBs_Setup_Item_t *));
10931
10932    /* Initialize the Drb Setup List Members */
10933    DU_ALLOC(drbSetupList->list.array, drbSetupList->list.size);
10934    if(drbSetupList->list.array == NULLP)
10935    {
10936       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DRB Setup List in fillDrbSetupList()");
10937       ret = RFAILED;
10938    }
10939
10940    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
10941    {
10942       DU_ALLOC(drbSetupList->list.array[arrIdx], sizeof(DRBs_Setup_Item_t));
10943       if(drbSetupList->list.array[arrIdx] == NULLP)
10944       {
10945          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDrbSetupList()", arrIdx);
10946          return RFAILED;
10947       }
10948       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
10949       drbItemIe->id = ProtocolIE_ID_id_DRBs_Setup_Item;
10950       drbItemIe->criticality = Criticality_reject;
10951       drbItemIe->value.present = DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item;
10952       drbItemIe->value.choice.DRBs_Setup_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
10953       ret = fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List,\
10954           &ueCfg->upTnlInfo[arrIdx]);
10955       if(ret != ROK)
10956          break;
10957    }
10958    return ret;
10959 }
10960
10961 /*******************************************************************
10962  *
10963  * @brief Builds and sends the UE Setup Response
10964  *
10965  * @details
10966  *
10967  *    Function : BuildAndSendUeContextSetupRsp
10968  *
10969  *    Functionality: Constructs the UE Setup Response and sends
10970  *                   it to the DU through SCTP.
10971  *
10972  * @params[in] uint8_t cellId,uint8_t ueIdx
10973  *
10974  * @return ROK     - success
10975  *         RFAILED - failure
10976  *
10977  * ****************************************************************/
10978 uint8_t BuildAndSendUeContextSetupRsp(uint8_t cellId,uint8_t ueIdx)
10979 {
10980    uint8_t   idx, ret, cellIdx, elementCnt;
10981    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
10982    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
10983    asn_enc_rval_t  encRetVal;        /* Encoder return value */
10984    F1AP_PDU_t               *f1apMsg = NULLP;
10985    UEContextSetupResponse_t *ueSetRsp = NULLP;
10986    CellGroupConfigRrc_t     *cellGrpCfg = NULLP;
10987    DuUeCb                   *ueCb = NULLP;
10988
10989    DU_LOG("\n INFO   -->  F1AP : Building UE Context Setup Response for cellId %d, ueIdx %d\n", cellId, ueIdx);
10990
10991    while(true)
10992    {
10993       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10994       if(f1apMsg == NULLP)
10995       {
10996          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
10997          ret = RFAILED;
10998          break;
10999       }
11000
11001       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
11002       DU_ALLOC(f1apMsg->choice.successfulOutcome,
11003             sizeof(SuccessfulOutcome_t));
11004       if(f1apMsg->choice.successfulOutcome == NULLP)
11005       {
11006          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
11007          ret = RFAILED;
11008          break;
11009       }
11010
11011       f1apMsg->choice.successfulOutcome->procedureCode = \
11012                                                          ProcedureCode_id_UEContextSetup;
11013       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
11014       f1apMsg->choice.successfulOutcome->value.present = \
11015                                                          SuccessfulOutcome__value_PR_UEContextSetupResponse;
11016
11017       ueSetRsp =
11018          &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
11019       elementCnt = 4;
11020       ueSetRsp->protocolIEs.list.count = elementCnt;
11021       ueSetRsp->protocolIEs.list.size = \
11022                                         elementCnt * sizeof(UEContextSetupResponse_t *);
11023
11024       /* Initialize the UESetup members */
11025       DU_ALLOC(ueSetRsp->protocolIEs.list.array, \
11026             ueSetRsp->protocolIEs.list.size);
11027       if(ueSetRsp->protocolIEs.list.array == NULLP)
11028       {
11029          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
11030          ret = RFAILED;
11031          break;
11032       }
11033
11034       for(idx=0; idx<elementCnt; idx++)
11035       {
11036          DU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
11037                sizeof(UEContextSetupResponseIEs_t));
11038          if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
11039          {
11040             DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
11041             ret = RFAILED;
11042             break;
11043          }
11044       }
11045       /* Fetching Ue Cb Info*/
11046       GET_CELL_IDX(cellId, cellIdx);
11047       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
11048       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
11049       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
11050
11051       idx = 0;
11052       /*GNB CU UE F1AP ID*/
11053       ueSetRsp->protocolIEs.list.array[idx]->id = \
11054                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11055       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11056       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
11057                                                              UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
11058       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
11059
11060       /*GNB DU UE F1AP ID*/
11061       idx++;
11062       ueSetRsp->protocolIEs.list.array[idx]->id = \
11063                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11064       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11065       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
11066                                                              UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
11067       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
11068
11069
11070       /*DUtoCURRC Information */
11071       idx++;
11072       ueSetRsp->protocolIEs.list.array[idx]->id  = \
11073                                                    ProtocolIE_ID_id_DUtoCURRCInformation;
11074       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11075       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
11076                                                             UEContextSetupResponseIEs__value_PR_DUtoCURRCInformation;
11077       if(ueCb->f1UeDb)
11078       {
11079          if(ueCb->f1UeDb->duUeCfg.cellGrpCfg)
11080          {
11081             cellGrpCfg = (CellGroupConfigRrc_t*)ueCb->f1UeDb->duUeCfg.cellGrpCfg;
11082             ret = EncodeUeCntxtDuToCuInfo(&ueSetRsp->protocolIEs.list.array[idx]->value.\
11083                      choice.DUtoCURRCInformation.cellGroupConfig, cellGrpCfg);
11084             if(ret == RFAILED)
11085             {
11086                DU_LOG("\nERROR  -->  F1AP : Failed to EncodeUeCntxtDuToCuInfo in BuildAndSendUeContextSetupRsp()");
11087                freeF1UeDb(ueCb->f1UeDb);
11088                ueCb->f1UeDb = NULLP;
11089                break;
11090             }
11091          }
11092       }
11093       else
11094       {
11095          DU_LOG("\nERROR  -->  F1AP : Failed to form DUtoCU RRCInfo at BuildAndSendUeContextSetupRsp()");
11096          ret = RFAILED;
11097          break;
11098       }
11099
11100       /* Drb Setup List */
11101       idx++;
11102       ueSetRsp->protocolIEs.list.array[idx]->id  = \
11103                                  ProtocolIE_ID_id_DRBs_Setup_List;
11104       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11105       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
11106                                  UEContextSetupResponseIEs__value_PR_DRBs_Setup_List;
11107       ret = fillDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List,\
11108                &ueCb->f1UeDb->duUeCfg);
11109       if(ret == RFAILED)
11110       {
11111          DU_LOG("\nERROR  -->  F1AP : Failed to fillDrbSetupList in BuildAndSendUeContextSetupRsp()");
11112          freeF1UeDb(ueCb->f1UeDb);
11113          ueCb->f1UeDb = NULLP;
11114          break;
11115       }
11116
11117        /* Free UeContext Db created during Ue context Req */
11118        freeF1UeDb(ueCb->f1UeDb);
11119        ueCb->f1UeDb = NULLP;
11120
11121       /* TODO: To send Drb list */
11122       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11123
11124       /* Encode the UE context setup response type as APER */
11125       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
11126       encBufSize = 0;
11127       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11128             encBuf);
11129       /* Encode results */
11130       if(encRetVal.encoded == ENCODE_FAIL)
11131       {
11132          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Response structure (at %s)\n",\
11133                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11134          ret = RFAILED;
11135          break;
11136       }
11137       else
11138       {
11139          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Setup Response\n");
11140          for(int i=0; i< encBufSize; i++)
11141          {
11142             printf("%x",encBuf[i]);
11143          }
11144       }
11145
11146       /* Sending  msg  */
11147       if(sendF1APMsg()  != ROK)
11148       {
11149          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Response failed");
11150          ret = RFAILED;
11151          break;
11152       }
11153       break;
11154    }
11155    FreeUeContextSetupRsp(f1apMsg);
11156    return ret;
11157 }/* End of BuildAndSendUeContextSetupRsp */
11158 /*******************************************************************
11159 *
11160 * @brief  Build And Send Ue Context Rsp
11161 *
11162 * @details
11163 *
11164 *    Function : BuildAndSendUeCtxtRsp
11165 *
11166 *    Functionality : Build And Send Ue Context Rsp
11167
11168 * @params[in]
11169 * @return sucess = ROK
11170 *         failure = RFAILED
11171 *
11172 * ****************************************************************/
11173 uint8_t BuildAndSendUeCtxtRsp(uint8_t cellId, uint8_t ueIdx)
11174 {
11175    uint8_t cellIdx = 0, actionType = 0;
11176
11177    GET_CELL_IDX(cellId, cellIdx);
11178    actionType = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].f1UeDb->actionType;
11179
11180    switch(actionType)
11181    {
11182       case UE_CTXT_SETUP:
11183          {
11184             BuildAndSendUeContextSetupRsp(cellId,ueIdx);
11185             break;
11186          }
11187       case UE_CTXT_MOD:
11188          {
11189             BuildAndSendUeContextModRsp(cellId, ueIdx);
11190             break;
11191          }
11192       default:
11193          DU_LOG("ERROR  -->  F1AP: Invalid Action Type %d at BuildAndSendUeCtxtRsp()", actionType);
11194          break;
11195
11196    }
11197    return ROK;
11198 }
11199
11200 /*******************************************************************
11201  *
11202  * @brief deallocating the memory of  F1reset msg
11203  *
11204  * @details
11205  *
11206  *    Function : FreeF1ResetReq
11207  *
11208  *    Functionality :
11209  *         - freeing memory of F1reset request msg
11210  *
11211  * @params[in]
11212  * @return void
11213  *
11214  *
11215  * ****************************************************************/
11216 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
11217 {
11218    uint8_t idx =0 ;
11219    Reset_t *f1ResetMsg;
11220
11221    if(f1apMsg)
11222    {
11223       if(f1apMsg->choice.initiatingMessage)
11224       {
11225          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11226
11227          if(f1ResetMsg->protocolIEs.list.array)
11228          {
11229             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
11230             {
11231                if(f1ResetMsg->protocolIEs.list.array[idx])
11232                {
11233                   DU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
11234                }
11235             }
11236             DU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
11237          }
11238          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11239       }
11240       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11241    }
11242 }
11243 /*******************************************************************
11244  *
11245  * @brief Build and Send F1reset request
11246  *
11247  * @details
11248  *
11249  *    Function : BuildAndSendF1ResetReq
11250  *
11251  *    Functionality:
11252  *         - Build and Send F1reset request msg
11253  *
11254  * @params[in]
11255  * @return ROK     - success
11256  *         RFAILED - failure
11257  *
11258  * ****************************************************************/
11259 uint8_t BuildAndSendF1ResetReq()
11260 {
11261    uint8_t          elementCnt=0;
11262    uint8_t          idx=0;
11263    uint8_t          ret= RFAILED;
11264    Reset_t          *f1ResetMsg = NULLP;
11265    F1AP_PDU_t       *f1apMsg = NULLP;
11266    asn_enc_rval_t   encRetVal;
11267    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset request \n");
11268    do
11269    {
11270       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11271       if(f1apMsg == NULLP)
11272       {
11273          break;
11274       }
11275       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
11276       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11277       if(f1apMsg->choice.initiatingMessage == NULLP)
11278       {
11279          break;
11280       }
11281       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
11282       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
11283       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
11284
11285       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11286
11287       elementCnt = 3;
11288       f1ResetMsg->protocolIEs.list.count = elementCnt;
11289       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
11290
11291       /* Initialize the F1Setup members */
11292       DU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
11293       if(f1ResetMsg->protocolIEs.list.array == NULLP)
11294       {
11295          break;
11296       }
11297       for(idx=0; idx<elementCnt; idx++)
11298       {
11299          DU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
11300          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
11301          {
11302             break;
11303          }
11304       }
11305
11306       /*TransactionID*/
11307       idx=0;
11308       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
11309       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11310       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
11311       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
11312
11313       /*Cause*/
11314       idx++;
11315       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
11316       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
11317       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
11318       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
11319       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
11320
11321       /*Reset Type*/
11322       idx++;
11323       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
11324       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11325       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
11326       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
11327       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
11328
11329       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11330
11331       /* Encode the F1SetupRequest type as APER */
11332       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11333       encBufSize = 0;
11334       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11335             encBuf);
11336
11337       /* Encode results */
11338       if(encRetVal.encoded == ENCODE_FAIL)
11339       {
11340          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
11341                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11342          break;
11343       }
11344       else
11345       {
11346          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1Reset\n");
11347          for(idx=0; idx< encBufSize; idx++)
11348          {
11349             printf("%x",encBuf[idx]);
11350          }
11351       }
11352
11353       if(sendF1APMsg() != ROK)
11354       {
11355          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
11356          break;
11357       }
11358
11359       ret = ROK;
11360       break;
11361    }while(true);
11362
11363    FreeF1ResetReq(f1apMsg);
11364    return ret;
11365 }
11366 /*******************************************************************
11367  *
11368  * @brief Build And Send F1ResetAck
11369  *
11370  * @details
11371  *
11372  *    Function : BuildAndSendF1ResetAck
11373  *
11374  *    Functionality:
11375  *         - Build And Send  F1ResetRSP
11376  *
11377  * @return ROK     - success
11378  *         RFAILED - failure
11379  *
11380  * ****************************************************************/
11381 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
11382 {
11383    uint8_t idx;
11384    ResetAcknowledge_t *f1ResetAck;
11385
11386    if(f1apMsg)
11387    {
11388       if(f1apMsg->choice.successfulOutcome)
11389       {
11390          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
11391
11392          if(f1ResetAck->protocolIEs.list.array)
11393          {
11394             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
11395             {
11396                if(f1ResetAck->protocolIEs.list.array[idx])
11397                {
11398                   DU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
11399                }
11400             }
11401             DU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
11402          }
11403          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11404       }
11405       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11406    }
11407 }
11408
11409 /*******************************************************************
11410  *
11411  * @brief Build And Send F1ResetAck
11412  *
11413  * @details
11414  *
11415  *    Function : BuildAndSendF1ResetAck
11416  *
11417  *    Functionality:
11418  *         - Build And Send  F1ResetRSP
11419  *
11420  *  @params[in]
11421  * @return ROK     - success
11422  *         RFAILED - failure
11423  *
11424  * ****************************************************************/
11425 uint8_t BuildAndSendF1ResetAck()
11426 {
11427    uint8_t                idx = 0;
11428    uint8_t                elementCnt = 0;
11429    uint8_t                ret = RFAILED;
11430    F1AP_PDU_t             *f1apMsg = NULL;
11431    ResetAcknowledge_t     *f1ResetAck = NULLP;
11432    asn_enc_rval_t         encRetVal;
11433    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset Acknowledgment \n");
11434
11435    do{
11436       /* Allocate the memory for F1ResetRequest_t */
11437       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11438       if(f1apMsg == NULLP)
11439       {
11440          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11441          break;
11442       }
11443
11444       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
11445
11446       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11447       if(f1apMsg->choice.successfulOutcome == NULLP)
11448       {
11449          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11450          break;
11451       }
11452       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
11453       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
11454       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
11455
11456       elementCnt = 1;
11457
11458       f1ResetAck->protocolIEs.list.count = elementCnt;
11459       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
11460
11461       DU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
11462       if(f1ResetAck->protocolIEs.list.array == NULLP)
11463       {
11464          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
11465          break;
11466       }
11467
11468       for(idx=0; idx<elementCnt; idx++)
11469       {
11470          DU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
11471          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
11472          {
11473             break;
11474          }
11475       }
11476       /*TransactionID*/
11477       idx = 0;
11478       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
11479       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11480       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
11481       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
11482
11483       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11484
11485       /* Encode the F1SetupRequest type as UPER */
11486       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11487       encBufSize = 0;
11488       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
11489
11490       /* Check encode results */
11491       if(encRetVal.encoded == ENCODE_FAIL)
11492       {
11493          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
11494                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11495          break;
11496       }
11497       else
11498       {
11499          DU_LOG("\nDUBUG   -->  F1AP : Created APER encoded buffer for F1ResetAck\n");
11500          for(int i=0; i< encBufSize; i++)
11501          {
11502             printf("%x",encBuf[i]);
11503          }
11504       }
11505       /* Sending msg */
11506       if(sendF1APMsg() != ROK)
11507       {
11508          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Acknowledgement failed");
11509          break;
11510       }
11511
11512       ret = ROK;
11513       break;
11514    }while(true);
11515
11516    FreeF1ResetAck(f1apMsg);
11517    return ret;
11518 }
11519 /******************************************************************
11520 *
11521 * @brief free F1 reset msg allocated by aper_decoder
11522 *
11523 * @details
11524 *
11525 *    Function : freeAperDecodeF1ResetMsg
11526 *
11527 *    Functionality: free F1 reset msg allocated by aper_decoder
11528 *
11529 * @params[in] Reset_t *f1ResetMsg
11530 * @return void
11531 *
11532 * ****************************************************************/
11533
11534 void freeAperDecodeF1ResetMsg(Reset_t *f1ResetMsg)
11535 {
11536    uint8_t ieIdx =0;
11537    if(f1ResetMsg->protocolIEs.list.array)
11538    {
11539       for(ieIdx=0 ;ieIdx < f1ResetMsg->protocolIEs.list.count ; ieIdx++)
11540       {
11541          if(f1ResetMsg->protocolIEs.list.array[ieIdx])
11542          {
11543             free(f1ResetMsg->protocolIEs.list.array[ieIdx]);
11544          }
11545       }
11546       free(f1ResetMsg->protocolIEs.list.array);
11547    }
11548 }
11549
11550 /******************************************************************
11551  *
11552  * @brief Processes DL RRC Message Transfer  sent by CU
11553  *
11554  * @details
11555  *
11556  *    Function : procF1ResetReq
11557  *
11558  *    Functionality: Processes DL RRC Message Transfer sent by CU
11559  *
11560  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11561  * @return ROK     - success
11562  *         RFAILED - failure
11563  *
11564  * ****************************************************************/
11565 uint8_t procF1ResetReq(F1AP_PDU_t *f1apMsg)
11566 {
11567    /* we are currently not supporting Ue release. right now we are supporting only init case of fireset */
11568    uint8_t       ieIdx = 0;
11569    uint8_t        ret = ROK;
11570    Reset_t       *f1ResetMsg = NULLP;
11571
11572    DU_LOG("\nINFO   -->  Processing F1 reset request");
11573    f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11574
11575    for(ieIdx=0; ieIdx<f1ResetMsg->protocolIEs.list.count; ieIdx++)
11576    {
11577       switch(f1ResetMsg->protocolIEs.list.array[ieIdx]->id)
11578       {
11579          case ProtocolIE_ID_id_TransactionID:
11580             break;
11581
11582          case ProtocolIE_ID_id_Cause:
11583             break;
11584
11585          case ProtocolIE_ID_id_ResetType:
11586             {
11587                break;
11588             }
11589
11590          default:
11591             break;
11592       }
11593    }
11594    ret = BuildAndSendF1ResetAck();
11595    DU_LOG("\nINFO   -->  UE release is not supported for now");
11596
11597    freeAperDecodeF1ResetMsg(f1ResetMsg);
11598
11599    return ret;
11600 }
11601
11602 /*******************************************************************
11603  *
11604  * @brief free the RRC delivery report
11605  *
11606  * @details
11607  *
11608  *    Function : freeRrcDeliveryReport
11609  *
11610  *    Functionality: free the RRC delivery report
11611  *
11612  * @params[in]
11613  * @return ROK     - success
11614  *         RFAILED - failure
11615  *
11616  * ****************************************************************/
11617 void freeRrcDeliveryReport(F1AP_PDU_t  *f1apMsg )
11618 {
11619    uint8_t idx=0;
11620    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11621
11622    if(f1apMsg)
11623    {
11624       if(f1apMsg->choice.initiatingMessage)
11625       {
11626          rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11627          if(rrcDeliveryReport->protocolIEs.list.array)
11628          {
11629             for(idx =0 ;idx <rrcDeliveryReport->protocolIEs.list.count ;
11630                   idx++)
11631             {
11632                if(rrcDeliveryReport->protocolIEs.list.array[idx])
11633                {
11634                   DU_FREE(rrcDeliveryReport->protocolIEs.list.array[idx],
11635                         sizeof(RRCDeliveryReportIEs_t));
11636                }
11637             }
11638             DU_FREE(rrcDeliveryReport->protocolIEs.list.array,
11639                   rrcDeliveryReport->protocolIEs.list.size);
11640          }
11641          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11642       }
11643       DU_FREE(f1apMsg,
11644             sizeof(F1AP_PDU_t));
11645    }
11646 }
11647
11648 /*******************************************************************
11649 *
11650 * @brief Builds and sends the RRC delivery report
11651 *
11652 * @details
11653 *
11654 *    Function : BuildAndSendRrcDeliveryReport
11655 *
11656 *    Functionality: Builds and sends the RRC delivery report
11657 *
11658 * @params[in]
11659 *
11660 * @return ROK     - success
11661 *         RFAILED - failure
11662 *
11663 * ****************************************************************/
11664 uint8_t BuildAndSendRrcDeliveryReport(uint32_t gnbCuUeF1apId, \
11665    uint32_t gnbDuUeF1apId, RrcDeliveryReport *rrcDelivery)
11666 {
11667    uint8_t             ret = RFAILED;
11668    uint8_t             idx    = 0;
11669    uint8_t             idx1   = 0;
11670    uint8_t             elementCnt = 0;
11671    F1AP_PDU_t          *f1apMsg = NULLP;
11672    asn_enc_rval_t      encRetVal;
11673    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11674
11675    do{
11676
11677       DU_LOG("\nINFO   -->  F1AP : Building RRC delivery Message Transfer Message\n");
11678       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11679       if(f1apMsg == NULLP)
11680       {
11681          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11682          break;
11683       }
11684       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
11685       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11686       if(f1apMsg->choice.initiatingMessage == NULLP)
11687       {
11688          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU  failed");
11689          break;
11690       }
11691       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_RRCDeliveryReport;
11692       f1apMsg->choice.initiatingMessage->criticality   = Criticality_ignore;
11693       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RRCDeliveryReport;
11694
11695       rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11696       elementCnt = 4;
11697       rrcDeliveryReport->protocolIEs.list.count = elementCnt;
11698       rrcDeliveryReport->protocolIEs.list.size = elementCnt * sizeof(RRCDeliveryReportIEs_t *);
11699
11700       /* Initialize the F1Setup members */
11701       DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array, rrcDeliveryReport->protocolIEs.list.size);
11702       if(rrcDeliveryReport->protocolIEs.list.array == NULLP)
11703       {
11704          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRC Delivery  failed");
11705          break;
11706       }
11707       for(idx =0 ;idx <elementCnt; idx++)
11708       {
11709          DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array[idx], sizeof(RRCDeliveryReportIEs_t));
11710          if(rrcDeliveryReport->protocolIEs.list.array[idx] == NULLP)
11711          {
11712             break;
11713          }
11714       }
11715
11716       idx1 = 0;
11717
11718       /*GNB CU UE F1AP ID*/
11719       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11720       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
11721       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_CU_UE_F1AP_ID;
11722       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
11723
11724       /*GNB DU UE F1AP ID*/
11725       idx1++;
11726       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11727       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
11728       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_DU_UE_F1AP_ID;
11729       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
11730
11731       /*RRC delivery status*/
11732       idx1++;
11733       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_RRCDeliveryStatus;
11734       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
11735       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_RRCDeliveryStatus;
11736       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.delivery_status =\
11737       rrcDelivery->rrcDeliveryStatus.deliveryStatus;
11738       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.triggering_message =\
11739       rrcDelivery->rrcDeliveryStatus.triggeringMessage;
11740
11741       /* SRB ID */
11742       idx1++;
11743       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
11744       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
11745       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_SRBID;
11746       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.SRBID =  rrcDelivery->srbId;
11747
11748       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11749
11750       /* Encode the RRC DELIVERY REPORT type as APER */
11751       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11752       encBufSize = 0;
11753       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11754             encBuf);
11755
11756       /* Encode results */
11757       if(encRetVal.encoded == ENCODE_FAIL)
11758       {
11759          DU_LOG("\nERROR  -->  F1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
11760                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11761          break;
11762       }
11763       else
11764       {
11765          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for RRC Delivery Msg \n");
11766          for(idx=0; idx< encBufSize; idx++)
11767          {
11768             printf("%x",encBuf[idx]);
11769          }
11770       }
11771
11772       /* Sending msg */
11773       if(sendF1APMsg() != ROK)
11774       {
11775          DU_LOG("\nERROR  -->  F1AP : Sending RRC delivery  msg request failed");
11776          break;
11777       }
11778       ret = ROK;
11779       break;
11780
11781    }while(true);
11782
11783    freeRrcDeliveryReport(f1apMsg);
11784    return ret;
11785 }
11786
11787 /*******************************************************************
11788  *
11789  * @brief Processes cells to be activated
11790  *
11791  * @details
11792  *
11793  *    Function : extractCellsToBeActivated
11794  *
11795  *    Functionality:
11796  *      - Processes cells to be activated list received in F1SetupRsp
11797  *
11798  * @params[in] void
11799  * @return ROK     - success
11800  *         RFAILED - failure
11801  *
11802  * ****************************************************************/
11803
11804 uint8_t extractCellsToBeActivated(Cells_to_be_Activated_List_t cellsToActivate)
11805 {
11806    uint8_t  ret = ROK;
11807    uint16_t idx, nci, pci = 0;
11808    Cells_to_be_Activated_List_Item_t cell;
11809
11810    for(idx=0; idx<cellsToActivate.list.count; idx++)
11811    {
11812       nci = 0;
11813       cell = cellsToActivate.list.array[idx]->value.choice.Cells_to_be_Activated_List_Item;
11814       bitStringToInt(&cell.nRCGI.nRCellIdentity, &nci);
11815
11816       if(cell.nRPCI)
11817       {
11818          pci = *cell.nRPCI;
11819       }
11820       ret = duProcCellsToBeActivated(cell.nRCGI.pLMN_Identity.buf, nci, pci);
11821    }
11822    return ret;
11823 }
11824 /******************************************************************
11825 *
11826 * @brief Processes F1 Setup Response allocated by aper_decoder
11827 *
11828 * @details
11829 *
11830 *    Function : freeF1SetupRsp
11831 *
11832 *    Functionality: free F1 Setup Response allocated by aper_decoder
11833 *
11834 * @params[in] F1SetupResponse_t *f1SetRspMsg
11835 * @return void
11836 *
11837 * ****************************************************************/
11838
11839 void freeAperDecodeF1SetupRsp(F1SetupResponse_t *f1SetRspMsg)
11840 {
11841    uint8_t ieIdx =0;
11842    uint8_t arrIdx =0;
11843    Cells_to_be_Activated_List_t *cellToActivate =NULLP;
11844    RRC_Version_t      *rrcVer =NULLP;
11845
11846    if(f1SetRspMsg->protocolIEs.list.array)
11847    {
11848       for(ieIdx=0; ieIdx<f1SetRspMsg->protocolIEs.list.count; ieIdx++)
11849       {
11850          if(f1SetRspMsg->protocolIEs.list.array[ieIdx])
11851          {
11852             switch(f1SetRspMsg->protocolIEs.list.array[ieIdx]->id)
11853             {
11854                case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11855                   {
11856                      cellToActivate =
11857                         &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.Cells_to_be_Activated_List;
11858                      if(cellToActivate->list.array)
11859                      {
11860                         for(arrIdx=0; arrIdx<cellToActivate->list.count ; arrIdx++)
11861                         {
11862                            if(cellToActivate->list.array[arrIdx])
11863                            {
11864
11865                               if(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.\
11866                               pLMN_Identity.buf)
11867                               {
11868                                  if(cellToActivate->list.array[0]->value.choice.\
11869                                        Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf)
11870                                  {
11871                                     free(cellToActivate->list.array[0]->value.choice.\
11872                                           Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf);
11873                                  }
11874
11875                                  free(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
11876                                        nRCGI.pLMN_Identity.buf);
11877                               }
11878                               free(cellToActivate->list.array[arrIdx]);
11879                            }
11880                         }
11881                         free(cellToActivate->list.array);
11882                      }
11883                      break;
11884                   }
11885                case ProtocolIE_ID_id_TransactionID:
11886                   {
11887                      break;
11888                   }
11889                case ProtocolIE_ID_id_gNB_CU_Name:
11890                   {
11891                      free(f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_Name.buf);
11892                      break;
11893                   }
11894                case ProtocolIE_ID_id_GNB_CU_RRC_Version:
11895                   {
11896                      rrcVer = &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
11897                      if(rrcVer->latest_RRC_Version.buf)
11898                      {
11899                         if(rrcVer->iE_Extensions)
11900                         {
11901                            if(rrcVer->iE_Extensions->list.array)
11902                            {
11903                               if(rrcVer->iE_Extensions->list.array[0])
11904                               {
11905                                  if(rrcVer->iE_Extensions->list.\
11906                                        array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf)
11907                                  {
11908                                     free(rrcVer->iE_Extensions->list.\
11909                                           array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf);
11910                                  }
11911                                  free(rrcVer->iE_Extensions->list.array[0]);
11912                               }
11913                               free(rrcVer->iE_Extensions->list.array);
11914                            }
11915                            free(rrcVer->iE_Extensions);
11916                         }
11917                         free(rrcVer->latest_RRC_Version.buf);
11918                      }
11919                      break;
11920
11921                   }
11922                default:
11923                   {
11924                      DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
11925                            f1SetRspMsg->protocolIEs.list.array[ieIdx]->id);
11926                   }
11927             }
11928             free(f1SetRspMsg->protocolIEs.list.array[ieIdx]);
11929          }
11930       }
11931       free(f1SetRspMsg->protocolIEs.list.array);
11932    }
11933 }
11934 /******************************************************************
11935  *
11936  * @brief Processes F1 Setup Response sent by CU
11937  *
11938  * @details
11939  *
11940  *    Function : procF1SetupRsp
11941  *
11942  *    Functionality: Processes F1 Setup Response sent by CU
11943  *
11944  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11945  * @return ROK     - success
11946  *         RFAILED - failure
11947  *
11948  * ****************************************************************/
11949 uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg)
11950 {
11951    uint8_t ret = ROK;
11952    uint16_t idx =0;
11953    F1SetupResponse_t *f1SetRspMsg = NULLP;
11954    GNB_CU_Name_t     *cuName = NULLP;
11955    F1SetupRsp  f1SetRspDb;
11956    RRC_Version_t      *rrcVer =NULLP;
11957
11958    memset(&f1SetRspDb, 0, sizeof(F1SetupRsp));
11959
11960    DU_LOG("\nINFO   -->  F1AP : F1 Setup Response received");
11961    f1SetRspMsg = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
11962
11963    for(idx=0; idx<f1SetRspMsg->protocolIEs.list.count; idx++)
11964    {
11965       switch(f1SetRspMsg->protocolIEs.list.array[idx]->id)
11966       {
11967          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11968             {
11969                extractCellsToBeActivated(f1SetRspMsg->protocolIEs.list.array[idx]->\
11970                      value.choice.Cells_to_be_Activated_List);
11971                break;
11972             }
11973          case ProtocolIE_ID_id_TransactionID:
11974             {
11975                f1SetRspDb.transId = f1SetRspMsg->protocolIEs.list.array[idx]->\
11976                                     value.choice.TransactionID;
11977                break;
11978             }
11979          case ProtocolIE_ID_id_gNB_CU_Name:
11980             {
11981                cuName = &f1SetRspMsg->protocolIEs.list.array[idx]->\
11982                         value.choice.GNB_CU_Name;
11983                strcpy(f1SetRspDb.cuName, (const char*)cuName->buf);
11984                break;
11985             }
11986          case ProtocolIE_ID_id_GNB_CU_RRC_Version:
11987             {
11988                rrcVer = &f1SetRspMsg->protocolIEs.list.array[idx]->value.choice.RRC_Version;
11989                strcpy(f1SetRspDb.rrcVersion.rrcVer,
11990                      (const char*)rrcVer->latest_RRC_Version.buf);
11991                break;
11992             }
11993          default:
11994             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
11995                   f1SetRspMsg->protocolIEs.list.array[idx]->id);
11996       }
11997       duProcF1SetupRsp();
11998    }
11999
12000    freeAperDecodeF1SetupRsp(f1SetRspMsg);
12001    return ret;
12002 }
12003 /*******************************************************************
12004 *
12005 * @brief free GNB DU config update ack
12006 *
12007 * @details
12008 *
12009 *    Function : freeAperDecodeGnbDuAck
12010 *
12011 *    Functionality: Processes GNB DU config update ack And
12012 *                     added free part for the memory allocated by aper_decoder
12013 *
12014 * @params[in] F1AP_PDU_t ASN decoded F1AP message
12015 * @return ROK     - success
12016 *         RFAILED - failure
12017 *
12018 * ****************************************************************/
12019
12020 void freeAperDecodeGnbDuAck(GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck)
12021 {
12022    uint8_t ieIdx = 0;
12023
12024    if(gnbDuAck->protocolIEs.list.array)
12025    {
12026       for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
12027       {
12028          if(gnbDuAck->protocolIEs.list.array[ieIdx])
12029          {
12030             free(gnbDuAck->protocolIEs.list.array[ieIdx]);
12031          }
12032       }
12033       free(gnbDuAck->protocolIEs.list.array);
12034    }
12035 }
12036
12037 /*******************************************************************
12038 *
12039 * @brief Building  result of gnb-du config update ack output
12040 *
12041 * @details
12042 *
12043 *    Function : duProcGnbDuCfgUpdAckMsg
12044 *
12045 *    Functionality:
12046 *        Building output of gnb-du config update ack
12047 *
12048 * @params[in] transId
12049 * @return void
12050 *
12051 * ****************************************************************/
12052
12053 uint8_t duProcGnbDuCfgUpdAckMsg(uint8_t transId)
12054 {
12055    uint8_t  ieIdx=0, arrIdx=0,ret=ROK;
12056    uint8_t  ueId =0 , ueIdx =0;
12057    uint16_t cellId =0, cellIdx =0, crnti=0;
12058    CmLList *f1apPduNode = NULLP;
12059    ReservedF1apPduInfo *f1apPduInfo =NULLP;
12060    F1AP_PDU_t *f1apMsgPdu = NULLP;
12061    GNBDUConfigurationUpdate_t *gnbDuConfigUpdate = NULLP;
12062    BIT_STRING_t *cellIdentity=NULLP;
12063    struct Served_Cells_To_Delete_ItemIEs *deleteItemIe=NULLP;
12064    Served_Cells_To_Delete_List_t *cellsToDelete=NULLP;
12065    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
12066
12067    DU_LOG("\nINFO   -->  DU APP: GNB-DU config update Ack received ");
12068    f1apPduNode = searchFromReservedF1apPduList(transId);
12069    f1apPduInfo = (ReservedF1apPduInfo *)f1apPduNode->node;
12070    f1apMsgPdu = (F1AP_PDU_t *)f1apPduInfo->f1apMsg;
12071
12072    if(f1apMsgPdu)
12073    {
12074       if(f1apMsgPdu->choice.initiatingMessage)
12075       {
12076          gnbDuConfigUpdate = &f1apMsgPdu->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
12077          for(ieIdx=0; ieIdx < gnbDuConfigUpdate->protocolIEs.list.count; ieIdx++)
12078          {
12079             switch(gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->id)
12080             {
12081                case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
12082                   {
12083                      cellsToDelete = &gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
12084                                      Served_Cells_To_Delete_List;
12085                      if(cellsToDelete->list.array)
12086                      {
12087                         if(cellsToDelete->list.array[arrIdx])
12088                         {
12089                            deleteItemIe = (Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx];
12090                            deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
12091                            if(deleteItem->oldNRCGI.nRCellIdentity.buf)
12092                            {
12093                               cellIdentity = &deleteItem->oldNRCGI.nRCellIdentity;
12094                               bitStringToInt(cellIdentity, &cellId);
12095                            }
12096                         }
12097                      }
12098
12099                      GET_CELL_IDX(cellId, cellIdx);
12100                      if(duCb.actvCellLst[cellIdx] != NULLP)
12101                      {
12102                         if(duCb.actvCellLst[cellIdx]->numActvUes == 0)
12103                         {
12104                            duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
12105                            ret = duSendCellDeletReq(cellId);
12106                            if(ret == RFAILED)
12107                            {
12108                               DU_LOG("ERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to send cell delete\
12109                               request for cellId[%d]", cellId);
12110                            }
12111                         }
12112                         else
12113                         {
12114                            for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
12115                            {
12116                               crnti = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].crnti;
12117                               GET_UE_IDX(crnti,ueId);
12118                               ret = BuildAndSendUeContextReleaseReq(cellId, ueId);
12119                               if(ret == RFAILED)
12120                               {
12121                                  DU_LOG("ERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to build and send UE delete\
12122                                  request for cellId[%d]", cellId);
12123                               }
12124                            }
12125                         }
12126                      }
12127                      else
12128                      {
12129                         DU_LOG("ERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): CellId [%d] not found", cellId);
12130                         ret = RFAILED;
12131                      }
12132                      break;
12133                   }
12134
12135                default:
12136                   break;
12137             }
12138          }
12139       }
12140    }
12141
12142    FreeDUConfigUpdate(f1apMsgPdu);
12143    deleteFromReservedF1apPduList(f1apPduNode);
12144    return ret;
12145 }
12146
12147 /*******************************************************************
12148 *
12149 * @brief Processes GNB DU config update ack
12150 *
12151 * @details
12152 *
12153 *    Function : procF1GNBDUCfgUpdAck
12154 *
12155 *    Functionality: added free part for the memory allocated by aper_decoder
12156 *
12157 * @params[in] F1AP_PDU_t *f1apMsg
12158 * @return void
12159 *
12160 * ****************************************************************/
12161 uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
12162 {
12163    uint8_t ieIdx=0,transId=0;
12164    GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
12165
12166    DU_LOG("\nINFO   -->  F1AP : GNB-DU config update acknowledgment");
12167    gnbDuAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
12168
12169    for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
12170    {
12171       switch(gnbDuAck->protocolIEs.list.array[ieIdx]->id)
12172       {
12173          case ProtocolIE_ID_id_TransactionID:
12174             {
12175                transId = gnbDuAck->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
12176                break;
12177             }
12178          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
12179             {
12180                break;
12181             }
12182          default :
12183             {
12184                DU_LOG("\nERROR  -->  F1AP: procF1GNBDUCfgUpdAck(): Invalid IE Received: %ld", \
12185                      gnbDuAck->protocolIEs.list.array[ieIdx]->id);
12186                break;
12187             }
12188       }
12189    }
12190
12191    duProcGnbDuCfgUpdAckMsg(transId);
12192
12193 #if 0
12194    /* presently we are not supporting F1 Reset from DU to CU , we are only
12195     * supporting F1 Reset from CU to DU */
12196
12197    if(BuildAndSendF1ResetReq() != ROK)
12198    {
12199       return RFAILED;
12200    }
12201 #endif
12202
12203    freeAperDecodeGnbDuAck(gnbDuAck);
12204    return ROK;
12205 }
12206 /******************************************************************
12207 *
12208 * @brief free DL RRC Message Transfer allocated by aper_decoder
12209 *
12210 * @details
12211 *
12212 *    Function : freeAperDecodef1DlRrcMsg
12213 *
12214 *    Functionality: free DL RRC Message Transfer allocated by aper_decoder
12215 *
12216 * @params[in] DLRRCMessageTransfer_t *f1DlRrcMsg
12217 * @return ROK     - success
12218 *         RFAILED - failure
12219 *
12220 * ****************************************************************/
12221
12222 void freeAperDecodef1DlRrcMsg(DLRRCMessageTransfer_t *f1DlRrcMsg)
12223 {
12224    uint8_t ieIdx =0;
12225    RRCContainer_t *rrcContainer = NULLP;
12226
12227    if(f1DlRrcMsg->protocolIEs.list.array)
12228    {
12229       for(ieIdx=0; ieIdx<f1DlRrcMsg->protocolIEs.list.count; ieIdx++)
12230       {
12231          if(f1DlRrcMsg->protocolIEs.list.array[ieIdx])
12232          {
12233             switch(f1DlRrcMsg->protocolIEs.list.array[ieIdx]->id)
12234             {
12235                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12236                   break;
12237                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12238                   break;
12239                case ProtocolIE_ID_id_SRBID:
12240                   break;
12241                case ProtocolIE_ID_id_RRCContainer:
12242                   {
12243                      rrcContainer =&f1DlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
12244                      free(rrcContainer->buf);
12245                   }
12246                case ProtocolIE_ID_id_ExecuteDuplication:
12247                   break;
12248                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
12249                   break;
12250                   break;
12251             }
12252             free(f1DlRrcMsg->protocolIEs.list.array[ieIdx]);
12253          }
12254       }
12255       free(f1DlRrcMsg->protocolIEs.list.array);
12256    }
12257 }
12258 /******************************************************************
12259  *
12260  * @brief Processes DL RRC Message Transfer  sent by CU
12261  *
12262  * @details
12263  *
12264  *    Function : procF1DlRrcMsgTrans
12265  *
12266  *    Functionality: Processes DL RRC Message Transfer sent by CU
12267  *
12268  * @params[in] F1AP_PDU_t ASN decoded F1AP message
12269  * @return ROK     - success
12270  *         RFAILED - failure
12271  *
12272  * ****************************************************************/
12273 uint8_t procF1DlRrcMsgTrans(F1AP_PDU_t *f1apMsg)
12274 {
12275    uint8_t  idx, ret;
12276    DLRRCMessageTransfer_t *f1DlRrcMsg = NULLP;
12277    F1DlRrcMsg dlMsg;
12278    memset(&dlMsg, 0, sizeof(F1DlRrcMsg));
12279
12280    DU_LOG("\nINFO   -->  DU_APP : DL RRC message transfer Recevied");
12281    f1DlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
12282
12283    ret = ROK;
12284
12285    for(idx=0; idx<f1DlRrcMsg->protocolIEs.list.count; idx++)
12286    {
12287       switch(f1DlRrcMsg->protocolIEs.list.array[idx]->id)
12288       {
12289          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12290             {
12291                dlMsg.gnbCuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
12292                break;
12293             }
12294          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12295             {
12296                dlMsg.gnbDuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
12297                break;
12298             }
12299          case ProtocolIE_ID_id_SRBID:
12300             {
12301                dlMsg.srbId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
12302                break;
12303             }
12304          case ProtocolIE_ID_id_ExecuteDuplication:
12305             dlMsg.execDup = true;
12306             break;
12307
12308          case ProtocolIE_ID_id_RRCContainer:
12309             {
12310                if(f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0)
12311                {
12312                   dlMsg.rrcMsgSize = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
12313                   DU_ALLOC_SHRABL_BUF(dlMsg.rrcMsgPdu, dlMsg.rrcMsgSize);
12314                   if(dlMsg.rrcMsgPdu)
12315                   {
12316                      memcpy(dlMsg.rrcMsgPdu, f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
12317                         dlMsg.rrcMsgSize);
12318                   }
12319                   else
12320                   {
12321                      DU_LOG("\nERROR  -->  DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
12322                      return RFAILED;
12323                   }
12324                }
12325                else
12326                {
12327                   DU_LOG("\nERROR  -->  DU_APP : RRC Container Size is invalid:%ld",\
12328                   f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
12329                   return RFAILED;
12330                }
12331                break;
12332             }
12333          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
12334             {
12335                dlMsg.deliveryStatRpt = true;
12336                break;
12337             }
12338          default:
12339             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
12340                   f1DlRrcMsg->protocolIEs.list.array[idx]->id);
12341       }
12342    }
12343
12344    ret = duProcDlRrcMsg(&dlMsg);
12345
12346    freeAperDecodef1DlRrcMsg(f1DlRrcMsg);
12347    return ret;
12348 }
12349 /*******************************************************************
12350  *
12351 * @brief Builds the DRB to be Setup Mod list
12352 *
12353 * @details
12354 *
12355 *    Function :
12356 *
12357 *    Functionality: Constructs the DRB to be Setup Mod list
12358 *
12359 * @params[in] DRBs_SetupMod_List_t *drbSet
12360 *
12361 * @return ROK     - success
12362 *         RFAILED - failure
12363 *
12364 * ****************************************************************/
12365
12366 uint8_t BuildDrbSetupModList(DRBs_SetupMod_List_t *drbSet , DuUeCfg *ueCfg)
12367 {
12368    uint8_t arrIdx =0;
12369    uint8_t drbCnt =0;
12370    struct DRBs_SetupMod_ItemIEs *drbItemIe;
12371
12372    drbCnt = 1;
12373    drbSet->list.count = drbCnt;
12374    drbSet->list.size = drbCnt * sizeof(DRBs_SetupMod_ItemIEs_t *);
12375    DU_ALLOC(drbSet->list.array, drbSet->list.size);
12376    if(drbSet->list.array == NULLP)
12377    {
12378       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
12379       return  RFAILED;
12380    }
12381    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
12382    {
12383       DU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
12384       if(drbSet->list.array[arrIdx] == NULLP)
12385       {
12386               DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
12387               return  RFAILED;
12388       }
12389
12390       drbItemIe = (struct DRBs_SetupMod_ItemIEs *)drbSet->list.array[arrIdx];
12391       drbItemIe->id = ProtocolIE_ID_id_DRBs_SetupMod_Item;
12392       drbItemIe->criticality = Criticality_reject;
12393       drbItemIe->value.present = DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item;
12394       drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
12395       if(fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List,\
12396       &ueCfg->upTnlInfo[arrIdx])!= ROK)
12397       {
12398          DU_LOG("\nERROR  -->  F1AP : Failed to fill DlTnl SetupList in BuildDrbToBeSetupModList");
12399          return RFAILED;
12400       }
12401
12402    }
12403
12404    return ROK;
12405 }
12406 /*******************************************************************
12407 * @brief Free the memory allocated for DRB setup List
12408 *
12409 * @details
12410 *
12411 *    Function : FreeDrbSetupModList
12412 *
12413 *    Functionality:
12414 *       Free the memory allocated for DRB setup list
12415 *
12416 * @params[in] DRBs_Setup_List_t *
12417 * @return void
12418 *
12419 * ****************************************************************/
12420 void FreeDrbSetupModList(DRBs_SetupMod_List_t *drbSetupList)
12421 {
12422    uint8_t arrIdx = 0;
12423    DRBs_SetupMod_ItemIEs_t *drbItemIe = NULLP;
12424
12425    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
12426    {
12427       drbItemIe = ((DRBs_SetupMod_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
12428       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
12429       DU_FREE(drbSetupList->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
12430    }
12431    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
12432 }
12433 /*******************************************************************
12434 * @brief Free the memory allocated for UE Context Mod Response
12435 *
12436 * @details
12437 *
12438 *    Function : FreeUeContextModResp
12439 *
12440 *    Functionality:
12441 *       Free the memory allocated for UE Context Mod Response
12442 *
12443 * @params[in] F1AP_PDU_t *f1apMsg
12444 * @return void
12445 *
12446 * ****************************************************************/
12447
12448 void FreeUeContextModResp(F1AP_PDU_t *f1apMsg)
12449 {
12450    uint8_t ieIdx;
12451    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
12452    if(f1apMsg)
12453    {
12454       if(f1apMsg->choice.successfulOutcome)
12455       {
12456          ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
12457          if(ueContextModifyRes->protocolIEs.list.array)
12458          {
12459             for(ieIdx=0 ; ieIdx<ueContextModifyRes->protocolIEs.list.count; ieIdx++)
12460             {
12461                if(ueContextModifyRes->protocolIEs.list.array[ieIdx])
12462                {
12463                   switch(ueContextModifyRes->protocolIEs.list.array[ieIdx]->id)
12464                   {
12465                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12466                         break;
12467                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12468                         break;
12469                      case ProtocolIE_ID_id_DRBs_SetupMod_List:
12470                         {
12471                             FreeDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
12472                             value.choice.DRBs_SetupMod_List));
12473                             break;
12474                         }
12475                   }
12476                   DU_FREE(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
12477                }
12478
12479             }
12480             DU_FREE(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
12481          }
12482          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12483       }
12484       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12485    }
12486 }
12487
12488 /*****************************************************************i
12489 *
12490 * @brief Creating the ue context modifcation response and sending
12491 *
12492 * @details
12493 *
12494 *    Function : BuildAndSendUeContextModRsp
12495 *
12496 *    Functionality:
12497 *         - Creating the ue context modifcation response
12498 *
12499 * @params[in] uint8_t cellId,uint8_t ueIdx
12500 * @return ROK     - success
12501 *         RFAILED - failure
12502 *
12503 * ****************************************************************/
12504 uint8_t BuildAndSendUeContextModRsp(uint8_t cellId,uint8_t ueIdx)
12505 {
12506    uint8_t   ieIdx = 0;
12507    uint8_t   cellIdx =0;
12508    uint8_t   elementCnt = 0;
12509    uint8_t   ret = RFAILED;
12510    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
12511    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
12512    F1AP_PDU_t *f1apMsg = NULLP;
12513    asn_enc_rval_t         encRetVal;
12514    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
12515    DuUeCb                   *ueCb = NULLP;
12516
12517    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification response\n");
12518
12519    while(1)
12520    {
12521       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12522       if(f1apMsg == NULLP)
12523       {
12524          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
12525          break;
12526       }
12527
12528       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
12529
12530       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12531       if(f1apMsg->choice.successfulOutcome == NULLP)
12532       {
12533          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
12534          break;
12535       }
12536       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextModification;
12537       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
12538       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_UEContextModificationResponse;
12539
12540       ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
12541
12542       elementCnt = 3;
12543       ueContextModifyRes->protocolIEs.list.count = elementCnt;
12544       ueContextModifyRes->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationResponse_t*);
12545
12546       /* Initialize the UE context modification members */
12547       DU_ALLOC(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
12548       if(ueContextModifyRes->protocolIEs.list.array == NULLP)
12549       {
12550          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
12551          break;
12552       }
12553
12554       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
12555       {
12556          DU_ALLOC(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
12557          if(ueContextModifyRes->protocolIEs.list.array[ieIdx] == NULLP)
12558          {
12559             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
12560             break;
12561          }
12562       }
12563
12564       /* Fetching Ue Cb Info*/
12565       GET_CELL_IDX(cellId, cellIdx);
12566       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
12567       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
12568       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
12569
12570       ieIdx=0;
12571       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
12572       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12573       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
12574       UEContextModificationResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
12575       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
12576
12577       ieIdx++;
12578       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
12579       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12580       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present=\
12581       UEContextModificationResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
12582       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
12583
12584       ieIdx++;
12585       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_SetupMod_List;
12586       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12587       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
12588       UEContextModificationResponseIEs__value_PR_DRBs_SetupMod_List;
12589       if(ueCb->f1UeDb)
12590       {
12591          ret = BuildDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
12592                   value.choice.DRBs_SetupMod_List) , &ueCb->f1UeDb->duUeCfg);
12593          if(ret != ROK)
12594          {
12595             DU_LOG( "\nERROR  -->  F1AP : Failed to build drb setupmod List ");
12596             break;
12597          }
12598          freeF1UeDb(ueCb->f1UeDb);
12599          ueCb->f1UeDb = NULLP;
12600       }
12601       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12602
12603       /* Encode the F1SetupRequest type as APER */
12604       memset(encBuf, 0, ENC_BUF_MAX_LEN);
12605       encBufSize = 0;
12606       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,encBuf);
12607
12608       /* Encode results */
12609       if(encRetVal.encoded == ENCODE_FAIL)
12610       {
12611          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
12612                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12613          ret = RFAILED;
12614          break;
12615       }
12616       else
12617       {
12618          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Modification Response\n");
12619          for(int i=0; i< encBufSize; i++)
12620          {
12621             printf("%x",encBuf[i]);
12622          }
12623       }
12624
12625       /* Sending  msg  */
12626       if(sendF1APMsg() != ROK)
12627       {
12628          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Res Failed");
12629          ret = RFAILED;
12630          break;
12631       }
12632       break;
12633    }
12634    FreeUeContextModResp(f1apMsg);
12635    return ret;
12636 }
12637 /*******************************************************************
12638  *
12639  * @brief Deallocating the memory allocated by the aper decoder
12640  *          for QOSInfo
12641  *
12642  * @details
12643  *
12644  *    Function : freeAperDecodeQosInfo
12645  *
12646  *    Functionality:  Deallocating the memory allocated for QOSInfo
12647  *
12648  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
12649  *
12650  * @return void
12651  *
12652  * ****************************************************************/
12653
12654 void freeAperDecodeQosInfo(QoSFlowLevelQoSParameters_t *drbQos)
12655 {
12656    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
12657    {
12658       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
12659       {
12660          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
12661          {
12662             free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
12663          }
12664          free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
12665       }
12666       free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI);
12667    }
12668 }
12669 /*******************************************************************
12670  *
12671  * @brief Deallocating the memory allocated by the aper decoder
12672  *          for UlTnlInfoforDrb
12673  *
12674  * @details
12675  *
12676  *    Function : freeAperDecodeUlTnlInfoforDrbSetupMod
12677  *
12678  *    Functionality:  Deallocating memory allocated for UlTnlInfoforDrb
12679  *
12680  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
12681  *
12682  * @return void
12683  *
12684  * ****************************************************************/
12685 void freeAperDecodeUlTnlInfoforDrbSetupMod(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
12686 {
12687    uint8_t arrIdx =0;
12688
12689    if(ulInfo->list.array)
12690    {
12691       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
12692       {
12693          if(ulInfo->list.array[arrIdx])
12694          {
12695             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
12696             {
12697                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
12698                {
12699                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
12700                   {
12701                      free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12702                            gTP_TEID.buf);
12703                   }
12704                   free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12705                         transportLayerAddress.buf);
12706                }
12707                free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel);
12708             }
12709             free(ulInfo->list.array[arrIdx]);
12710          }
12711       }
12712       free(ulInfo->list.array);
12713    }
12714 }
12715 /*******************************************************************
12716  *
12717  * @brief Deallocating the memory allocated by the aper decoder
12718  *          for DrbSetupModItem
12719  *
12720  * @details
12721  *
12722  *    Function : freeAperDecodeDrbSetupModItem
12723  *
12724  *    Functionality:  Deallocating memory allocated for DrbSetupModItem
12725  *
12726  * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
12727  *
12728  * @return void
12729  *
12730  * ****************************************************************/
12731
12732 void freeAperDecodeDrbSetupModItem(DRBs_ToBeSetupMod_Item_t *drbItem)
12733 {
12734    uint8_t arrIdx =0;
12735    SNSSAI_t *snssai =NULLP;
12736    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
12737
12738    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
12739    switch(drbItem->qoSInformation.present)
12740    {
12741       case QoSInformation_PR_NOTHING:
12742          break;
12743       case QoSInformation_PR_eUTRANQoS:
12744          {
12745             if(drbItem->qoSInformation.choice.eUTRANQoS)
12746             {
12747                free(drbItem->qoSInformation.choice.eUTRANQoS);
12748             }
12749             break;
12750          }
12751       case QoSInformation_PR_choice_extension:
12752          {
12753             if(drbItem->qoSInformation.choice.choice_extension)
12754             {
12755                freeAperDecodeQosInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.\
12756                      DRB_Information.dRB_QoS);
12757                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
12758                if(snssai->sST.buf)
12759                {
12760                   free(snssai->sST.buf);
12761                }
12762                if(snssai->sD)
12763                {
12764                   if(snssai->sD->buf)
12765                   {
12766                      free(snssai->sD->buf);
12767                   }
12768                   free(snssai->sD);
12769                }
12770
12771                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.\
12772                          DRB_Information.flows_Mapped_To_DRB_List;
12773                if(flowMap->list.array)
12774                {
12775                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
12776                   {
12777                      if(flowMap->list.array[arrIdx] )
12778                      {
12779                         freeAperDecodeQosInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
12780                         free(flowMap->list.array[arrIdx]);
12781                      }
12782                   }
12783                   free(flowMap->list.array);
12784                }
12785
12786                free(drbItem->qoSInformation.choice.choice_extension);
12787             }
12788             break;
12789          }
12790
12791    }
12792    freeAperDecodeUlTnlInfoforDrbSetupMod(&drbItem->uLUPTNLInformation_ToBeSetup_List);
12793    if(drbItem->uLConfiguration)
12794    {
12795       free(drbItem->uLConfiguration);
12796    }
12797 }
12798
12799 /*******************************************************************
12800  *
12801  * @brief Deallocating the memory allocated by the aper decoder
12802  *          for DrbToBeSetupModList
12803  *
12804  * @details
12805  *
12806  *    Function : freeAperDecodeDrbToBeSetupModList
12807  *
12808  *    Functionality:  Deallocating memory allocated for DrbToBeSetupModList
12809  *
12810  * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
12811  *
12812  * @return void
12813  *
12814  * ****************************************************************/
12815
12816 void freeAperDecodeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
12817 {
12818    uint8_t arrIdx =0;
12819    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
12820
12821    if(drbSet->list.array)
12822    {
12823       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
12824       {
12825          if(drbSet->list.array[arrIdx] != NULLP)
12826          {
12827             if(arrIdx == 0)
12828             {
12829                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
12830                freeAperDecodeDrbSetupModItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
12831             }
12832             free(drbSet->list.array[arrIdx]);
12833          }
12834       }
12835       free(drbSet->list.array);
12836    }
12837
12838 }
12839 /*******************************************************************
12840  *
12841  * @brief Deallocating the memory allocated by the aper decoder
12842  *          for UeContextModificationReqMsg
12843  *
12844  * @details
12845  *
12846  *    Function : freeAperDecodeUeContextModificationReqMsg
12847  *
12848  *    Functionality:  Deallocating memory allocated for
12849  *                  UeContextModificationReqMsg
12850  *
12851  * @params[in] UEContextModificationRequest_t *UeContextModifyReq
12852  *
12853  * @return void
12854  *
12855  * ****************************************************************/
12856 void freeAperDecodeUeContextModificationReqMsg(UEContextModificationRequest_t *UeContextModifyReq )
12857 {
12858    uint8_t arrIdx, ieId;
12859
12860    if(UeContextModifyReq->protocolIEs.list.array)
12861    {
12862       for( arrIdx = 0 ; arrIdx<UeContextModifyReq->protocolIEs.list.count ; arrIdx++)
12863       {
12864          if(UeContextModifyReq->protocolIEs.list.array[arrIdx])
12865          {
12866             ieId = UeContextModifyReq->protocolIEs.list.array[arrIdx]->id;
12867             switch(ieId)
12868             {
12869                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12870                   break;
12871                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12872                   break;
12873                case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
12874                   {
12875                      freeAperDecodeDrbToBeSetupModList(&UeContextModifyReq->protocolIEs.list.array[arrIdx]->\
12876                            value.choice.DRBs_ToBeSetupMod_List);
12877                      break;
12878                   }
12879             }
12880             free(UeContextModifyReq->protocolIEs.list.array[arrIdx]);
12881          }
12882       }
12883       free(UeContextModifyReq->protocolIEs.list.array);
12884    }
12885 }
12886 /*******************************************************************
12887  *
12888  * @brief processing the F1 UeContextModificationReq
12889  *
12890  * @details
12891  *
12892  *    Function : procF1UeContextModificationReq
12893  *
12894  *    Functionality:  processing the F1 UeContextModificationReq
12895  *
12896  * @params[in] F1AP_PDU_t *f1apMsg
12897  *
12898  * @return
12899  * ****************************************************************/
12900 uint8_t procF1UeContextModificationReq(F1AP_PDU_t *f1apMsg)
12901 {
12902    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
12903    uint8_t  ret = ROK, ieIdx = 0, cellIdx=0, ueIdx=0;
12904    DuUeCb   *duUeCb = NULLP;
12905    DRBs_ToBeSetupMod_List_t *drbSetupModCfg;
12906    DRBs_ToBeModified_List_t *drbModifiedCfg;
12907    uint32_t gnbCuUeF1apId, gnbDuUeF1apId;
12908
12909    ueContextModifyReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
12910    for(ieIdx=0; (ieIdx < ueContextModifyReq->protocolIEs.list.count && ret == ROK); ieIdx++)
12911    {
12912       switch(ueContextModifyReq->protocolIEs.list.array[ieIdx]->id)
12913       {
12914          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12915             {
12916                gnbCuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
12917                break;
12918             }
12919          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12920             {
12921                gnbDuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
12922                break;
12923             }
12924          case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
12925          case ProtocolIE_ID_id_DRBs_ToBeModified_List:
12926             {
12927                for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
12928                {
12929                   for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
12930                   {
12931                      if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
12932                            (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
12933                      {
12934
12935                         duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
12936                         if(duUeCb->f1UeDb == NULLP)
12937                         {
12938                            DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
12939                         }
12940                         if(duUeCb->f1UeDb)
12941                         {
12942                            duUeCb->f1UeDb->actionType = UE_CTXT_MOD;
12943                            if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present ==\
12944                                  UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List)
12945                            {
12946                               drbSetupModCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
12947                               choice.DRBs_ToBeSetupMod_List;
12948
12949                               if(extractDrbListToSetupMod(NULL, drbSetupModCfg, NULL, drbSetupModCfg->list.count,\
12950                                     &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap))
12951                               {
12952                                  DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbSetupModList");
12953                                  ret = RFAILED;
12954                               }
12955                            }
12956
12957                            if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present == \
12958                                   UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List)
12959
12960                            {
12961                               drbModifiedCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
12962                               choice.DRBs_ToBeModified_List;
12963                               if(extractDrbListToSetupMod(NULL, NULL, drbModifiedCfg, drbSetupModCfg->list.count,\
12964                                  &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap))
12965                               {
12966                                  DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbModifiedList");
12967                                  ret = RFAILED;
12968                               }
12969                            }
12970                         }
12971                         break;
12972                      }
12973                   }
12974                   if(ueIdx >= duCb.actvCellLst[cellIdx]->numActvUes)
12975                   {
12976                      DU_LOG("\nERROR  -->  DU APP : wrong values of gnbCuUeF1apId and gnbDuUeF1apId ");
12977                      ret = RFAILED;
12978                   }
12979                }
12980                break;
12981             }
12982       }
12983    }
12984    if(ret != RFAILED)
12985    {
12986       ret = duProcUeContextModReq(duUeCb);
12987    }
12988    freeAperDecodeUeContextModificationReqMsg(ueContextModifyReq);
12989    return ret;
12990 }
12991 /*****************************************************************i
12992 *
12993 * @brief Free memory allocated for UE Context Release Request
12994 *
12995 * @details
12996 *
12997 *    Function : FreeUeContextReleaseReq
12998 *
12999 *    Functionality:
13000 *         - Free memory allocated for UE Context Release Request
13001 *
13002 * @params[in] F1AP_PDU_t *f1apMsg
13003 * @return void
13004 *
13005 * *************************************************************/
13006 void FreeUeContextReleaseReq(F1AP_PDU_t *f1apMsg)
13007 {
13008    uint8_t ieIdx;
13009    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
13010
13011    if(f1apMsg)
13012    {
13013       if(f1apMsg->choice.initiatingMessage)
13014       {
13015          ueReleaseReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
13016          if(ueReleaseReq->protocolIEs.list.array)
13017          {
13018             for(ieIdx=0 ; ieIdx<ueReleaseReq->protocolIEs.list.count; ieIdx++)
13019             {
13020                DU_FREE(ueReleaseReq->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseRequest_t));
13021             }
13022             DU_FREE(ueReleaseReq->protocolIEs.list.array, ueReleaseReq->protocolIEs.list.size);
13023          }
13024          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
13025       }
13026       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
13027    }
13028
13029 }
13030 /*****************************************************************i
13031 *
13032 * @brief Build and Send UE Context Release Request
13033 *
13034 * @details
13035 *
13036 *    Function : BuildAndSendUeContextReleaseReq
13037 *
13038 *    Functionality:
13039 *         - Build and Send UE Context Release Request
13040 *
13041 * @params[in]
13042 * @return ROK     - success
13043 *         RFAILED - failure
13044 *
13045 * *************************************************************/
13046 uint8_t BuildAndSendUeContextReleaseReq(uint16_t cellId, uint8_t ueIdx)
13047 {
13048    bool memAllocFail = false;
13049    uint8_t ieIdx =0;
13050    uint8_t ret = RFAILED;
13051    uint16_t cellIdx =0;
13052    uint16_t crnti = 0;
13053    uint8_t  elementCnt = 0;
13054    uint32_t  gnbCuUeF1apId =0;   /* gNB-CU UE F1AP Id */
13055    uint32_t  gnbDuUeF1apId =0;   /* gNB-DU UE F1AP Id */
13056    asn_enc_rval_t encRetVal;
13057    F1AP_PDU_t *f1apMsg = NULLP;
13058    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
13059
13060    DU_LOG("\nINFO  --> Building the UE Context Release Request");
13061    do
13062    {
13063       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
13064       if(f1apMsg == NULLP)
13065       {
13066          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for f1apMsg");
13067          break;
13068       }
13069
13070       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
13071       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
13072       if(f1apMsg->choice.initiatingMessage == NULLP)
13073       {
13074          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for\
13075          initiatingMessage");
13076          break;
13077       }
13078       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextReleaseRequest;
13079       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
13080       f1apMsg->choice.initiatingMessage->value.present = \
13081       InitiatingMessage__value_PR_UEContextReleaseRequest;
13082
13083       ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
13084
13085       elementCnt = 2;
13086
13087       ueReleaseReq->protocolIEs.list.count = elementCnt;
13088       ueReleaseReq->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseRequest_t *);
13089
13090       /* Initialize the F1Setup members */
13091       DU_ALLOC(ueReleaseReq->protocolIEs.list.array,ueReleaseReq->protocolIEs.list.size);
13092       if(ueReleaseReq->protocolIEs.list.array == NULLP)
13093       {
13094          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE array");
13095          break;
13096       }
13097       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
13098       {
13099          DU_ALLOC(ueReleaseReq->protocolIEs.list.array[ieIdx],\
13100                sizeof(UEContextReleaseRequest_t));
13101          if(ueReleaseReq->protocolIEs.list.array[ieIdx] == NULLP)
13102          {
13103             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE elements");
13104             memAllocFail = true;
13105             break;
13106          }
13107       }
13108       if(memAllocFail == true)
13109          break;
13110
13111       /* Fetching Ue Cb Info*/
13112       GET_CELL_IDX(cellId, cellIdx);
13113       if(duCb.actvCellLst[cellIdx] == NULLP)
13114       {
13115          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): CellId[%d] does not exist", cellId);
13116          break;
13117       }
13118       else
13119       {
13120          GET_CRNTI(crnti, ueIdx);
13121          if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].crnti != crnti)
13122          {
13123             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): crnti[%d] does not exist", crnti);
13124             break;
13125          }
13126          gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
13127          gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
13128       }
13129
13130       ieIdx=0;
13131       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
13132       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13133       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present = \
13134       UEContextReleaseRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
13135       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
13136
13137       ieIdx++;
13138       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
13139       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13140       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present =\
13141       UEContextReleaseRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
13142       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
13143
13144       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13145
13146       /* Encode the F1SetupRequest type as APER */
13147       memset(encBuf, 0, ENC_BUF_MAX_LEN);
13148       encBufSize = 0;
13149       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
13150       /* Encode results */
13151       if(encRetVal.encoded == ENCODE_FAIL)
13152       {
13153          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseRequest structure (at %s)\n",\
13154                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13155          break;
13156       }
13157       else
13158       {
13159          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseRequest\n");
13160          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
13161          {
13162             printf("%x",encBuf[ieIdx]);
13163          }
13164       }
13165
13166       /* Sending msg */
13167       if(sendF1APMsg() != ROK)
13168       {
13169          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Request failed");
13170          break;
13171       }
13172       ret = ROK;
13173       break;
13174    }while(true);
13175
13176    FreeUeContextReleaseReq(f1apMsg);
13177    return ret;
13178 }
13179 /*****************************************************************i
13180  *
13181  * @brief Free memory allocated for UE Context Release Complete
13182  *
13183  * @details
13184  *
13185  *    Function : FreeUeContextReleaseComplete
13186  *
13187  *    Functionality:
13188  *         - Free memory allocated for UE Context Release Complete
13189  *
13190  * @params[in] F1AP_PDU_t *f1apMsg
13191  * @return void
13192  *
13193  * *************************************************************/
13194 void FreeUeContextReleaseComplete(F1AP_PDU_t *f1apMsg)
13195 {
13196    uint8_t ieIdx;
13197    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
13198
13199    if(f1apMsg)
13200    {
13201       if(f1apMsg->choice.successfulOutcome)
13202       {
13203          ueReleaseComplete =&f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
13204          if(ueReleaseComplete->protocolIEs.list.array)
13205          {
13206             for(ieIdx=0 ; ieIdx<ueReleaseComplete->protocolIEs.list.count; ieIdx++)
13207             {
13208                DU_FREE(ueReleaseComplete->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseComplete_t));
13209             }
13210             DU_FREE(ueReleaseComplete->protocolIEs.list.array, ueReleaseComplete->protocolIEs.list.size);
13211          }
13212          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
13213       }
13214       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
13215    }
13216
13217 }
13218 /*****************************************************************i
13219  *
13220  * @brief Build and Send UE Context Release Complete
13221  *
13222  * @details
13223  *
13224  *    Function : BuildAndSendUeContextReleaseComplete
13225  *
13226  *    Functionality:
13227  *         - Build and Send UE Context Release Complete
13228  *
13229  * @params[in]  cellId,  gnbCuUeF1apId, gnbDuUeF1apId
13230  * @return ROK     - success
13231  *         RFAILED - failure
13232  *
13233  * *************************************************************/
13234 uint8_t BuildAndSendUeContextReleaseComplete(uint16_t cellId, uint32_t gnbCuUeF1apId, uint32_t gnbDuUeF1apId)
13235 {
13236    bool memAllocFail = false;
13237    uint8_t ieIdx =0, ret = RFAILED, elementCnt = 0;
13238    asn_enc_rval_t encRetVal;
13239    F1AP_PDU_t *f1apMsg = NULLP;
13240    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
13241
13242    DU_LOG("\nINFO  --> Building the UE Context Release Complete");
13243    do
13244    {
13245       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
13246       if(f1apMsg == NULLP)
13247       {
13248          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for f1apMsg");
13249          break;
13250       }
13251
13252       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
13253       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
13254       if(f1apMsg->choice.successfulOutcome == NULLP)
13255       {
13256          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for\
13257                successfulOutcome");
13258          break;
13259       }
13260       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextRelease;
13261       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
13262       f1apMsg->choice.successfulOutcome->value.present = \
13263       SuccessfulOutcome__value_PR_UEContextReleaseComplete;
13264
13265       ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
13266
13267       elementCnt = 2;
13268       ueReleaseComplete->protocolIEs.list.count = elementCnt;
13269       ueReleaseComplete->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseComplete_t *);
13270
13271       /* Initialize the UE Release Complete members */
13272       DU_ALLOC(ueReleaseComplete->protocolIEs.list.array,ueReleaseComplete->protocolIEs.list.size);
13273       if(ueReleaseComplete->protocolIEs.list.array == NULLP)
13274       {
13275          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE array");
13276          break;
13277       }
13278       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
13279       {
13280          DU_ALLOC(ueReleaseComplete->protocolIEs.list.array[ieIdx],\
13281                sizeof(UEContextReleaseComplete_t));
13282          if(ueReleaseComplete->protocolIEs.list.array[ieIdx] == NULLP)
13283          {
13284             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE\
13285             elements");
13286             memAllocFail = true;
13287             break;
13288          }
13289       }
13290       if(memAllocFail == true)
13291          break;
13292
13293
13294       ieIdx=0;
13295       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
13296       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13297       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present = \
13298       UEContextReleaseCompleteIEs__value_PR_GNB_CU_UE_F1AP_ID;
13299       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
13300
13301       ieIdx++;
13302       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
13303       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13304       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present =\
13305       UEContextReleaseCompleteIEs__value_PR_GNB_DU_UE_F1AP_ID;
13306       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
13307
13308       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13309
13310       /* Encode the F1SetupComplete type as APER */
13311       memset(encBuf, 0, ENC_BUF_MAX_LEN);
13312       encBufSize = 0;
13313       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
13314       /* Encode results */
13315       if(encRetVal.encoded == ENCODE_FAIL)
13316       {
13317          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseComplete structure (at %s)\n",\
13318                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13319          break;
13320       }
13321       else
13322       {
13323          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseComplete\n");
13324          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
13325          {
13326             printf("%x",encBuf[ieIdx]);
13327          }
13328       }
13329
13330       /* Sending msg */
13331       if(sendF1APMsg() != ROK)
13332       {
13333          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Complete failed");
13334          break;
13335       }
13336       ret = ROK;
13337       break;
13338    }while(true);
13339
13340    if(ret == ROK)
13341    {
13342       duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
13343       ret = duSendCellDeletReq(cellId);
13344       if(ret != ROK)
13345       {
13346          DU_LOG("\nERROR  -->  F1AP: BuildAndSendUeContextReleaseComplete(): Failed to process cell\
13347                Delete req for CellId");
13348       }
13349    }
13350    FreeUeContextReleaseComplete(f1apMsg);
13351    return ret;
13352
13353 }
13354
13355 /*******************************************************************
13356 *
13357 * @brief added free part for the memory allocated by aper_decoder
13358 *
13359 * @details
13360 *
13361 *    Function : freeAperDecodeUeContextReleaseCommand
13362 *
13363 *    Functionality: added free part for the memory allocated by aper_decoder
13364 *
13365 * @params[in] F1AP_PDU_t *f1apMsg
13366 * @return void
13367 *
13368 * ****************************************************************/
13369 void freeAperDecodeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
13370 {
13371    uint8_t ieIdx=0;
13372    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
13373
13374    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
13375
13376    if(ueContextReleaseCommand->protocolIEs.list.array)
13377    {
13378       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
13379       {
13380          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
13381          {
13382             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
13383             {
13384                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13385                   break;
13386                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13387                   break;
13388                case ProtocolIE_ID_id_Cause:
13389                   break;
13390                case ProtocolIE_ID_id_RRCContainer:
13391                {
13392                   if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
13393                   {
13394                      free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
13395                   }
13396                   break;
13397                }
13398                default :
13399                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
13400                        ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
13401                   break;
13402             }
13403          }
13404          free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]);
13405       }
13406       free(ueContextReleaseCommand->protocolIEs.list.array);
13407    }
13408 }
13409 /*******************************************************************
13410 *
13411 * @brief processing of UE Context Release Command
13412 *
13413 * @details
13414 *
13415 *    Function : procF1UeContextReleaseCommand
13416 *
13417 *    Functionality: processing of UE Context Release Command
13418 *
13419 * @params[in] F1AP_PDU_t *f1apMsg
13420 * @return void
13421 *
13422 * ****************************************************************/
13423 uint8_t procF1UeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
13424 {
13425    uint8_t  ieIdx=0, ret=ROK, ueIdx=0;
13426    uint16_t cellIdx =0;
13427    bool ueIdxFound;
13428    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0;
13429    DuUeCb   *duUeCb = NULLP;
13430    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
13431
13432    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
13433
13434    if(ueContextReleaseCommand->protocolIEs.list.array)
13435    {
13436       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
13437       {
13438          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
13439          {
13440             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
13441             {
13442                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13443                   {
13444                      gnbCuUeF1apId= ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13445                                     value.choice.GNB_CU_UE_F1AP_ID;
13446                      break;
13447                   }
13448
13449                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13450                   {
13451                      gnbDuUeF1apId = ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13452                                      value.choice.GNB_DU_UE_F1AP_ID;
13453                      break;
13454                   }
13455
13456                case ProtocolIE_ID_id_Cause:
13457                   {
13458                      break;
13459                   }
13460
13461                case ProtocolIE_ID_id_RRCContainer:
13462                   {
13463                      for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
13464                      {
13465                         for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
13466                         {
13467                            if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
13468                                  (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
13469                            {
13470                               duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
13471                               DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
13472                               if(duUeCb->f1UeDb)
13473                               {
13474                                  memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
13475                                  duUeCb->f1UeDb->actionType = UE_CTXT_RELEASE;
13476                                  duUeCb->f1UeDb->cellIdx = cellIdx;
13477                                  /* Filling Dl RRC Msg Info */
13478                                  DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
13479                                  if(!duUeCb->f1UeDb->dlRrcMsg)
13480                                  {
13481                                     DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
13482                                     Memory allocation failed ");
13483                                     ret = RFAILED;
13484                                  }
13485                                  else
13486                                  {
13487                                     duUeCb->f1UeDb->dlRrcMsgPres = true;
13488                                     memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
13489                                     ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
13490                                           &ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13491                                           value.choice.RRCContainer);
13492                                  }
13493
13494                               }
13495                               else
13496                               {
13497                                  DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
13498                                  Memory allocation failed ");
13499                                  ret = RFAILED;
13500
13501                               }
13502
13503                               ueIdxFound = true;
13504                               break;
13505                            }
13506                         }
13507                         if(ueIdxFound == true)
13508                         {
13509                            break;
13510                         }
13511                      }
13512                      if(!ueIdxFound)
13513                      {
13514                         DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
13515                         ret = RFAILED;
13516                      }
13517
13518
13519                      break;
13520                   }
13521                default :
13522                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
13523                         ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
13524                   break;
13525             }
13526          }
13527       }
13528    }
13529    if(ret != RFAILED)
13530    {
13531       duProcUeContextReleaseCommand(duUeCb);
13532    }
13533    freeAperDecodeUeContextReleaseCommand(f1apMsg);
13534    return ret;
13535 }
13536 /**************************************************************
13537  *
13538  * @brief Handles received F1AP message and sends back response
13539  *
13540  * @details
13541  *
13542  *    Function : F1APMsgHdlr
13543  *
13544  *    Functionality:
13545  *         - Decodes received F1AP control message
13546  *         - Prepares response message, encodes and sends to SCTP
13547  *
13548  * @params[in]
13549  * @return ROK     - success
13550  *         RFAILED - failure
13551  *
13552  * ****************************************************************/
13553 void F1APMsgHdlr(Buffer *mBuf)
13554 {
13555    int i =0;
13556    char *recvBuf =NULLP;
13557    MsgLen copyCnt =0;
13558    MsgLen recvBufLen =0;
13559    F1AP_PDU_t *f1apMsg =NULLP;
13560    asn_dec_rval_t rval; /* Decoder return value */
13561    F1AP_PDU_t f1apasnmsg ;
13562    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
13563    ODU_PRINT_MSG(mBuf, 0,0);
13564
13565    /* Copy mBuf into char array to decode it */
13566    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
13567    DU_ALLOC(recvBuf, (Size)recvBufLen);
13568
13569    if(recvBuf == NULLP)
13570    {
13571       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
13572       return;
13573    }
13574    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
13575    {
13576       DU_LOG("\nERROR   -->  F1AP : Failed while copying %d", copyCnt);
13577       return;
13578    }
13579
13580    printf("\nDEBUG   -->  F1AP : Received flat buffer to be decoded : ");
13581    for(i=0; i< recvBufLen; i++)
13582    {
13583       printf("%x",recvBuf[i]);
13584    }
13585
13586    /* Decoding flat buffer into F1AP messsage */
13587    f1apMsg = &f1apasnmsg;
13588    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
13589
13590    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
13591    DU_FREE(recvBuf, (Size)recvBufLen);
13592
13593    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
13594    {
13595       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
13596       return;
13597    }
13598    printf("\n");
13599    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13600
13601    switch(f1apMsg->present)
13602    {
13603       case F1AP_PDU_PR_successfulOutcome:
13604          {
13605             switch(f1apMsg->choice.successfulOutcome->value.present)
13606             {
13607                case SuccessfulOutcome__value_PR_ResetAcknowledge:
13608                   {
13609                      DU_LOG("\nINFO   -->  F1AP : F1ResetAcknowledge is received successfully ");
13610                      break;
13611                   }
13612                case SuccessfulOutcome__value_PR_F1SetupResponse:
13613                   {
13614 #ifndef ODU_TEST_STUB
13615                      procF1SetupRsp(f1apMsg);
13616 #endif
13617                      break;
13618                   }
13619
13620                case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
13621                   {
13622                      procF1GNBDUCfgUpdAck(f1apMsg);
13623                      break;
13624                   }
13625
13626                default:
13627                   {
13628                      DU_LOG("\nERROR  -->  F1AP : Invalid type of SuccessfulOutcome__value_PR_ResetAcknowledge [%d]",\
13629                            f1apMsg->choice.successfulOutcome->value.present);
13630                      return;
13631                   }
13632             }/* End of switch(successfulOutcome) */
13633             free(f1apMsg->choice.successfulOutcome);
13634             break;
13635          }
13636       case F1AP_PDU_PR_initiatingMessage:
13637          {
13638             switch(f1apMsg->choice.initiatingMessage->value.present)
13639             {
13640                case InitiatingMessage__value_PR_Reset:
13641                   {
13642                      procF1ResetReq(f1apMsg);
13643                      break;
13644                   }
13645                case InitiatingMessage__value_PR_DLRRCMessageTransfer:
13646                   {
13647                      procF1DlRrcMsgTrans(f1apMsg);
13648                      break;
13649                   }
13650                case InitiatingMessage__value_PR_UEContextSetupRequest:
13651                   {
13652                      procF1UeContextSetupReq(f1apMsg);
13653                      break;
13654                   }
13655                case InitiatingMessage__value_PR_UEContextModificationRequest:
13656                   {
13657                      procF1UeContextModificationReq(f1apMsg);
13658                      break;
13659                   }
13660                case InitiatingMessage__value_PR_UEContextReleaseCommand:
13661                   {
13662                       procF1UeContextReleaseCommand(f1apMsg);
13663                       break;
13664                   }
13665                default:
13666                   {
13667                      DU_LOG("\nERROR  -->  F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
13668                            f1apMsg->choice.initiatingMessage->value.present);
13669                      return;
13670                   }
13671             }/* End of switch(initiatingMessage) */
13672             free(f1apMsg->choice.initiatingMessage);
13673             break;
13674          }
13675
13676       default:
13677          {
13678             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
13679             return;
13680          }
13681          free(f1apMsg);
13682
13683    }/* End of switch(f1apMsg->present) */
13684
13685 } /* End of F1APMsgHdlr */
13686
13687 /**********************************************************************
13688   End of file
13689  **********************************************************************/