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 extractDrbCfg()");
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 extractDrbCfg()");
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 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
7646    return ROK;
7647 }
7648
7649 /*******************************************************************
7650  *
7651  * @brief Function to extract RB info received from CU
7652  *
7653  * @details
7654  *
7655  *    Function : extractMacRbCfg
7656  *
7657  *    Functionality: Function to extract RB info received from CU
7658  *
7659  * @params[in] F1AP message
7660  * @return ROK/RFAILED
7661  *
7662  * ****************************************************************/
7663
7664 uint8_t extractMacRbCfg(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbCfg,\
7665 DRBs_ToBeSetupMod_Item_t *drbSetupModCfg,  LogicalChannelConfig_t *ulLcCfg, LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7666 {
7667    if(drbCfg != NULLP)
7668    {
7669       if(extractDrbCfg(drbCfg, NULL, lcCfg, upTnlInfo) != ROK)
7670       {
7671          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7672          return RFAILED;
7673       }
7674    }
7675    else if(drbSetupModCfg != NULLP)
7676    {
7677       if(extractDrbCfg(NULL, drbSetupModCfg, lcCfg, upTnlInfo) != ROK)
7678       {
7679          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7680          return RFAILED;
7681       }
7682    }
7683    else
7684    {
7685       lcCfg->drbQos = NULLP;
7686       lcCfg->snssai = NULLP;
7687       if(lcCfg->lcId == SRB2_LCID)
7688          lcCfg->dlLcCfg.lcp = LC_PRIORITY_3;
7689       else
7690          lcCfg->dlLcCfg.lcp = LC_PRIORITY_1;
7691    }
7692    if(ulLcCfg)
7693    {
7694       lcCfg->ulLcCfgPres = true;
7695       extractUlLcCfg(&lcCfg->ulLcCfg, ulLcCfg);
7696    }
7697    else
7698       lcCfg->ulLcCfgPres = false;
7699    return ROK;
7700 }
7701
7702 /*******************************************************************
7703  *
7704  * @brief Function processing LC config info received from CU
7705  *
7706  * @details
7707  *
7708  *    Function : procMacLcCfg
7709  *
7710  *    Functionality: Function processing LC config info received from CU
7711  *
7712  * @params[in] F1AP message
7713  * @return ROK/RFAILED
7714  *
7715  * ****************************************************************/
7716
7717 uint8_t procMacLcCfg(uint8_t lcId, uint8_t rbType, uint8_t configType,\
7718 DRBs_ToBeSetup_Item_t *drbItem, DRBs_ToBeSetupMod_Item_t *drbSetupModItem, LogicalChannelConfig_t *ulLcCfg,\
7719 LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7720 {
7721    uint8_t ret = ROK;
7722
7723    lcCfg->lcId = lcId;
7724    lcCfg->configType = configType;
7725    if(rbType == RB_TYPE_SRB)
7726    {
7727       ret = extractMacRbCfg(lcId, NULL,NULL, ulLcCfg, lcCfg, NULL);
7728    }
7729    else if(rbType == RB_TYPE_DRB)
7730    {
7731       if(drbItem != NULL)
7732         ret = extractMacRbCfg(lcId, drbItem, NULL, ulLcCfg, lcCfg, upTnlInfo);
7733       else if(drbSetupModItem != NULL)
7734         ret = extractMacRbCfg(lcId, NULL, drbSetupModItem, ulLcCfg, lcCfg, upTnlInfo);
7735    }
7736    return ret;
7737 }
7738
7739 /*******************************************************************
7740  *
7741  * @brief Function to extract Rlc cfg To Add/Mod in CellGrp Info
7742  *
7743  * @details
7744  *
7745  *    Function : extractRlcCfgToAddMod
7746  *
7747  *    Functionality: Function to extract Rlc cfg To Add/Mod in CellGrp Info
7748  *
7749  * @params[in] CellGroupConfigRrc__rlc_BearerTo pointer
7750  *             DuUeCfg Pointer
7751  * @return ROK/RFAILED
7752  *
7753  * ****************************************************************/
7754
7755 uint8_t extractRlcCfgToAddMod(struct CellGroupConfigRrc__rlc_BearerToAddModList *lcCfg, DuUeCfg *ueCfgDb)
7756 {
7757   uint8_t idx, rbId, lcId, rlcMode, rbType;
7758   RLC_Config_t *f1RlcCfg = NULLP;
7759   LogicalChannelConfig_t *macUlLcCfg = NULLP;
7760
7761   for(idx = 0; idx < lcCfg->list.count; idx++)
7762   {
7763      lcId = lcCfg->list.array[idx]->logicalChannelIdentity;
7764      if(lcCfg->list.array[idx]->servedRadioBearer)
7765      {
7766         /* RadioBearer for SRB/DRB */
7767         if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7768         RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
7769         {
7770            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.srb_Identity;
7771            rbType = RB_TYPE_SRB;
7772         }
7773         else if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7774         RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
7775         {
7776            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.drb_Identity;
7777            rbType = RB_TYPE_DRB;
7778         }
7779         else
7780         {
7781            DU_LOG("\nERROR  -->  No components present in Bearer config to ADD/MOD");
7782            return RFAILED;
7783         }
7784         /* MAC UL LC Config */
7785         if(lcCfg->list.array[idx]->mac_LogicalChannelConfig)
7786         {
7787            macUlLcCfg = lcCfg->list.array[idx]->mac_LogicalChannelConfig;
7788         }
7789      }
7790      else
7791      {
7792         DU_LOG("\nERROR  -->  DUAPP: Received RadioBearer config is NULL");
7793         return RFAILED;
7794      }
7795      /* RLC Mode Config */
7796      if(lcCfg->list.array[idx]->rlc_Config)
7797      {
7798         rlcMode  = lcCfg->list.array[idx]->rlc_Config->present;
7799         f1RlcCfg = lcCfg->list.array[idx]->rlc_Config;
7800      }
7801
7802      /* Filling RLC/MAC Config*/
7803      memset(&ueCfgDb->macLcCfg[idx], 0, sizeof(LcCfg));
7804      memset(&ueCfgDb->rlcLcCfg[idx], 0, sizeof(RlcBearerCfg));
7805      procRlcLcCfg(rbId, lcId, rbType, rlcMode, CONFIG_UNKNOWN, f1RlcCfg, &(ueCfgDb->rlcLcCfg[idx]));
7806      if(procMacLcCfg(lcId, rbType, CONFIG_UNKNOWN, NULL, NULL, macUlLcCfg, &ueCfgDb->macLcCfg[idx], NULL) != ROK)
7807      {
7808         DU_LOG("\nERROR  -->  DU APP : Failed while filling MAC LC config at extractRlcCfgToAddMod()");
7809         return RFAILED;
7810      }
7811      (ueCfgDb->numRlcLcs)++;
7812      (ueCfgDb->numMacLcs)++;
7813          DU_LOG("\nDEBUG  -> DUAPP: extractRlcCfgToAddMod:RBType:%d, DrbID: %d,lcId:%d, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
7814                             rbType, rbId, lcId, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
7815   }
7816   //TODO: To send the failure cause in UeContextSetupRsp
7817   return ROK;
7818 }
7819
7820 /*******************************************************************
7821  *
7822  * @brief DeAlloc pdsch serv cell config info
7823  *
7824  * @details
7825  *
7826  *    Function : freeMacPdschServCellInfo
7827  *
7828  *    Functionality: DeAlloc pdsch serv cell config info
7829  *
7830  * @params[in] PdschServCellCfg pointer
7831  * @return void
7832  *
7833  * ****************************************************************/
7834
7835 void freeMacPdschServCellInfo(PdschServCellCfg *pdsch)
7836 {
7837    if(pdsch->xOverhead)
7838    {
7839       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->xOverhead, sizeof(PdschXOverhead));
7840    }
7841    if(pdsch->codeBlkGrpFlushInd)
7842    {
7843       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->codeBlkGrpFlushInd, sizeof(bool));
7844    }
7845    if(pdsch->maxCodeBlkGrpPerTb)
7846    {
7847       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
7848    }
7849    if(pdsch->maxMimoLayers)
7850    {
7851       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxMimoLayers, sizeof(uint8_t));
7852    }
7853 }
7854
7855 /*******************************************************************
7856  *
7857  * @brief Free Serving cell Info
7858  *
7859  * @details
7860  *
7861  *    Function : freeMacServingCellInfo
7862  *
7863  *    Functionality: Free Serving cell Info
7864  *
7865  * @params[in] ServCellCfgInfo *srvCellCfg
7866  * @return void
7867  *
7868  * ****************************************************************/
7869 void freeMacServingCellInfo(ServCellCfgInfo *srvCellCfg)
7870 {
7871    uint8_t timeDomRsrcIdx;
7872
7873    if(srvCellCfg->initDlBwp.pdschPresent)
7874    {
7875       for(timeDomRsrcIdx = 0; timeDomRsrcIdx < srvCellCfg->initDlBwp.pdschCfg.numTimeDomRsrcAlloc; timeDomRsrcIdx++)
7876       {
7877          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, \
7878             srvCellCfg->initDlBwp.pdschCfg.timeDomRsrcAllociList[timeDomRsrcIdx].k0, sizeof(uint8_t));
7879       }
7880    }
7881
7882    freeMacPdschServCellInfo(&srvCellCfg->pdschServCellCfg);
7883    if(srvCellCfg->bwpInactivityTmr)
7884    {
7885       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
7886    }
7887
7888    if(srvCellCfg->initUlBwp.pucchPresent)
7889    {
7890       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->initUlBwp.pucchCfg.dlDataToUlAck, sizeof(PucchDlDataToUlAck));
7891    }
7892 }
7893
7894 /*******************************************************************
7895  *
7896  * @brief Free cell Grp Cfg Info
7897  *
7898  * @details
7899  *
7900  *    Function : freeUeReCfgCellGrpInfo
7901  *
7902  *    Functionality: Free cell Grp Cfg Info
7903  *
7904  * @params[in] MacUeCfg*  duUeCfg
7905  * @return void
7906  *
7907  * ****************************************************************/
7908
7909 void freeUeReCfgCellGrpInfo(MacUeCfg *macUeCfg)
7910 {
7911    freeMacServingCellInfo(&macUeCfg->spCellCfg.servCellCfg);
7912 }
7913
7914 /*******************************************************************
7915  *
7916  * @brief Fills Reconfig SchReqReConfig
7917  *
7918  * @details
7919  *
7920  *    Function : extractSchReqReConfig
7921  *
7922  *    Functionality: Fills Reconfig SchReqReConfig
7923  *
7924  * @params[in] SchedulingRequestConfig_t *cuSchedReq
7925  *             SchedReqCfg*  macSchedReq
7926  * @return void
7927  *
7928  * ****************************************************************/
7929 void extractSchReqReConfig(SchedulingRequestConfig_t *cuSchedReq, SchedReqCfg *macSchedReq)
7930 {
7931    uint8_t schReqIdx = 0;
7932    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqListToAdd = NULLP;
7933    struct SchedulingRequestConfig__schedulingRequestToReleaseList *schReqListToRel = NULLP;
7934
7935    if(cuSchedReq->schedulingRequestToAddModList)
7936    {
7937       schReqListToAdd = cuSchedReq->schedulingRequestToAddModList;
7938       if(schReqListToAdd->list.count)
7939       {
7940          macSchedReq->addModListCount = schReqListToAdd->list.count;
7941          for(schReqIdx = 0; schReqIdx < schReqListToAdd->list.count; schReqIdx++)
7942          {
7943             macSchedReq->addModList[schReqIdx].schedReqId = \
7944                schReqListToAdd->list.array[schReqIdx]->schedulingRequestId;
7945             macSchedReq->addModList[schReqIdx].srProhibitTmr = \
7946                *(schReqListToAdd->list.array[schReqIdx]->sr_ProhibitTimer);
7947             macSchedReq->addModList[schReqIdx].srTransMax    =\
7948                schReqListToAdd->list.array[schReqIdx]->sr_TransMax;
7949          }
7950       }
7951    }
7952    /* Scheduling Req To release */
7953    if(cuSchedReq->schedulingRequestToReleaseList)
7954    {
7955       schReqListToRel = cuSchedReq->schedulingRequestToReleaseList;
7956       if(schReqListToRel->list.count)
7957       {
7958          macSchedReq->relListCount = schReqListToRel->list.count;
7959          for(schReqIdx = 0; schReqIdx < schReqListToRel->list.count; schReqIdx++)
7960          {
7961             macSchedReq->relList[schReqIdx] = \
7962                *schReqListToRel->list.array[schReqIdx];
7963          }
7964       }
7965    }
7966 }
7967
7968 /*******************************************************************
7969  *
7970  * @brief Fills TagReconfig
7971  *
7972  * @details
7973  *
7974  *    Function : extractTagReconfig
7975  *
7976  *    Functionality: Fills extractTagReconfig
7977  *
7978  * @params[in] TAG_Config_t *cuTagCfg
7979  *             TagCfg *macTagCfg
7980  * @return void
7981  *
7982  * ****************************************************************/
7983
7984 void extractTagReconfig(TAG_Config_t *cuTagCfg, TagCfg *macTagCfg)
7985 {
7986   uint8_t tagIdx = 0;
7987   struct TAG_Config__tag_ToAddModList  *tagListToAddMod = NULLP;
7988   struct TAG_Config__tag_ToReleaseList *tagListToRel = NULLP;
7989
7990   /* Tag config to AddMod */
7991   if(cuTagCfg->tag_ToAddModList)
7992   {
7993      tagListToAddMod = cuTagCfg->tag_ToAddModList;
7994      if(tagListToAddMod->list.count)
7995      {
7996         macTagCfg->addModListCount = tagListToAddMod->list.count;
7997         for(tagIdx = 0; tagIdx < tagListToAddMod->list.count; tagIdx++)
7998         {
7999            macTagCfg->addModList[tagIdx].tagId =\
8000               tagListToAddMod->list.array[tagIdx]->tag_Id;
8001            macTagCfg->addModList[tagIdx].timeAlignTimer = \
8002
8003               tagListToAddMod->list.array[tagIdx]->timeAlignmentTimer;
8004         }
8005      }
8006   }
8007   /* Tag config to release */
8008   if(cuTagCfg->tag_ToReleaseList)
8009   {
8010      tagListToRel = cuTagCfg->tag_ToReleaseList;
8011      if(tagListToRel->list.count)
8012      {
8013         macTagCfg->relListCount = tagListToRel->list.count;
8014         for(tagIdx = 0; tagIdx < tagListToRel->list.count; tagIdx++)
8015         {
8016            macTagCfg->relList[tagIdx] = *tagListToRel->list.array[tagIdx];
8017         }
8018      }
8019   }
8020 }
8021
8022 /*******************************************************************
8023  *
8024  * @brief Fills PdcchCfg received by CU
8025  *
8026  * @details
8027  *
8028  *    Function : extractPdcchCfg
8029  *
8030  *    Functionality: Fills PdcchCfg received  by CU
8031  *
8032  * @params[in] PDCCH_Config_t *cuPdcchCfg,
8033  *             PdcchConfig *duPdcchCfg
8034  * @return void
8035  *
8036  * ****************************************************************/
8037
8038 void extractPdcchCfg(PDCCH_Config_t *cuPdcchCfg, PdcchConfig *macPdcchCfg)
8039 {
8040    uint8_t cRsetIdx = 0;
8041    uint8_t srchSpcIdx = 0;
8042
8043    struct PDCCH_Config__controlResourceSetToAddModList *cRsetToAddModList = NULLP;
8044    struct PDCCH_Config__controlResourceSetToReleaseList *cRsetToRelList = NULLP;
8045    struct PDCCH_Config__searchSpacesToAddModList *srchSpcToAddModList = NULLP;
8046    struct PDCCH_Config__searchSpacesToReleaseList *srchSpcToRelList = NULLP;
8047
8048
8049    /* Control Resource Set To Add/Mod List */
8050    if(cuPdcchCfg->controlResourceSetToAddModList)
8051    {
8052       cRsetToAddModList = cuPdcchCfg->controlResourceSetToAddModList;
8053       if(cRsetToAddModList->list.count)
8054       {
8055          macPdcchCfg->numCRsetToAddMod = cRsetToAddModList->list.count;
8056          for(cRsetIdx = 0; cRsetIdx < cRsetToAddModList->list.count; cRsetIdx++)
8057          {
8058             macPdcchCfg->cRSetToAddModList[cRsetIdx].cRSetId = \
8059               cRsetToAddModList->list.array[cRsetIdx]->controlResourceSetId;
8060             bitStringToInt(&cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources,\
8061                macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc);
8062             macPdcchCfg->cRSetToAddModList[cRsetIdx].duration = \
8063               cRsetToAddModList->list.array[cRsetIdx]->duration;
8064
8065             macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType = \
8066               cRsetToAddModList->list.array[cRsetIdx]->cce_REG_MappingType.present;
8067             if(macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType == CCE_REG_MAPPINGTYPE_PR_INTERLEAVED)
8068             {
8069                //TODO: handle the case for Interleaved
8070             }
8071             macPdcchCfg->cRSetToAddModList[cRsetIdx].precoderGranularity = \
8072               cRsetToAddModList->list.array[cRsetIdx]->precoderGranularity;
8073             if(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID)
8074             {
8075                macPdcchCfg->cRSetToAddModList[cRsetIdx].dmrsScramblingId= \
8076                   *(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID);
8077             }
8078          }
8079       }
8080
8081    }
8082    /* Control Resource Set To Release List */
8083    if(cuPdcchCfg->controlResourceSetToReleaseList)
8084    {
8085       cRsetToRelList = cuPdcchCfg->controlResourceSetToReleaseList;
8086       if(cRsetToRelList->list.count)
8087       {
8088          macPdcchCfg->numCRsetToRel = cRsetToRelList->list.count;
8089          for(cRsetIdx = 0; cRsetIdx < cRsetToRelList->list.count; cRsetIdx++)
8090          {
8091             macPdcchCfg->cRSetToRelList[cRsetIdx] = *(cRsetToRelList->list.array[cRsetIdx]);
8092          }
8093       }
8094    }
8095
8096    /* Search space To Add/Mod List */
8097    if(cuPdcchCfg->searchSpacesToAddModList)
8098    {
8099       srchSpcToAddModList = cuPdcchCfg->searchSpacesToAddModList;
8100       if(srchSpcToAddModList->list.count)
8101       {
8102          macPdcchCfg->numSearchSpcToAddMod = srchSpcToAddModList->list.count;
8103          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToAddModList->list.count; srchSpcIdx++)
8104          {
8105             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceId =\
8106                srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceId;
8107             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].cRSetId =\
8108                *(srchSpcToAddModList->list.array[srchSpcIdx]->controlResourceSetId);
8109             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset)
8110             {
8111                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset =\
8112                   srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset->present;
8113             }
8114             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot)
8115             {
8116                bitStringToInt(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot,\
8117                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSymbolsWithinSlot);
8118             }
8119             if(srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates)
8120             {
8121               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel1 = \
8122                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel1;
8123               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel2 = \
8124                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel2;
8125               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel4 = \
8126                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel4;
8127
8128               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel8 = \
8129                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel8;
8130
8131               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel16 = \
8132                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel16;
8133             }
8134             if(srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType)
8135             {
8136                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType =\
8137                   srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->present;
8138                if(macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType == SEARCHSPACETYPE_PR_UE_SPECIFIC)
8139                {
8140                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].ueSpecificDciFormat =\
8141                      srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->choice.ue_Specific->dci_Formats;
8142                }
8143
8144             }
8145          }
8146       }
8147    }
8148    /* Search space To Rel List */
8149    if(cuPdcchCfg->searchSpacesToReleaseList)
8150    {
8151       srchSpcToRelList = cuPdcchCfg->searchSpacesToReleaseList;
8152       if(srchSpcToRelList->list.count)
8153       {
8154          macPdcchCfg->numSearchSpcToRel = srchSpcToRelList->list.count;
8155          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToRelList->list.count; srchSpcIdx++)
8156          {
8157             macPdcchCfg->searchSpcToRelList[srchSpcIdx] =\
8158                *(srchSpcToRelList->list.array[srchSpcIdx]);
8159          }
8160       }
8161    }
8162 }
8163
8164 /*******************************************************************
8165  *
8166  * @brief Fills PdschCfg received by CU
8167  *
8168  * @details
8169  *
8170  *    Function : extractPdschCfg
8171  *
8172  *    Functionality: Fills PdschCfg received  by CU
8173  *
8174  * @params[in] PDSCH_Config_t *cuPdschCfg = Information which is send by CU,
8175  *                   which we have stored in F1UeContextSetupDb,
8176  *             PdschConfig *macPdschCfg = Used to Store the information which
8177  *                   needs to send in other layer, as well as this can be the variable
8178  *                   which stores the information in DuCb,
8179  *             PdschConfig *storedPdschCfg =  Null in case of sending the
8180  *                   information to other layer else it will have stored pdsch
8181  *                   configuration in copyOfmacUeCfg.
8182  * @return void
8183  *
8184  * ****************************************************************/
8185
8186 void extractPdschCfg(PDSCH_Config_t *cuPdschCfg, PdschConfig *macPdschCfg, PdschConfig *storedPdschCfg)
8187 {
8188    uint8_t timeDomIdx;
8189    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAlloc = NULLP;
8190
8191    if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
8192    {
8193       if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->present == \
8194             PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup)
8195       {
8196          if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup)
8197          {
8198             macPdschCfg->dmrsDlCfgForPdschMapTypeA.addPos = \
8199                *(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_AdditionalPosition);
8200          }
8201       }
8202    }
8203    macPdschCfg->resourceAllocType = cuPdschCfg->resourceAllocation;
8204    if(cuPdschCfg->pdsch_TimeDomainAllocationList)
8205    {
8206       timeDomAlloc = cuPdschCfg->pdsch_TimeDomainAllocationList;
8207       if(timeDomAlloc->present ==\
8208             PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup)
8209       {
8210          if(timeDomAlloc->choice.setup)
8211          {
8212             macPdschCfg->numTimeDomRsrcAlloc  = timeDomAlloc->choice.setup->list.count;
8213             for(timeDomIdx = 0; timeDomIdx < timeDomAlloc->choice.setup->list.count; timeDomIdx++)
8214             {
8215                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 = NULLP;
8216                if(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0)
8217                {
8218                   if(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 == NULL)
8219                   {
8220                      if(storedPdschCfg)
8221                      {
8222                         if(storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
8223                         {
8224                            macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 =\
8225                            storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0;
8226                         }
8227                         else
8228                         {
8229                            DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
8230                         }
8231                      }
8232                      else
8233                      {
8234                         DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
8235                      }
8236                      if(!macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
8237                      {
8238                         DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for k0 at extractPdschCfg()");
8239                         return RFAILED;
8240                      }
8241                   }
8242                   *(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0) = \
8243                   *(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0);
8244                }
8245                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
8246                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
8247                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
8248                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8249             }
8250          }
8251       }
8252    }
8253    macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
8254    if(cuPdschCfg->maxNrofCodeWordsScheduledByDCI)
8255       macPdschCfg->numCodeWordsSchByDci = *(cuPdschCfg->maxNrofCodeWordsScheduledByDCI);
8256    if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_staticBundling)
8257    {
8258       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
8259       if(cuPdschCfg->prb_BundlingType.choice.staticBundling)
8260       {
8261          if(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize)
8262          {
8263             macPdschCfg->bundlingInfo.StaticBundling.size = \
8264                *(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize);
8265          }
8266       }
8267    }
8268    else if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_dynamicBundling)
8269    {
8270       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
8271    }
8272
8273 }
8274
8275 /*******************************************************************
8276  *
8277  * @brief Fills PdschServingCellCfg received by CU
8278  *
8279  * @details
8280  *
8281  *    Function : extractPdschServingCellCfg
8282  *
8283  *    Functionality: Fills PdschCfg received  by CU
8284  *
8285  * @params[in] PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg,
8286  *             PdschServCellCfg *macUePdschSrvCellCfg
8287  * @return ROK/RFAILED
8288  *
8289  * ****************************************************************/
8290
8291 uint8_t extractPdschServingCellCfg(PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg, PdschServCellCfg *macUePdschSrvCellCfg)
8292 {
8293    if(cuPdschSrvCellCfg->codeBlockGroupTransmission)
8294    {
8295       if(cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup)
8296       {
8297          if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
8298          {
8299             *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
8300                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
8301          }
8302          else
8303          {
8304             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
8305             if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
8306             {
8307                *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
8308                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
8309             }
8310             else
8311             {
8312                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
8313                return RFAILED;
8314             }
8315          }
8316          if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
8317          {
8318             *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
8319                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
8320          }
8321          else
8322          {
8323             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->codeBlkGrpFlushInd , sizeof(bool));
8324             if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
8325             {
8326                *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
8327                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
8328             }
8329             else
8330             {
8331                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
8332                return RFAILED;
8333             }
8334          }
8335       }
8336    }
8337    if(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH)
8338    {
8339       macUePdschSrvCellCfg->numHarqProcForPdsch = *(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH);
8340    }
8341    if(cuPdschSrvCellCfg->ext1)
8342    {
8343       if(cuPdschSrvCellCfg->ext1->maxMIMO_Layers)
8344       {
8345         if(macUePdschSrvCellCfg->maxMimoLayers)
8346         {
8347            *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
8348         }
8349         else
8350         {
8351            DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxMimoLayers, sizeof(uint8_t));
8352            if(macUePdschSrvCellCfg->maxMimoLayers)
8353            {
8354               *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
8355            }
8356            else
8357            {
8358               DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
8359               return RFAILED;
8360            }
8361         }
8362       }
8363    }
8364    if(cuPdschSrvCellCfg->xOverhead)
8365    {
8366       if(macUePdschSrvCellCfg->xOverhead)
8367       {
8368          *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
8369       }
8370       else
8371       {
8372          DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->xOverhead, sizeof(PdschXOverhead));
8373          if(macUePdschSrvCellCfg->xOverhead)
8374          {
8375             *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
8376          }
8377          else
8378          {
8379             DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
8380             return RFAILED;
8381          }
8382       }
8383    }
8384    return ROK;
8385 }
8386
8387 /*******************************************************************
8388  *
8389  * @brief Fills PuschCfg received by CU
8390  *
8391  * @details
8392  *
8393  *    Function : extractPuschCfg
8394  *
8395  *    Functionality: Fills PuschCfg received  by CU
8396  *
8397  * @params[in] BWP_UplinkDedicated__pusch_Config *cuPuschCfg,
8398  *             PuschCfg *macPuschCfg
8399  * @return void
8400  *
8401  * ****************************************************************/
8402
8403 void extractPuschCfg(struct BWP_UplinkDedicated__pusch_Config *cuPuschCfg, PuschCfg *macPuschCfg)
8404 {
8405    uint8_t timeDomIdx = 0;
8406    DMRS_UplinkConfig_t *dmrsUlCfg = NULLP;
8407    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList = NULLP;
8408
8409    if(cuPuschCfg->present == BWP_UplinkDedicated__pusch_Config_PR_setup)
8410    {
8411       if(cuPuschCfg->choice.setup)
8412       {
8413          if(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH)
8414          {
8415              macPuschCfg->dataScramblingId = \
8416                 *(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH);
8417          }
8418          if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA)
8419          {
8420             if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->present == PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup)
8421             {
8422                if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup)
8423                {
8424                   dmrsUlCfg = (cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup);
8425                   if(dmrsUlCfg->dmrs_AdditionalPosition)
8426                   {
8427                      macPuschCfg->dmrsUlCfgForPuschMapTypeA.addPos =\
8428                         *(dmrsUlCfg->dmrs_AdditionalPosition);
8429                   }
8430                   if(dmrsUlCfg->transformPrecodingDisabled)
8431                   {
8432                      if(dmrsUlCfg->transformPrecodingDisabled->scramblingID0)
8433                      {
8434                         macPuschCfg->dmrsUlCfgForPuschMapTypeA.transPrecodDisabled.scramblingId0 = \
8435                            *(dmrsUlCfg->transformPrecodingDisabled->scramblingID0);
8436                      }
8437                   }
8438                }
8439             }
8440          }
8441          /*Res Alloc Type for UL */
8442          if(cuPuschCfg->choice.setup->resourceAllocation)
8443          {
8444             macPuschCfg->resourceAllocType = \
8445                cuPuschCfg->choice.setup->resourceAllocation;
8446          }
8447          if(cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList)
8448          {
8449             timeDomAllocList = cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList;
8450             if(timeDomAllocList->present == PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup)
8451             {
8452                if(timeDomAllocList->choice.setup)
8453                {
8454                   macPuschCfg->numTimeDomRsrcAlloc = timeDomAllocList->choice.setup->list.count;
8455                   for(timeDomIdx = 0; timeDomIdx <timeDomAllocList->choice.setup->list.count; timeDomIdx++)
8456                   {
8457                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].k2 = \
8458                         *(timeDomAllocList->choice.setup->list.array[timeDomIdx]->k2);
8459                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].mappingType = \
8460                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->mappingType;
8461                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbolAndLength = \
8462                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8463                   }
8464                }
8465             }
8466          }
8467          if(cuPuschCfg->choice.setup->transformPrecoder)
8468             macPuschCfg->transformPrecoder = *(cuPuschCfg->choice.setup->transformPrecoder);
8469       }
8470    }
8471 }
8472
8473 /*******************************************************************
8474  *
8475  * @brief Function to fill pucch Power Control
8476  *
8477  * @details
8478  *
8479  *    Function : extractPucchPowerControl
8480  *
8481  *    Functionality: Function to fill pucch Power Control
8482  *
8483  * @params[in] PucchPowerControl *pwrCtrl,
8484  *             struct PUCCH_PowerControl *cuPwrCtrlCfg
8485  * @return void
8486  *
8487  * ****************************************************************/
8488
8489 void extractPucchPowerControl(PucchPowerControl *pwrCtrl, struct PUCCH_PowerControl *cuPwrCtrlCfg)
8490 {
8491    uint8_t arrIdx;
8492
8493    if(cuPwrCtrlCfg->deltaF_PUCCH_f0)
8494       pwrCtrl->deltaF_Format0 = *cuPwrCtrlCfg->deltaF_PUCCH_f0;
8495    if(cuPwrCtrlCfg->deltaF_PUCCH_f1)
8496       pwrCtrl->deltaF_Format1 = *cuPwrCtrlCfg->deltaF_PUCCH_f1;
8497    if(cuPwrCtrlCfg->deltaF_PUCCH_f2)
8498       pwrCtrl->deltaF_Format2 = *cuPwrCtrlCfg->deltaF_PUCCH_f2;
8499    if(cuPwrCtrlCfg->deltaF_PUCCH_f3)
8500       pwrCtrl->deltaF_Format3 = *cuPwrCtrlCfg->deltaF_PUCCH_f3;
8501    if(cuPwrCtrlCfg->deltaF_PUCCH_f4)
8502       pwrCtrl->deltaF_Format4 = *cuPwrCtrlCfg->deltaF_PUCCH_f4;
8503    if(cuPwrCtrlCfg->p0_Set)
8504    {
8505       pwrCtrl->p0SetCount = cuPwrCtrlCfg->p0_Set->list.count;
8506       for(arrIdx=0; arrIdx < pwrCtrl->p0SetCount; arrIdx++)
8507       {
8508          pwrCtrl->p0Set[arrIdx].p0PucchId =\
8509             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Id;
8510          pwrCtrl->p0Set[arrIdx].p0PucchVal =\
8511             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Value;
8512       }
8513    }
8514    if(cuPwrCtrlCfg->pathlossReferenceRSs)
8515    {
8516       pwrCtrl->pathLossRefRSListCount = cuPwrCtrlCfg->pathlossReferenceRSs->list.count;
8517       for(arrIdx = 0; arrIdx < pwrCtrl->pathLossRefRSListCount; arrIdx++)
8518       {
8519          pwrCtrl->pathLossRefRSList[arrIdx].pathLossRefRSId =\
8520             cuPwrCtrlCfg->pathlossReferenceRSs->list.array[arrIdx]->pucch_PathlossReferenceRS_Id;
8521       }
8522    }
8523 }
8524
8525  /*******************************************************************
8526  *
8527  * @brief Function to extractResrcSetToAddModList sent by CU
8528  *
8529  * @details
8530  *
8531  *    Function : extractResrcSetToAddModList
8532  *
8533  *    Functionality: Fucntion to extractResrcSetToAddModList
8534  *
8535  * @params[in] PucchResrcSetCfg pointer,
8536  *             struct PUCCH_Config__resourceSetToAddModList pointer
8537  * @return void
8538  *
8539  * ****************************************************************/
8540
8541 void extractResrcSetToAddModList(PucchResrcSetCfg *macRsrcSetList, struct PUCCH_Config__resourceSetToAddModList *cuRsrcSetList)
8542 {
8543    uint8_t arrIdx, rsrcListIdx;
8544
8545    macRsrcSetList->resrcSetToAddModListCount = cuRsrcSetList->list.count;
8546    for(arrIdx = 0; arrIdx < macRsrcSetList->resrcSetToAddModListCount; arrIdx++)
8547    {
8548       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcSetId     =\
8549          cuRsrcSetList->list.array[arrIdx]->pucch_ResourceSetId;
8550       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount =\
8551          cuRsrcSetList->list.array[arrIdx]->resourceList.list.count;
8552       for(rsrcListIdx = 0; rsrcListIdx < macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount; rsrcListIdx++)
8553       {
8554          macRsrcSetList->resrcSetToAddModList[arrIdx].resrcList[rsrcListIdx] =\
8555             *cuRsrcSetList->list.array[arrIdx]->resourceList.list.array[rsrcListIdx];
8556       }
8557       macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize =\
8558          *cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1;
8559    }
8560 }/* End of extractResrcSetToAddModList */
8561
8562 /*******************************************************************
8563  *
8564  * @brief Fills extractResrcToAddModList sent by CU
8565  *
8566  * @details
8567  *
8568  *    Function : extractResrcToAddModList
8569  *
8570  *    Functionality: Fills extractResrcToAddModList
8571  *
8572  * @params[in] PucchResrcCfg pointer,
8573  *             struct PUCCH_Config__resourceToAddModList pointer
8574  * @return ROk/RFAILED
8575  *
8576  * ****************************************************************/
8577
8578 uint8_t extractResrcToAddModList(PucchResrcCfg *macResrcList, struct PUCCH_Config__resourceToAddModList *cuResrcList)
8579 {
8580    uint8_t arrIdx;
8581
8582    macResrcList->resrcToAddModListCount = cuResrcList->list.count;
8583    for(arrIdx = 0; arrIdx < macResrcList->resrcToAddModListCount; arrIdx++)
8584    {
8585       macResrcList->resrcToAddModList[arrIdx].resrcId      =\
8586         cuResrcList->list.array[arrIdx]->pucch_ResourceId;
8587       macResrcList->resrcToAddModList[arrIdx].startPrb     =\
8588         cuResrcList->list.array[arrIdx]->startingPRB;
8589       if(cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping)
8590       {
8591          macResrcList->resrcToAddModList[arrIdx].intraFreqHop =\
8592            *cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping;
8593       }
8594       if(cuResrcList->list.array[arrIdx]->secondHopPRB)
8595       {
8596          macResrcList->resrcToAddModList[arrIdx].secondPrbHop =\
8597            *cuResrcList->list.array[arrIdx]->secondHopPRB;
8598       }
8599       /* PUCCH RSRC FORMAT */
8600       if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format0)
8601       {
8602          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_0;
8603          if(cuResrcList->list.array[arrIdx]->format.choice.format0)
8604          {
8605             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0, sizeof(PucchFormat0));
8606             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0 == NULLP)
8607             {
8608                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
8609                return RFAILED;
8610             }
8611             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->initialCyclicShift =\
8612                cuResrcList->list.array[arrIdx]->format.choice.format0->initialCyclicShift;
8613             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->numSymbols =\
8614                cuResrcList->list.array[arrIdx]->format.choice.format0->nrofSymbols;
8615             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->startSymbolIdx =\
8616                cuResrcList->list.array[arrIdx]->format.choice.format0->startingSymbolIndex;
8617          }
8618       }
8619       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format1)
8620       {
8621          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_1;
8622          if(cuResrcList->list.array[arrIdx]->format.choice.format1)
8623          {
8624             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1, sizeof(PucchFormat1));
8625             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1 == NULLP)
8626             {
8627                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
8628                return RFAILED;
8629             }
8630             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->initialCyclicShift =\
8631                 cuResrcList->list.array[arrIdx]->format.choice.format1->initialCyclicShift;
8632             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->numSymbols =\
8633                 cuResrcList->list.array[arrIdx]->format.choice.format1->nrofSymbols;
8634             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->startSymbolIdx =\
8635                 cuResrcList->list.array[arrIdx]->format.choice.format1->startingSymbolIndex;
8636             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->timeDomOCC =\
8637                 cuResrcList->list.array[arrIdx]->format.choice.format1->timeDomainOCC;
8638          }
8639       }
8640       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format2)
8641       {
8642          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_2;
8643          if(cuResrcList->list.array[arrIdx]->format.choice.format2)
8644          {
8645             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
8646             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2 == NULLP)
8647             {
8648                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
8649                return RFAILED;
8650             }
8651             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numPrbs =\
8652                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofPRBs;
8653             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numSymbols =\
8654                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofSymbols;
8655             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->startSymbolIdx =\
8656                 cuResrcList->list.array[arrIdx]->format.choice.format2->startingSymbolIndex;
8657          }
8658       }
8659       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format3)
8660       {
8661          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_3;
8662          if(cuResrcList->list.array[arrIdx]->format.choice.format3)
8663          {
8664             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
8665             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3 == NULLP)
8666             {
8667                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
8668                return RFAILED;
8669             }
8670             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numPrbs =\
8671                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofPRBs;
8672             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numSymbols =\
8673                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofSymbols;
8674             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->startSymbolIdx =\
8675                 cuResrcList->list.array[arrIdx]->format.choice.format3->startingSymbolIndex;
8676          }
8677       }
8678       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format4)
8679       {
8680          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_4;
8681          if(cuResrcList->list.array[arrIdx]->format.choice.format4)
8682          {
8683             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4, sizeof(PucchFormat4));
8684             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4 == NULLP)
8685             {
8686                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
8687                return RFAILED;
8688             }
8689             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->numSymbols =\
8690                 cuResrcList->list.array[arrIdx]->format.choice.format4->nrofSymbols;
8691             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occLen =\
8692                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Length;
8693             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occIdx =\
8694                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Index;
8695             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->startSymbolIdx =\
8696                 cuResrcList->list.array[arrIdx]->format.choice.format4->startingSymbolIndex;
8697          }
8698       }
8699    }
8700    return ROK;
8701
8702 }/* End of extractResrcToAddModList */
8703
8704 /*******************************************************************
8705  *
8706  * @brief Fills fillPucchSchedReqPeriodAndOffset sent by CU
8707  *
8708  * @details
8709  *
8710  *    Function : fillPucchSchedReqPeriodAndOffset
8711  *
8712  *    Functionality: To fillPucchSchedReqPeriodAndOffset
8713  *
8714  * @params[in] macPeriodicty,
8715  *     SchedulingRequestResourceConfig__periodicityAndOffset pointer
8716  * @return void
8717  *
8718  * ****************************************************************/
8719
8720 void fillPucchSchedReqPeriodAndOffset(uint8_t macPeriodicty, uint16_t  macOffset,\
8721    struct SchedulingRequestResourceConfig__periodicityAndOffset *cuPeriodicty)
8722 {
8723    macPeriodicty = cuPeriodicty->present;
8724    switch(macPeriodicty)
8725    {
8726       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
8727          {
8728             macOffset     = cuPeriodicty->choice.sym2;
8729             break;
8730          }
8731       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
8732          {
8733             macOffset     = cuPeriodicty->choice.sym6or7;
8734             break;
8735          }
8736       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
8737          {
8738             macOffset     = cuPeriodicty->choice.sl1;
8739             break;
8740          }
8741       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
8742          {
8743             macOffset = cuPeriodicty->choice.sl2;
8744             break;
8745          }
8746       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
8747          {
8748             macOffset = cuPeriodicty->choice.sl4;
8749             break;
8750          }
8751       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
8752          {
8753             macOffset = cuPeriodicty->choice.sl5;
8754             break;
8755          }
8756       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
8757          {
8758             macOffset = cuPeriodicty->choice.sl8;
8759             break;
8760          }
8761       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
8762          {
8763             macOffset = cuPeriodicty->choice.sl10;
8764             break;
8765          }
8766       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
8767          {
8768             macOffset = cuPeriodicty->choice.sl16;
8769             break;
8770          }
8771       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
8772          {
8773             macOffset = cuPeriodicty->choice.sl20;
8774             break;
8775          }
8776       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
8777          {
8778             macOffset = cuPeriodicty->choice.sl40;
8779             break;
8780          }
8781       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
8782          {
8783             macOffset = cuPeriodicty->choice.sl80;
8784             break;
8785          }
8786       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
8787          {
8788             macOffset = cuPeriodicty->choice.sl160;
8789             break;
8790          }
8791       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
8792          {
8793             macOffset = cuPeriodicty->choice.sl320;
8794             break;
8795          }
8796       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
8797          {
8798             macOffset = cuPeriodicty->choice.sl640;
8799             break;
8800          }
8801       default :
8802          DU_LOG("\nERROR  -->  F1AP : Invalid periodicity %d", macPeriodicty);
8803    }
8804 }
8805
8806 /*******************************************************************
8807  *
8808  * @brief Function to extractPucchFormatCfg sent by CU
8809  *
8810  * @details
8811  *
8812  *    Function : extractPucchFormatCfg
8813  *
8814  *    Functionality: Function to extractPucchFormatCfg
8815  *
8816  * @params[in] PucchFormatCfg pointer,
8817  *             PUCCH_FormatConfig_t pointer
8818  * @return void
8819  *
8820  * ****************************************************************/
8821
8822 void extractPucchFormatCfg(PucchFormatCfg *macFormatCfg, PUCCH_FormatConfig_t *cuFormatCfg)
8823  {
8824     if(cuFormatCfg->interslotFrequencyHopping)
8825        macFormatCfg->interSlotFreqHop = *cuFormatCfg->interslotFrequencyHopping;
8826     if(cuFormatCfg->additionalDMRS)
8827        macFormatCfg->addDmrs = *cuFormatCfg->additionalDMRS;
8828     if(cuFormatCfg->maxCodeRate)
8829        macFormatCfg->maxCodeRate = *cuFormatCfg->maxCodeRate;
8830     if(cuFormatCfg->nrofSlots)
8831        macFormatCfg->numSlots = *cuFormatCfg->nrofSlots;
8832     if(cuFormatCfg->pi2BPSK)
8833        macFormatCfg->pi2BPSK = *cuFormatCfg->pi2BPSK;
8834     if(cuFormatCfg->simultaneousHARQ_ACK_CSI)
8835        macFormatCfg->harqAckCSI = *cuFormatCfg->simultaneousHARQ_ACK_CSI;
8836  }/* End of extractPucchFormatCfg */
8837
8838 /*******************************************************************
8839  *
8840  * @brief Function to extractSchedReqCfgToAddMod sent by CU
8841  *
8842  * @details
8843  *
8844  *    Function : extractSchedReqCfgToAddMod
8845  *
8846  *    Functionality: Function to extractSchedReqCfgToAddMod
8847  *
8848  * @params[in] PucchSchedReqCfg pointer,
8849  *      PUCCH_Config__schedulingRequestResourceToAddModList pointer
8850  * @return void
8851  *
8852  * ****************************************************************/
8853
8854 void extractSchedReqCfgToAddMod(PucchSchedReqCfg *macSchedReqCfg, struct PUCCH_Config__schedulingRequestResourceToAddModList *cuSchedReqList)
8855 {
8856    uint8_t arrIdx;
8857
8858    macSchedReqCfg->schedAddModListCount = cuSchedReqList->list.count;
8859    for(arrIdx = 0; arrIdx <  macSchedReqCfg->schedAddModListCount; arrIdx++)
8860    {
8861       macSchedReqCfg->schedAddModList[arrIdx].resrcId =\
8862          cuSchedReqList->list.array[arrIdx]->schedulingRequestResourceId;
8863       macSchedReqCfg->schedAddModList[arrIdx].requestId =\
8864          cuSchedReqList->list.array[arrIdx]->schedulingRequestID;
8865       if(cuSchedReqList->list.array[arrIdx]->periodicityAndOffset)
8866       {
8867          fillPucchSchedReqPeriodAndOffset(macSchedReqCfg->schedAddModList[arrIdx].periodicity,\
8868             macSchedReqCfg->schedAddModList[arrIdx].offset, cuSchedReqList->list.array[arrIdx]->periodicityAndOffset);
8869       }
8870       if(cuSchedReqList->list.array[arrIdx]->resource)
8871       {
8872          macSchedReqCfg->schedAddModList[arrIdx].resrc =\
8873             *cuSchedReqList->list.array[arrIdx]->resource;
8874       }
8875    }
8876
8877 }/* End of extractSchedReqCfgToAddMod */
8878
8879  /*******************************************************************
8880  *
8881  * @brief Fills PucchCfg received by CU
8882  *
8883  * @details
8884  *
8885  *    Function : extractPucchCfg
8886  *
8887  *    Functionality: Fills PucchCfg received  by CU
8888  *
8889  * @params[in] BWP_UplinkDedicated__pucch_Config *cuPucchCfg = Information which
8890  *                is send by CU, which we have stored in F1UeContextSetupDb,
8891  *             PucchCfg *macPucchCfg = Used to Store the information which
8892  *                needs to send in other layer, as well as this can be the variable
8893  *                which stores the information in DuCb,
8894  *             PucchCfg *storedPucchCfg = Null in case of sending the
8895  *                information to other layer else it will have Pucch Cfg which
8896  *                we have stored in copyOfmacUeCfg.
8897  * @return ROK/RFAILED
8898  *
8899  * ****************************************************************/
8900
8901 uint8_t extractPucchCfg(struct BWP_UplinkDedicated__pucch_Config *cuPucchCfg, PucchCfg *macPucchCfg,\
8902 PucchCfg *storedPucchCfg)
8903 {
8904    uint8_t arrIdx;
8905
8906    if(cuPucchCfg->present == BWP_UplinkDedicated__pucch_Config_PR_setup)
8907    {
8908       if(cuPucchCfg->choice.setup)
8909       {
8910          /* Resource Set Cfg */
8911          if(cuPucchCfg->choice.setup->resourceSetToAddModList)
8912          {
8913             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrcSet, sizeof(PucchResrcSetCfg));
8914             if(macPucchCfg->resrcSet == NULLP)
8915             {
8916                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
8917                return RFAILED;
8918             }
8919             memset(macPucchCfg->resrcSet, 0, sizeof(PucchResrcSetCfg));
8920             extractResrcSetToAddModList(macPucchCfg->resrcSet, cuPucchCfg->choice.setup->resourceSetToAddModList);
8921          }
8922
8923          /* Resource Cfg */
8924          if(cuPucchCfg->choice.setup->resourceToAddModList)
8925          {
8926             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrc, sizeof(PucchResrcCfg));
8927             if(macPucchCfg->resrc == NULLP)
8928             {
8929                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
8930                return RFAILED;
8931             }
8932             memset(macPucchCfg->resrc, 0, sizeof(PucchResrcCfg));
8933             extractResrcToAddModList(macPucchCfg->resrc, cuPucchCfg->choice.setup->resourceToAddModList);
8934          }
8935
8936          /* Format 1 Cfg */
8937          if(cuPucchCfg->choice.setup->format1)
8938          {
8939             DU_ALLOC_SHRABL_BUF(macPucchCfg->format1, sizeof(PucchFormatCfg));
8940             if(macPucchCfg->format1 == NULLP)
8941             {
8942                DU_LOG("\nERROR --> F1AP : Failed to extract format 1 Cfg in  extractPucchCfg()");
8943                return RFAILED;
8944             }
8945             memset(macPucchCfg->format1, 0, sizeof(PucchFormatCfg));
8946             extractPucchFormatCfg(macPucchCfg->format1,\
8947                cuPucchCfg->choice.setup->format1->choice.setup);
8948          }
8949
8950          /* Format 2 Cfg */
8951          if(cuPucchCfg->choice.setup->format2)
8952          {
8953             DU_ALLOC_SHRABL_BUF(macPucchCfg->format2, sizeof(PucchFormatCfg));
8954             if(macPucchCfg->format2 == NULLP)
8955             {
8956                DU_LOG("\nERROR --> F1AP : Failed to extract format 2 Cfg in  extractPucchCfg()");
8957                return RFAILED;
8958             }
8959             memset(macPucchCfg->format2, 0, sizeof(PucchFormatCfg));
8960             extractPucchFormatCfg(macPucchCfg->format2,\
8961                cuPucchCfg->choice.setup->format2->choice.setup);
8962          }
8963
8964          /* Format 3 Cfg */
8965          if(cuPucchCfg->choice.setup->format3)
8966          {
8967             DU_ALLOC_SHRABL_BUF(macPucchCfg->format3, sizeof(PucchFormatCfg));
8968             if(macPucchCfg->format3 == NULLP)
8969             {
8970                DU_LOG("\nERROR --> F1AP : Failed to extract format 3 Cfg in  extractPucchCfg()");
8971                return RFAILED;
8972             }
8973             memset(macPucchCfg->format3, 0, sizeof(PucchFormatCfg));
8974             extractPucchFormatCfg(macPucchCfg->format3,\
8975                cuPucchCfg->choice.setup->format3->choice.setup);
8976          }
8977
8978          /* Format 4 Cfg */
8979          if(cuPucchCfg->choice.setup->format4)
8980          {
8981             DU_ALLOC_SHRABL_BUF(macPucchCfg->format4, sizeof(PucchFormatCfg));
8982             if(macPucchCfg->format4 == NULLP)
8983             {
8984                DU_LOG("\nERROR --> F1AP : Failed to extract format 4 Cfg in  extractPucchCfg()");
8985                return RFAILED;
8986             }
8987             memset(macPucchCfg->format4, 0, sizeof(PucchFormatCfg));
8988             extractPucchFormatCfg(macPucchCfg->format4,\
8989                cuPucchCfg->choice.setup->format4->choice.setup);
8990          }
8991
8992          /* Sched Req List */
8993          if(cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList)
8994          {
8995             DU_ALLOC_SHRABL_BUF(macPucchCfg->schedReq, sizeof(PucchSchedReqCfg));
8996             if(macPucchCfg->schedReq == NULLP)
8997             {
8998                DU_LOG("\nERROR --> F1AP : Failed to extract schedReqCfg in  extractPucchCfg()");
8999                return RFAILED;
9000             }
9001             memset(macPucchCfg->schedReq, 0, sizeof(PucchSchedReqCfg));
9002             extractSchedReqCfgToAddMod(macPucchCfg->schedReq,\
9003             cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList);
9004          }
9005
9006          /*TODO: Add support for  Spatial Info */
9007
9008          /* MultiCsiCfg */
9009          if(cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList)
9010          {
9011             DU_ALLOC_SHRABL_BUF(macPucchCfg->multiCsiCfg, sizeof(PucchMultiCsiCfg));
9012             if(macPucchCfg->multiCsiCfg == NULLP)
9013             {
9014                DU_LOG("\nERROR --> F1AP : Failed to extract multiCsiCfg in  extractPucchCfg()");
9015                return RFAILED;
9016             }
9017             memset(macPucchCfg->multiCsiCfg, 0, sizeof(PucchMultiCsiCfg));
9018             macPucchCfg->multiCsiCfg->multiCsiResrcListCount = cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.count;
9019             for(arrIdx =0; arrIdx < macPucchCfg->multiCsiCfg->multiCsiResrcListCount; arrIdx++)
9020             {
9021                macPucchCfg->multiCsiCfg->multiCsiResrcList[arrIdx] =\
9022                  *cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.array[arrIdx];
9023             }
9024          }
9025
9026          /* Dl_DataToUL_ACK */
9027          if(cuPucchCfg->choice.setup->dl_DataToUL_ACK)
9028     {
9029        if(storedPucchCfg)
9030        {
9031           if(storedPucchCfg->dlDataToUlAck)
9032           {
9033              macPucchCfg->dlDataToUlAck = storedPucchCfg->dlDataToUlAck;
9034           }
9035           else
9036           {
9037             DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
9038           }
9039        }
9040        else
9041        {
9042           DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
9043        }
9044        if(macPucchCfg->dlDataToUlAck == NULLP)
9045        {
9046           DU_LOG("\nERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
9047           return RFAILED;
9048        }
9049        memset(macPucchCfg->dlDataToUlAck, 0, sizeof(PucchDlDataToUlAck));
9050        macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount = cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.count;
9051        for(arrIdx = 0; arrIdx < macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount; arrIdx++)
9052        {
9053           macPucchCfg->dlDataToUlAck->dlDataToUlAckList[arrIdx] =\
9054           *cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.array[arrIdx];
9055        }
9056          }
9057
9058          /* Power Control */
9059          if(cuPucchCfg->choice.setup->pucch_PowerControl)
9060          {
9061             DU_ALLOC_SHRABL_BUF(macPucchCfg->powerControl, sizeof(PucchPowerControl));
9062             if(macPucchCfg->powerControl == NULLP)
9063             {
9064                DU_LOG("\nERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
9065                return RFAILED;
9066             }
9067             extractPucchPowerControl(macPucchCfg->powerControl,\
9068                cuPucchCfg->choice.setup->pucch_PowerControl);
9069          }
9070       }
9071    }
9072    return ROK;
9073 }
9074
9075 /*******************************************************************
9076  *
9077  * @brief Fills ServingCellReconfig received by CU
9078  *
9079  * @details
9080  *
9081  *    Function : extractSpCellDedicatedCfg
9082  *
9083  *    Functionality: Fills ServingCellReconfig received  by CU
9084  *
9085  * @params[in] ServingCellConfig_t *cuSrvCellCfg = Information which is send by
9086  *                  CU, which we have stored in F1UeContextSetupDb,
9087  *             ServCellCfgInfo *macSrvCellCfg = Used to Store the information
9088  *                  which  needs to send in other layer, as well as this can be the
9089  *                  variable which stores the information in DuCb,
9090  *             ServCellCfgInfo *storedSrvCellCfg = Null in case of sending the
9091  *                  information to other layer else it will have ServCellCfgInfo which
9092  *                  we have stored in copyOfmacUeCfg.
9093  * @return ROK/RFAILD
9094  *
9095  * ****************************************************************/
9096 uint8_t extractSpCellDedicatedCfg(ServingCellConfig_t *cuSrvCellCfg, ServCellCfgInfo *macSrvCellCfg,\
9097 ServCellCfgInfo *storedSrvCellCfg)
9098 {
9099    uint8_t ret = ROK;
9100    BWP_DownlinkDedicated_t *dlBwp = NULLP;
9101    BWP_UplinkDedicated_t   *ulBwp = NULLP;
9102
9103    if(cuSrvCellCfg->initialDownlinkBWP)
9104    {
9105       dlBwp = ((BWP_DownlinkDedicated_t *)(cuSrvCellCfg->initialDownlinkBWP));
9106       if(dlBwp->pdcch_Config)
9107       {
9108          if(dlBwp->pdcch_Config->choice.setup)
9109          {
9110             macSrvCellCfg->initDlBwp.pdcchPresent = true;
9111             extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
9112          }
9113       }
9114       if(dlBwp->pdsch_Config)
9115       {
9116          if(dlBwp->pdsch_Config->choice.setup)
9117          {
9118             macSrvCellCfg->initDlBwp.pdschPresent = true;
9119
9120             if(storedSrvCellCfg)
9121             {
9122                if(!storedSrvCellCfg->initDlBwp.pdschPresent)
9123                {
9124                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
9125                }
9126                else
9127                {
9128                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg,\
9129                         &storedSrvCellCfg->initDlBwp.pdschCfg);
9130                }
9131             }
9132             else
9133             {
9134                extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
9135             }
9136          }
9137       }
9138    }
9139    if(cuSrvCellCfg->firstActiveDownlinkBWP_Id)
9140       macSrvCellCfg->firstActvDlBwpId = *(cuSrvCellCfg->firstActiveDownlinkBWP_Id);
9141    if(cuSrvCellCfg->defaultDownlinkBWP_Id)
9142       macSrvCellCfg->defaultDlBwpId = *(cuSrvCellCfg->defaultDownlinkBWP_Id);
9143    if(cuSrvCellCfg->bwp_InactivityTimer)
9144    {
9145       if(macSrvCellCfg->bwpInactivityTmr)
9146       {
9147          memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
9148       }
9149       else
9150       {
9151          macSrvCellCfg->bwpInactivityTmr = NULLP;
9152          DU_ALLOC_SHRABL_BUF(macSrvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
9153          if(macSrvCellCfg->bwpInactivityTmr)
9154          {
9155             memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
9156          }
9157          else
9158          {
9159             DU_LOG("\nERROR  --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
9160             return RFAILED;
9161          }
9162       }
9163    }
9164    if(cuSrvCellCfg->pdsch_ServingCellConfig)
9165    {
9166       if(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup)
9167       {
9168          ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
9169          if(ret == RFAILED)
9170          {
9171             DU_LOG("\nERROR --> F1AP : Failed at extractPdschServingCellCfg()");
9172             return RFAILED;
9173          }
9174       }
9175    }
9176    if(cuSrvCellCfg->uplinkConfig)
9177    {
9178       if(cuSrvCellCfg->uplinkConfig->initialUplinkBWP)
9179       {
9180          ulBwp = ((BWP_UplinkDedicated_t *)(cuSrvCellCfg->uplinkConfig->initialUplinkBWP));
9181          if(ulBwp->pusch_Config)
9182          {
9183             macSrvCellCfg->initUlBwp.puschPresent = true;
9184             extractPuschCfg(ulBwp->pusch_Config, &macSrvCellCfg->initUlBwp.puschCfg);
9185          }
9186          if(ulBwp->pucch_Config)
9187          {
9188             macSrvCellCfg->initUlBwp.pucchPresent = true;
9189             memset(&macSrvCellCfg->initUlBwp.pucchCfg, 0, sizeof(PucchCfg));
9190             if(storedSrvCellCfg)
9191             {
9192                if(!storedSrvCellCfg->initUlBwp.pucchPresent)
9193                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
9194                else
9195                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg,\
9196                   &storedSrvCellCfg->initUlBwp.pucchCfg);
9197             }
9198             else
9199             {
9200                extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
9201             }
9202          }
9203       }
9204       if(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id)
9205          macSrvCellCfg->firstActvUlBwpId = *(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id);
9206    }
9207    return ret;
9208 }
9209 /*******************************************************************
9210  *
9211  * @brief Fills Reconfig Cell group Info received by CU
9212  *
9213  * @details
9214  *
9215  *    Function : extractUeReCfgCellInfo
9216  *
9217  *    Functionality: Fills Reconfig Cell group Info received by CU
9218  *
9219  * @params[in] CellGroupConfigRrc_t *cellGrp = CellGroupConfigRrc_t information which
9220  *                       is send by CU, which we have stored in F1UeContextSetupDb
9221  *             MacUeCfg *MacUeCfg = Used to Store the information,
9222  *                      which needs to send in other layer, as well as this can be
9223  *                      the variable which stores the information in DuCb,
9224  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
9225  *                      information to other layer else it will have copyOfmacUeCfg
9226  *                      which we have stored in F1UeContextSetupDb.
9227  *
9228  * @return ROK/RFAILED
9229  *
9230  * ****************************************************************/
9231 uint8_t extractUeReCfgCellInfo(CellGroupConfigRrc_t *cellGrp, MacUeCfg *macUeCfg, MacUeCfg *storedMacUeCfg)
9232 {
9233    uint8_t ret = ROK;
9234    MAC_CellGroupConfig_t     *macCellGroup = NULLP;
9235    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
9236    SpCellConfig_t            *spcellCfg = NULLP;
9237    ServingCellConfig_t       *servCellCfg = NULLP;
9238
9239    if(cellGrp)
9240    {
9241       /* Fill MacCell Group Reconfig  */
9242       if(cellGrp->mac_CellGroupConfig)
9243       {
9244          macUeCfg->macCellGrpCfgPres = true;
9245          macCellGroup = ((MAC_CellGroupConfig_t *)(cellGrp->mac_CellGroupConfig));
9246          if(macCellGroup->schedulingRequestConfig)
9247          {
9248             extractSchReqReConfig(macCellGroup->schedulingRequestConfig, &macUeCfg->macCellGrpCfg.schReqCfg);
9249          }
9250          if(macCellGroup->tag_Config)
9251          {
9252             extractTagReconfig(macCellGroup->tag_Config, &macUeCfg->macCellGrpCfg.tagCfg);
9253          }
9254          if(macCellGroup->bsr_Config)
9255          {
9256             macUeCfg->macCellGrpCfg.bsrTmrCfg.periodicTimer = macCellGroup->bsr_Config->periodicBSR_Timer;
9257             macUeCfg->macCellGrpCfg.bsrTmrCfg.retxTimer     = macCellGroup->bsr_Config->retxBSR_Timer;
9258             if(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer)
9259             {
9260                macUeCfg->macCellGrpCfg.bsrTmrCfg.srDelayTimer  =\
9261                *(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer);
9262             }
9263          }
9264          if(macCellGroup->phr_Config)
9265          {
9266             if(macCellGroup->phr_Config->present == MAC_CellGroupConfig__phr_Config_PR_setup)
9267             {
9268                macUeCfg->macCellGrpCfg.phrCfgSetupPres = true;
9269                if(macCellGroup->phr_Config->choice.setup)
9270                {
9271                   macUeCfg->macCellGrpCfg.phrCfg.periodicTimer     = \
9272                   macCellGroup->phr_Config->choice.setup->phr_PeriodicTimer;
9273                   macUeCfg->macCellGrpCfg.phrCfg.prohibitTimer     = \
9274                   macCellGroup->phr_Config->choice.setup->phr_ProhibitTimer;
9275                   macUeCfg->macCellGrpCfg.phrCfg.txPowerFactor     = \
9276                   macCellGroup->phr_Config->choice.setup->phr_Tx_PowerFactorChange;
9277                   macUeCfg->macCellGrpCfg.phrCfg.multiplePHR       = \
9278                   macCellGroup->phr_Config->choice.setup->multiplePHR;
9279                   macUeCfg->macCellGrpCfg.phrCfg.dummy             = \
9280                   macCellGroup->phr_Config->choice.setup->dummy;
9281                   macUeCfg->macCellGrpCfg.phrCfg.phrType2OtherCell = \
9282                   macCellGroup->phr_Config->choice.setup->phr_Type2OtherCell;
9283                   macUeCfg->macCellGrpCfg.phrCfg.phrOtherCG        = \
9284                   macCellGroup->phr_Config->choice.setup->phr_ModeOtherCG;
9285                }
9286             }
9287          }
9288       }
9289       /* Fill Physical Cell Group Reconfig */
9290       if(cellGrp->physicalCellGroupConfig)
9291       {
9292          macUeCfg->phyCellGrpCfgPres = true;
9293          phyCellGrpCfg = ((PhysicalCellGroupConfig_t *)(cellGrp->physicalCellGroupConfig));
9294          if(phyCellGrpCfg->p_NR_FR1)
9295          {
9296             if(*(phyCellGrpCfg->p_NR_FR1) != macUeCfg->phyCellGrpCfg.pNrFr1)
9297                macUeCfg->phyCellGrpCfg.pNrFr1 = *(phyCellGrpCfg->p_NR_FR1);
9298          }
9299          macUeCfg->phyCellGrpCfg.pdschHarqAckCodebook = phyCellGrpCfg->pdsch_HARQ_ACK_Codebook;
9300       }
9301       /* Fill SpCell Reconfig */
9302       if(cellGrp->spCellConfig)
9303       {
9304          macUeCfg->spCellCfgPres = true;
9305          spcellCfg = ((SpCellConfig_t *)(cellGrp->spCellConfig));
9306          if(spcellCfg->servCellIndex)
9307          {
9308             macUeCfg->spCellCfg.servCellIdx = *(spcellCfg->servCellIndex);
9309          }
9310          /* Fill Serving cell Reconfig info */
9311          if(cellGrp->spCellConfig->spCellConfigDedicated)
9312          {
9313             servCellCfg = ((ServingCellConfig_t *)(cellGrp->spCellConfig->spCellConfigDedicated));
9314             if(storedMacUeCfg)
9315             {
9316                if(!storedMacUeCfg->spCellCfgPres)
9317                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
9318                else
9319                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg,\
9320                         &storedMacUeCfg->spCellCfg.servCellCfg);
9321             }
9322             else
9323             {
9324                ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
9325             }
9326             if(ret == RFAILED)
9327             {
9328                DU_LOG("\nERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
9329             }
9330          }
9331       }
9332    }
9333    return ret;
9334 }
9335 /*******************************************************************
9336 *
9337 * @brief free the memory allocated by decoder
9338 *
9339 * @details
9340 *
9341 *    Function : freeAperDecodeNrcgi
9342 *
9343 *    Functionality: Free Nrcgi values
9344 *
9345 * @params[in] NRCGI_t *nrcgi
9346 * @return void
9347 *
9348 * ****************************************************************/
9349
9350
9351 void freeAperDecodeNrcgi(NRCGI_t *nrcgi)
9352 {
9353     if(nrcgi->pLMN_Identity.buf != NULLP)
9354     {
9355        free(nrcgi->pLMN_Identity.buf);
9356     }
9357     if(nrcgi->nRCellIdentity.buf != NULLP)
9358     {
9359        free(nrcgi->nRCellIdentity.buf);
9360     }
9361 }
9362 /*******************************************************************
9363 *
9364 * @brief free the memory allocated by decoder
9365 *
9366 * @details
9367 *
9368 *    Function : freeAperDecodeCuToDuInfo
9369 *
9370 *    Functionality:  Free Cu To Du Information
9371 *
9372 * @params[in] CUtoDURRCInformation_t *rrcMsg
9373 * @return void
9374 *
9375 * ****************************************************************/
9376
9377
9378 void freeAperDecodeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
9379 {
9380    uint8_t ieIdx =0;
9381    uint8_t arrIdx =0;
9382
9383    if(rrcMsg->uE_CapabilityRAT_ContainerList)
9384    {
9385       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
9386          free(rrcMsg->uE_CapabilityRAT_ContainerList->buf);
9387       free(rrcMsg->uE_CapabilityRAT_ContainerList);
9388    }
9389
9390    if(rrcMsg->iE_Extensions)
9391    {
9392       if(rrcMsg->iE_Extensions->list.array)
9393       {
9394          for(ieIdx= 0; ieIdx < rrcMsg->iE_Extensions->list.count; ieIdx++)
9395          {
9396             if(rrcMsg->iE_Extensions->list.array[ieIdx])
9397             {
9398                switch(rrcMsg->iE_Extensions->list.array[ieIdx]->id)
9399                {
9400                   case ProtocolIE_ID_id_CellGroupConfig:
9401                      if(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
9402                      {
9403                         free(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf);
9404                      }
9405                      break;
9406                   default:
9407                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
9408                            rrcMsg->iE_Extensions->list.array[ieIdx]->id);
9409                      break;
9410                }
9411             }
9412          }
9413          for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
9414          {
9415             free(rrcMsg->iE_Extensions->list.array[arrIdx]);
9416          }
9417          free(rrcMsg->iE_Extensions->list.array);
9418
9419       }
9420
9421       free(rrcMsg->iE_Extensions);
9422    }
9423 }
9424 /*******************************************************************
9425 *
9426 * @brief free the memory allocated by decoder
9427 *
9428 * @details
9429 *
9430 *    Function : freeAperDecodeSplCellList
9431 *
9432 *    Functionality: Free Spl Cell List
9433                     where memory allocated by aper_decoder
9434 *
9435 * @params[in]  SCell_ToBeSetup_List_t *spCellLst
9436 * @return void
9437 *
9438 * ****************************************************************/
9439
9440
9441 void freeAperDecodeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
9442 {
9443     uint8_t  cellIdx =0;
9444
9445     if(spCellLst->list.array != NULLP)
9446     {
9447        for(cellIdx=0; cellIdx<spCellLst->list.count; cellIdx++)
9448        {
9449           if(cellIdx==0&&spCellLst->list.array[cellIdx]!=NULLP)
9450           {
9451              freeAperDecodeNrcgi(&spCellLst->list.array[cellIdx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
9452           }
9453           if(spCellLst->list.array[cellIdx]!=NULLP)
9454           {
9455              free(spCellLst->list.array[cellIdx]);
9456           }
9457        }
9458        free(spCellLst->list.array);
9459     }
9460 }
9461 /*******************************************************************
9462 *
9463 * @brief free the memory allocated by decoder
9464 *
9465 * @details
9466 *
9467 *    Function : freeAperDecodeSRBSetup
9468 *
9469 *    Functionality: added free part for the memory allocated by aper_decoder
9470 *
9471 * @params[in] SRBs_ToBeSetup_List_t *srbSet
9472 * @return void
9473 *
9474 ****************************************************************/
9475
9476
9477 void freeAperDecodeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
9478 {
9479     uint8_t srbIdx =0;
9480     if(srbSet->list.array != NULLP)
9481     {
9482        for(srbIdx=0; srbIdx<srbSet->list.count; srbIdx++)
9483        {
9484           if(srbSet->list.array[srbIdx]!=NULLP)
9485           {
9486              free(srbSet->list.array[srbIdx]);
9487           }
9488        }
9489        free(srbSet->list.array);
9490     }
9491 }
9492
9493 /*******************************************************************
9494 *
9495 * @brief free the memory allocated by decoder
9496 *
9497 * @details
9498 *
9499 *    Function : freeAperDecodeULTnlInfo
9500 *
9501 *    Functionality: added free part for the memory allocated by aper_decoder
9502 *
9503 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
9504 * @return void
9505 *
9506 * ****************************************************************/
9507
9508
9509 void freeAperDecodeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
9510 {
9511    uint8_t ulIdx=0;
9512    if(ulInfo->list.array != NULLP)
9513    {
9514       for(ulIdx=0; ulIdx<ulInfo->list.count; ulIdx++)
9515       {
9516          if(ulIdx==0&&ulInfo->list.array[ulIdx]!=NULLP)
9517          {
9518             if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
9519             {
9520                if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9521                      transportLayerAddress.buf != NULLP)
9522                {
9523                   if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
9524                         !=NULLP)
9525                   {
9526                      free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf);
9527                   }
9528                   free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9529                         transportLayerAddress.buf);
9530                }
9531                free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel);
9532             }
9533          }
9534          if(ulInfo->list.array[ulIdx]!=NULLP)
9535          {
9536             free(ulInfo->list.array[ulIdx]);
9537          }
9538       }
9539       free(ulInfo->list.array);
9540    }
9541 }
9542 /*******************************************************************
9543 *
9544 * @brief free the memory allocated by decoder
9545 *
9546 * @details
9547 *
9548 *    Function : freeAperDecodeDRBSetup
9549 *
9550 *    Functionality: free DRBSetup which is allocated by decoder
9551 *
9552 * @params[in]  DRBs_ToBeSetup_List_t *drbSet
9553 * @return void
9554 *
9555 * ****************************************************************/
9556
9557 void freeAperDecodeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
9558 {
9559    DRBs_ToBeSetup_Item_t *drbSetItem = NULLP;
9560    uint8_t  flowIdx =0;
9561    uint8_t  drbIdx =0;
9562
9563    if(drbSet->list.array != NULLP)
9564    {
9565       for(drbIdx=0; drbIdx<drbSet->list.count; drbIdx++)
9566       {
9567          if(drbIdx==0&&drbSet->list.array[drbIdx] != NULLP)
9568          {
9569             drbSetItem =&drbSet->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
9570             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
9571             {
9572                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9573                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
9574                {
9575                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9576                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9577                   {
9578                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9579                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9580                      {
9581
9582                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
9583                         {
9584
9585                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
9586                            {
9587
9588                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->\
9589                                     buf!=NULLP)
9590                               {
9591
9592                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
9593                                        flows_Mapped_To_DRB_List.list.array != NULLP)
9594                                  {
9595
9596                                     for(flowIdx=0;flowIdx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9597                                           DRB_Information.flows_Mapped_To_DRB_List.list.count; flowIdx++)
9598                                     {
9599
9600                                        if(flowIdx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9601                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9602                                        {
9603                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9604                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9605                                                 qoSFlowLevelQoSParameters.\
9606                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
9607                                           {
9608                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9609                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9610                                                    qoSFlowLevelQoSParameters.\
9611                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9612                                              {
9613
9614                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9615                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9616                                                       qoSFlowLevelQoSParameters.\
9617                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9618                                                 {
9619
9620
9621                                                    free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9622                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9623                                                          qoSFlowLevelQoSParameters.\
9624                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9625                                                 }
9626
9627                                                 free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9628                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9629                                                       qoSFlowLevelQoSParameters.\
9630                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9631                                              }
9632
9633                                              free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9634
9635                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9636                                                    qoSFlowLevelQoSParameters.\
9637                                                    qoS_Characteristics.choice.non_Dynamic_5QI);
9638                                           }
9639                                        }
9640                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9641                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9642                                        {
9643
9644                                           free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9645                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]);
9646                                        }
9647                                     }
9648
9649                                     free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9650                                           DRB_Information.flows_Mapped_To_DRB_List.list.array);
9651                                  }
9652
9653                                  free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9654                                        DRB_Information.sNSSAI.sD->buf);
9655                               }
9656
9657                               free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD);
9658                            }
9659
9660                            free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf);
9661
9662                         }
9663
9664                         free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9665
9666                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9667                      }
9668
9669                      free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9670                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9671                   }
9672
9673                   free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9674                         qoS_Characteristics.choice.non_Dynamic_5QI);
9675                }
9676                free(drbSetItem->qoSInformation.choice.choice_extension);
9677             }
9678             freeAperDecodeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
9679             if(drbSetItem->uLConfiguration)
9680             {
9681                free(drbSetItem->uLConfiguration);
9682             }
9683          }
9684          if(drbSet->list.array[drbIdx]!=NULLP)
9685          {
9686             free(drbSet->list.array[drbIdx]);
9687          }
9688       }
9689       free(drbSet->list.array);
9690    }
9691 }
9692
9693
9694 /*******************************************************************
9695  *
9696  * @brief builds Mac Cell Cfg
9697  *
9698  * @details
9699  *
9700  *    Function : procUeReCfgCellInfo
9701  *
9702  *    Functionality: builds Mac Cell Cfg
9703  *
9704  * @params[in] MacUeCfg *macUeCfgToSend = Used to Store the information which
9705  *                       needs to send in other layer, as well as this can be
9706  *                       the variable which stores the information in DuCb.
9707  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
9708  *                       information to other layer else it will have copyOfmacUeCfg
9709  *                       which we have stored in F1UeContextSetupDb
9710  *             void *cellInfo = CellGroupConfigRrc_t information which is send
9711  *                        by CU, which we have stored in F1UeContextSetupDb
9712  *
9713  * @return void
9714  *
9715  * ****************************************************************/
9716 uint8_t procUeReCfgCellInfo(MacUeCfg *macUeCfgToSend,MacUeCfg *storedMacUeCfg, void *cellInfo)
9717 {
9718    uint8_t ret = ROK;
9719    CellGroupConfigRrc_t *cellGrp = NULLP;
9720
9721    if(cellInfo)
9722    {
9723       cellGrp = (CellGroupConfigRrc_t *)cellInfo;
9724       ret = extractUeReCfgCellInfo(cellGrp, macUeCfgToSend, storedMacUeCfg);
9725       if(ret == RFAILED)
9726          DU_LOG("\nERROR  -->  F1AP : Failed at procUeReCfgCellInfo()");
9727    }
9728    if(ret == RFAILED)
9729    {
9730       freeUeReCfgCellGrpInfo(macUeCfgToSend);
9731    }
9732    return ret;
9733 }
9734
9735 /*******************************************************************
9736  *
9737  * @brief Filling modulation info in mac ue cfg
9738  *
9739  * @details
9740  *
9741  *    Function : duFillModulationDetails
9742  *
9743  *    Functionality: Filling modulation info in mac ue cfg
9744  *
9745  * @params[in] MAC UE Config to be updated
9746  *             Current UE configuration
9747  *             UE NR capability from CU
9748  * @return ROK     - success
9749  *         RFAILED - failure
9750  *
9751  * ****************************************************************/
9752 void duFillModulationDetails(MacUeCfg *ueCfg, MacUeCfg *oldUeCfg, void *ueCap)
9753 {
9754    UE_NR_Capability_t *ueNrCap=NULLP;
9755
9756    if(!ueCap)
9757    {
9758       memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9759       memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9760    }
9761    else
9762    {
9763       ueNrCap = (UE_NR_Capability_t *)ueCap;
9764
9765       /* Filling DL modulation info */
9766       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsDownlinkPerCC && \
9767          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0] && \
9768          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL)
9769       {
9770          switch(*(ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL))
9771          {
9772             case ModulationOrder_qpsk:
9773                {
9774                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
9775                   break;
9776                }
9777             case ModulationOrder_qam16:
9778                {
9779                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM16;
9780                   break;
9781                }
9782             case ModulationOrder_qam64:
9783                {
9784                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM64;
9785                   ueCfg->dlModInfo.mcsIndex = PDSCH_MCS_INDEX;
9786                   ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64;
9787                   break;
9788                }
9789             case ModulationOrder_qam256:
9790                {
9791                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM256;
9792                   break;
9793                }
9794             default:
9795                {
9796                   DU_LOG("\nERROR  -->  DU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
9797                   memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9798                   break;
9799                }
9800          }
9801       }
9802       else
9803       {
9804          memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9805       }
9806
9807       /* Filling UL modulation info */
9808       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsUplinkPerCC && \
9809          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0] && \
9810          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL)
9811       {
9812          switch(*(ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL))
9813          {
9814             case ModulationOrder_qpsk:
9815                {
9816                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
9817                   break;
9818                }
9819             case ModulationOrder_qam16:
9820                {
9821                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM16;
9822                   ueCfg->ulModInfo.mcsIndex = PUSCH_MCS_INDEX;
9823                   ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64;
9824                   break;
9825                }
9826             case ModulationOrder_qam64:
9827                {
9828                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM64;
9829                   break;
9830                }
9831             case ModulationOrder_qam256:
9832                {
9833                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM256;
9834                   break;
9835                }
9836             default:
9837                {
9838                   DU_LOG("\nERROR  -->  DU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
9839                   memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9840                   break;
9841                }
9842          }
9843       }
9844       else
9845       {
9846          memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9847       }
9848    }
9849 }
9850
9851 /*******************************************************************
9852  *
9853  * @brief Function to extract cellGrp Info present in cutoDu cont
9854  *
9855  * @details
9856  *
9857  *    Function : extractCellGrpInfo
9858  *
9859  *    Functionality: Function to extract cellGrp Info present
9860  *                   in cutoDu cont
9861  *
9862  * @params[in] ProtocolExtensionContainer_4624P16_t pointer
9863  *
9864  * @return CellGroupConfigRrc_t *
9865  *
9866  * ****************************************************************/
9867
9868 CellGroupConfigRrc_t *extractCellGrpInfo(ProtocolExtensionContainer_4624P16_t *protocolIeExtn,\
9869       DuUeCfg *ueCfgDb)
9870 {
9871    uint8_t idx2 =0;
9872    uint16_t id =0;
9873    uint16_t recvBufLen =0;
9874    CellGroupConfigRrc_t *cellGrpCfg = NULLP;
9875    CUtoDURRCInformation_ExtIEs_t *extIeInfo = NULLP;
9876    asn_dec_rval_t rval; /* Decoder return value */
9877    memset(&rval, 0, sizeof(asn_dec_rval_t));
9878
9879    if(protocolIeExtn)
9880    {
9881       for(idx2 = 0; idx2 < protocolIeExtn->list.count; idx2++)
9882       {
9883          extIeInfo = ((CUtoDURRCInformation_ExtIEs_t *)(protocolIeExtn->list.array[idx2]));
9884          id = extIeInfo->id;
9885          switch(id)
9886          {
9887             case ProtocolIE_ID_id_CellGroupConfig:
9888             {
9889                recvBufLen = extIeInfo->extensionValue.choice.CellGroupConfig.size;
9890                /* decoding the CellGroup Buf received */
9891                DU_ALLOC(cellGrpCfg, sizeof(CellGroupConfigRrc_t));
9892                if(cellGrpCfg)
9893                {
9894                   memset(cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
9895                   rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfg,
9896                      extIeInfo->extensionValue.choice.CellGroupConfig.buf, recvBufLen, 0, 0);
9897                   if(rval.code == RC_FAIL || rval.code == RC_WMORE)
9898                   {
9899                      DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
9900                      return NULLP;
9901                   }
9902                   xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfg);
9903                   if(extractRlcCfgToAddMod(cellGrpCfg->rlc_BearerToAddModList, ueCfgDb))
9904                      return NULLP;
9905                }
9906                break;
9907             }
9908             default:
9909                DU_LOG("\nERROR  -->  F1AP : Invalid IE received CUtoDURRCInformation:%d at decodeCellGrpCfg()", id);
9910                break;
9911          }
9912       }
9913    }
9914    return cellGrpCfg;
9915 }
9916
9917 /*******************************************************************
9918  *
9919  * @brief Fills Srb List received by CU
9920  *
9921  * @details
9922  *
9923  *    Function : procSrbListToSetup
9924  *
9925  *    Functionality: Fills Srb List received  by CU
9926  *
9927  * @params[in] SRBs_ToBeSetup_Item_t *cuSrbItem
9928  *             LcCfg pointer
9929  *             RlcBearerCfg pointer
9930  * @return void
9931  *
9932  * ****************************************************************/
9933 uint8_t procSrbListToSetup(SRBs_ToBeSetup_Item_t * srbItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd)
9934 {
9935    uint8_t ret = ROK;
9936
9937    /* Filling RLC INFO */
9938    procRlcLcCfg(srbItem->sRBID, srbItem->sRBID, RB_TYPE_SRB, RLC_AM, CONFIG_ADD, NULL, rlcLcToAdd);
9939
9940    /* Filling MAC INFO */
9941    ret = procMacLcCfg(srbItem->sRBID, RB_TYPE_SRB, CONFIG_ADD, NULL,NULL, NULL, macLcToAdd, NULL);
9942    if(ret == RFAILED)
9943    {
9944       DU_LOG("\nERROR  -->  F1AP : Failed at MAC LC Cfg in procSrbListToSetup()");
9945       return ret;
9946    }
9947    return ret;
9948 }
9949
9950
9951
9952 /*******************************************************************
9953  *
9954  * @brief extract Srb List received by CU
9955  *
9956  * @details
9957  *
9958  *    Function : extractSrbListToSetup
9959  *
9960  *    Functionality: extract Srb List received by CU
9961  *                   for both MAC and RLC
9962  *
9963  * @params[in] SRBs_ToBeSetup_Item_t pointer
9964  *             DuUeCfg pointer
9965  * @return ROK/RFAIED
9966  *
9967  * ****************************************************************/
9968
9969 uint8_t extractSrbListToSetup(SRBs_ToBeSetup_List_t *srbCfg, DuUeCfg *ueCfgDb)
9970 {
9971    uint8_t ret, srbIdx;
9972    SRBs_ToBeSetup_Item_t *srbItem = NULLP;
9973
9974    if(srbCfg)
9975    {
9976       for(srbIdx = 0; srbIdx < srbCfg->list.count; srbIdx++)
9977       {
9978          srbItem = &srbCfg->list.array[srbIdx]->value.choice.SRBs_ToBeSetup_Item;
9979          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
9980          {
9981             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in MAC");
9982             ret = RFAILED;
9983             break;
9984          }
9985          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
9986          {
9987             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in RLC");
9988             ret = RFAILED;
9989             break;
9990          }
9991          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
9992          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
9993          ret = procSrbListToSetup(srbItem, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
9994             &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs]);
9995          ueCfgDb->numRlcLcs++;
9996          ueCfgDb->numMacLcs++;
9997          DU_LOG("\nDEBUG --> DUAPP: extractSrbListToSetup: SRBID: %d [RLC,MAC,NumDrb]:[%x,%x,%x]",\
9998                             srbItem->sRBID, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
9999          if(ret == RFAILED)
10000          {
10001             DU_LOG("\nERROR  -->  F1AP:  Failed at extractSrbListToSetup()");
10002             break;
10003          }
10004       }
10005    }
10006    else
10007       ret = RFAILED;
10008
10009    return ret;
10010 }
10011
10012 /*******************************************************************
10013  *
10014  * @brief Fills Drb List received by CU
10015  *
10016  * @details
10017  *
10018  *    Function : procDrbListToSetup
10019  *
10020  *    Functionality: Fills Drb List received by CU
10021  *                   for both MAC and RLC
10022  *
10023  * @params[in] SRBs_ToBeSetup_Item_t pointer
10024  *             LcCfg pointer,
10025  *             RlcBearerCfg pointer
10026  * @return void
10027  *
10028  * ****************************************************************/
10029
10030 uint8_t procDrbListToSetup(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbItem,\
10031 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd, UpTnlCfg *upTnlInfo)
10032 {
10033
10034    if(drbItem != NULLP)
10035    {
10036       /* Filling RLC INFO */
10037       procRlcLcCfg(drbItem->dRBID, lcId, RB_TYPE_DRB, drbItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd);
10038
10039       /* Filling MAC INFO */
10040       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, drbItem, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
10041       {
10042          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetup()");
10043          return RFAILED;
10044       }
10045    }
10046    else if(drbSetupModItem != NULLP)
10047    {
10048       procRlcLcCfg(drbSetupModItem->dRBID, lcId, RB_TYPE_DRB, drbSetupModItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd);
10049
10050       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, NULL, drbSetupModItem, NULL, macLcToAdd, upTnlInfo) != ROK)
10051       {
10052          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetup()");
10053          return RFAILED;
10054       }
10055    }
10056    return ROK;
10057 }
10058
10059 /*******************************************************************
10060  *
10061  * @brief extract Drb List received by CU
10062  *
10063  * @details
10064  *
10065  *    Function : extractDrbListToSetup
10066  *
10067  *    Functionality: extract Drb List received by CU
10068  *                   for both MAC and RLC
10069  *
10070  * @params[in] DRBs_ToBeSetup_Item_t pointer
10071  *             DuUeCfg pointer
10072  * @return ROK/RFAIED
10073  *
10074  * ****************************************************************/
10075
10076 uint8_t extractDrbListToSetup(DRBs_ToBeSetup_List_t *drbCfg,DRBs_ToBeSetupMod_List_t *drbSetupModCfg,\
10077 uint8_t drbCount, DuUeCfg *ueCfgDb, uint32_t *drbBitMap)
10078 {
10079    uint8_t ret, drbIdx, lcId = 0;
10080    DRBs_ToBeSetup_Item_t *drbItem = NULLP;
10081    DRBs_ToBeSetupMod_ItemIEs_t *drbSetupModItem = NULLP;
10082
10083    ret = ROK;
10084    if(drbCount > 0)
10085    {
10086       for(drbIdx = 0; drbIdx < drbCount; drbIdx++)
10087       {
10088          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
10089          {
10090             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in MAC at extractDrbListToSetup()");
10091             ret = RFAILED;
10092             break;
10093          }
10094          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
10095          {
10096             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in RLC at extractDrbListToSetup()");
10097             ret = RFAILED;
10098             break;
10099          }
10100          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
10101          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
10102
10103          lcId = getDrbLcId(drbBitMap);
10104          if(lcId == RFAILED)
10105          {
10106             DU_LOG("\nERROR  -->  F1AP :  InCorrect LCID extractDrbListToSetup()");
10107             ret = RFAILED;
10108             break;
10109          }
10110          if(drbCfg != NULL)
10111          {
10112             drbItem = &drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
10113             ret = procDrbListToSetup(lcId, drbItem, NULL, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
10114                &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], &ueCfgDb->upTnlInfo[ueCfgDb->numDrb]);
10115             if(ret == RFAILED)
10116             {
10117                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetup()");
10118                break;
10119             }
10120          }
10121          else if(drbSetupModCfg != NULL)
10122          {
10123             drbSetupModItem = (DRBs_ToBeSetupMod_ItemIEs_t *) drbSetupModCfg->list.array[drbIdx];
10124             ret = procDrbListToSetup(lcId, NULL, &(drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item) ,\
10125             &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs],\
10126             &ueCfgDb->upTnlInfo[ueCfgDb->numDrb]);
10127             if(ret == RFAILED)
10128             {
10129                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetup()");
10130                break;
10131             }
10132          }
10133          ueCfgDb->numRlcLcs++;
10134          ueCfgDb->numMacLcs++;
10135          ueCfgDb->numDrb++;
10136
10137          DU_LOG("\nDEBUG --> DUAPP: extractDrbListToSetup:lcId:%x ,BitMap:%x, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
10138                             lcId,*drbBitMap, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
10139          if(ret == RFAILED)
10140          {
10141             DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetup()");
10142             break;
10143          }
10144       }
10145    }
10146    else
10147       ret = RFAILED;
10148
10149    return ret;
10150 }
10151
10152 /*******************************************************************
10153  *
10154  * @brief Function to extract Dl RRC Msg received from CU
10155  *
10156  * @details
10157  *
10158  *    Function : extractDlRrcMsg
10159  *
10160  *    Functionality: Function to extract Dl RRC Msg received from CU
10161  *
10162  * @params[in] F1AP message
10163  * @return ROK     - success
10164  *         RFAILED - failure
10165  *
10166  * ****************************************************************/
10167
10168 uint8_t extractDlRrcMsg(uint32_t gnbDuUeF1apId, uint32_t gnbCuUeF1apId, \
10169    F1DlRrcMsg *dlRrcMsg, RRCContainer_t *rrcContainer)
10170 {
10171    uint8_t ret = ROK;
10172    dlRrcMsg->rrcMsgSize = rrcContainer->size;
10173    if(dlRrcMsg->rrcMsgSize > 0)
10174    {
10175       DU_ALLOC_SHRABL_BUF(dlRrcMsg->rrcMsgPdu, dlRrcMsg->rrcMsgSize);
10176       if(!dlRrcMsg->rrcMsgPdu)
10177       {
10178          DU_LOG("\nERROR  --> DU APP : Memory allocation failed for RRC Msg in extractDlRrcMsg()");
10179          ret = RFAILED;
10180       }
10181       else
10182       {
10183          dlRrcMsg->gnbDuUeF1apId = gnbDuUeF1apId;
10184          dlRrcMsg->gnbCuUeF1apId = gnbCuUeF1apId;
10185          dlRrcMsg->srbId = SRB1_LCID;
10186          memcpy(dlRrcMsg->rrcMsgPdu, rrcContainer->buf, dlRrcMsg->rrcMsgSize);
10187       }
10188    }
10189    return ret;
10190 }
10191
10192 /*******************************************************************
10193  *
10194  * @brief Extract UE capability info
10195  *
10196  * @details
10197  *
10198  *    Function : extractUeCapability
10199  *
10200  *    Functionality: Extract UE capability info and stores in ue Cb
10201  *
10202  * @params[in] Octet string of UE capability RAT container list
10203  * @return ROK     - success
10204  *         RFAILED - failure
10205  *
10206  * ****************************************************************/
10207 UE_NR_Capability_t *extractUeCapability(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf, DuUeCb *ueCb)
10208 {
10209    uint8_t  idx;
10210    uint16_t recvBufLen;
10211    asn_dec_rval_t rval;
10212    UE_NR_Capability_t  *ueNrCap = NULLP;
10213    UE_CapabilityRAT_ContainerListRRC_t  *ueCapRatContList = NULLP;
10214
10215    /* Decoding UE Capability RAT Container List */
10216    recvBufLen = ueCapablityListBuf->size;
10217    DU_ALLOC(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10218    if(!ueCapRatContList)
10219    {
10220       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
10221       return NULLP;
10222    }
10223    memset(ueCapRatContList, 0, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10224    memset(&rval, 0, sizeof(asn_dec_rval_t));
10225    rval = aper_decode(0, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, (void **)&ueCapRatContList,
10226           ueCapablityListBuf->buf, recvBufLen, 0, 0);
10227    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10228    {
10229       DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
10230       return NULLP;
10231    }
10232    xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, ueCapRatContList);
10233
10234    /* Free encoded buffer after decoding */
10235
10236    for(idx = 0; idx < ueCapRatContList->list.count; idx++)
10237    {
10238       if(ueCapRatContList->list.array[idx]->rat_Type == RAT_Type_nr)
10239       {
10240          /* Decoding UE NR Capability */
10241           recvBufLen = ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.size;
10242           DU_ALLOC(ueNrCap, sizeof(UE_NR_Capability_t));
10243           if(!ueNrCap)
10244           {
10245              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
10246              DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10247              return NULLP;
10248           }
10249           memset(ueNrCap, 0, sizeof(UE_NR_Capability_t));
10250           memset(&rval, 0, sizeof(asn_dec_rval_t));
10251           rval = aper_decode(0, &asn_DEF_UE_NR_Capability, (void **)&ueNrCap,
10252                  ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf, recvBufLen, 0, 0);
10253           if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10254           {
10255              DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
10256              return NULLP;
10257           }
10258           xer_fprint(stdout, &asn_DEF_UE_NR_Capability, ueNrCap);
10259
10260           /* Free encoded buffer after decoding */
10261           free(ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf);
10262       }
10263       free(ueCapRatContList->list.array[idx]);
10264    }
10265
10266    /* Free Memory*/
10267    free(ueCapRatContList->list.array);
10268    DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10269    return ueNrCap;
10270 }
10271
10272 /*******************************************************************
10273 *
10274 * @brief free UE context setup request from CU
10275 *
10276 * @details
10277 *
10278 *    Function : freeAperDecodeF1UeContextSetupReq
10279 *
10280 *    Functionality: freeing part for the memory allocated by aper_decoder
10281 *
10282 * @params[in] F1AP message
10283 * @return ROK     - success
10284 *         RFAILED - failure
10285 *
10286 * ****************************************************************/
10287 void freeAperDecodeF1UeContextSetupReq(UEContextSetupRequest_t   *ueSetReq)
10288 {
10289    uint8_t ieIdx = 0;
10290
10291    if(ueSetReq->protocolIEs.list.array != NULLP)
10292    {
10293       for(ieIdx = 0; ieIdx < ueSetReq->protocolIEs.list.count; ieIdx++)
10294       {
10295          if(ueSetReq->protocolIEs.list.array[ieIdx])
10296          {
10297             switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
10298             {
10299                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10300                   break;
10301                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10302                   break;
10303                case ProtocolIE_ID_id_SpCell_ID:
10304                   freeAperDecodeNrcgi(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
10305                   break;
10306                case ProtocolIE_ID_id_ServCellIndex:
10307                   break;
10308                case ProtocolIE_ID_id_SpCellULConfigured:
10309                   break;
10310                case ProtocolIE_ID_id_CUtoDURRCInformation:
10311
10312                   freeAperDecodeCuToDuInfo(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation);
10313                   break;
10314                case ProtocolIE_ID_id_SCell_ToBeSetup_List:
10315
10316                   freeAperDecodeSplCellList(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SCell_ToBeSetup_List);
10317                   break;
10318                case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
10319
10320                   freeAperDecodeSRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List);
10321                   break;
10322                case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
10323
10324                   freeAperDecodeDRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List);
10325                   break;
10326                case ProtocolIE_ID_id_RRCContainer:
10327                   {
10328
10329                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf != NULLP)
10330                      {
10331
10332                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
10333                      }
10334                      break;
10335                   }
10336                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10337                   break;
10338                case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
10339                   {
10340                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf)
10341                      {
10342                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf);
10343                      }
10344                      break;
10345                   }
10346                default:
10347                   DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld " ,ueSetReq->protocolIEs.list.array[ieIdx]->id);
10348             }
10349             free(ueSetReq->protocolIEs.list.array[ieIdx]);
10350          }
10351       }
10352       free(ueSetReq->protocolIEs.list.array);
10353    }
10354 }
10355 /*******************************************************************
10356  *
10357  * @brief Process UE context setup request from CU
10358  *
10359  * @details
10360  *
10361  *    Function : procF1UeContextSetupReq
10362  *
10363  *    Functionality: Process UE context setup request from CU
10364  *
10365  * @params[in] F1AP message
10366  * @return ROK     - success
10367  *         RFAILED - failure
10368  *
10369  * ****************************************************************/
10370 uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
10371 {
10372    uint8_t  ret=0, ieIdx=0, ueIdx=0, cellIdx=0;
10373    bool ueCbFound = false;
10374    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0, bitRateSize=0;
10375    DuUeCb   *duUeCb = NULL;
10376    UEContextSetupRequest_t   *ueSetReq = NULL;
10377    DRBs_ToBeSetup_List_t *drbCfg = NULL;
10378
10379    ret = ROK;
10380
10381    ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
10382    for(ieIdx=0; (ieIdx < ueSetReq->protocolIEs.list.count && ret == ROK); ieIdx++)
10383    {
10384       switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
10385       {
10386          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10387             {
10388                gnbCuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
10389                break;
10390             }
10391          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10392             {
10393                gnbDuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
10394                break;
10395             }
10396          case ProtocolIE_ID_id_ServCellIndex:
10397             {
10398                cellIdx = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.ServCellIndex;
10399                for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
10400                {
10401                   if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
10402                         (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
10403                   {
10404                      ueCbFound = true;
10405                      duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
10406                      DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
10407                      if(duUeCb->f1UeDb)
10408                      {
10409                         memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
10410                         duUeCb->f1UeDb->actionType = UE_CTXT_SETUP;
10411                         duUeCb->f1UeDb->cellIdx = cellIdx;
10412                      }
10413                      else
10414                      {
10415                         DU_LOG("\nERROR  -->  F1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
10416                         ret = RFAILED;
10417                      }
10418                      break;
10419                   }
10420                   else
10421                      ueCbFound = false;
10422
10423                }
10424                if(!ueCbFound)
10425                {
10426                   DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
10427                   ret = RFAILED;
10428                }
10429                break;
10430             }
10431          case ProtocolIE_ID_id_SpCellULConfigured:
10432             /* Indicates whether the gNB-CU requests the gNB-DU to configure the uplink as no UL,
10433                UL, SUL or UL+SUL for the indicated cell for the UE */
10434             break;
10435          case ProtocolIE_ID_id_CUtoDURRCInformation:
10436             {
10437                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.uE_CapabilityRAT_ContainerList)
10438                {
10439                   duUeCb->f1UeDb->duUeCfg.ueNrCapability = \
10440                   extractUeCapability(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.\
10441                   uE_CapabilityRAT_ContainerList, duUeCb);
10442                }
10443                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.iE_Extensions)
10444                {
10445                   duUeCb->f1UeDb->duUeCfg.cellGrpCfg = extractCellGrpInfo(ueSetReq->protocolIEs.list.array[ieIdx]->\
10446                         value.choice.CUtoDURRCInformation.iE_Extensions, &duUeCb->f1UeDb->duUeCfg);
10447                   if(!duUeCb->f1UeDb->duUeCfg.cellGrpCfg)
10448                   {
10449                      DU_LOG("\nERROR  -->  F1AP: Failed to extract cell Grp Info");
10450                      //TODO: Update the failure cause in ue context Setup Response
10451                      ret = RFAILED;
10452                   }
10453                }
10454                break;
10455             }
10456          case ProtocolIE_ID_id_SCell_ToBeSetup_List:
10457             {
10458                DU_LOG("\nINFO   -->  DU_APP: Received SCell_ToBeSetup_List but  Not processing the list");
10459                break;
10460             }
10461          case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
10462             {
10463                if(extractSrbListToSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List,\
10464                &duUeCb->f1UeDb->duUeCfg))
10465                {
10466                   DU_LOG("\nERROR  -->  DU APP : Failed at extractSrbListToSetup()");
10467                   //TODO: Update the failure cause in ue context Setup Response
10468                   ret = RFAILED;
10469                }
10470                break;
10471             }
10472          case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
10473             {
10474                   drbCfg = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List;
10475
10476                   if(extractDrbListToSetup(drbCfg, NULL, drbCfg->list.count, &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap))
10477                   {
10478                      DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetup()");
10479                      //TODO: Update the failure cause in ue context Setup Response
10480                      ret = RFAILED;
10481                   }
10482                break;
10483             }
10484          case ProtocolIE_ID_id_RRCContainer:
10485             {
10486                /* Filling Dl RRC Msg Info */
10487                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
10488                if(!duUeCb->f1UeDb->dlRrcMsg)
10489                {
10490                   DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
10491                   ret = RFAILED;
10492                }
10493                else
10494                {
10495                   duUeCb->f1UeDb->dlRrcMsgPres = true;
10496                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
10497                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
10498                         &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer);
10499                }
10500                break;
10501             }
10502          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10503             {
10504                if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
10505                {
10506                   duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
10507                }
10508                else
10509                {
10510                   DU_LOG("\nERROR  -->  Ignoring delivery report, since rrcContainer is not present");
10511                }
10512                break;
10513             }
10514          case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
10515             {
10516                /* MaximumBitRate Uplink */
10517                bitRateSize = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.size;
10518                if(bitRateSize > 0)
10519                {
10520                   DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.ambrCfg, bitRateSize);
10521                   if(!duUeCb->f1UeDb->duUeCfg.ambrCfg)
10522                   {
10523                      DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
10524                      ret = RFAILED;
10525                   }
10526                   else
10527                   {
10528                      memset(duUeCb->f1UeDb->duUeCfg.ambrCfg, 0, sizeof(AmbrCfg));
10529                      memcpy(&duUeCb->f1UeDb->duUeCfg.ambrCfg->ulBr,
10530                            ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf, bitRateSize);
10531                   }
10532                }
10533                else
10534                   ret = RFAILED;
10535                break;
10536             }
10537          default:
10538             {
10539                break;
10540             }
10541       }
10542    }
10543    if(ret == RFAILED)
10544    {
10545       /*TODO : Negative case*/
10546       // BuildAndSendUeContextSetupRsp(cellId,ueIdx);
10547       DU_LOG("\nERROR  -->  F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
10548    }
10549    else
10550       ret = duProcUeContextSetupRequest(duUeCb);
10551
10552    freeAperDecodeF1UeContextSetupReq(ueSetReq);
10553    return ret;
10554
10555 }
10556 /*******************************************************************
10557  * @brief Free the memory allocated for Dl Tunnel Info
10558  *
10559  * @details
10560  *
10561  *    Function : freeDlTnlInfo
10562  *
10563  *    Functionality:
10564  *       Free the memory allocated for Dl Tunnel Info
10565  *
10566  * @params[in] DLUPTNLInformation_ToBeSetup_List_t *
10567  * @return void
10568  *
10569  * ****************************************************************/
10570
10571 void freeDlTnlInfo(DLUPTNLInformation_ToBeSetup_List_t *tnlInfo)
10572 {
10573    uint8_t arrIdx = 0;
10574
10575    if(tnlInfo)
10576    {
10577       for(arrIdx=0; arrIdx < tnlInfo->list.count; arrIdx++)
10578       {
10579          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf,\
10580                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
10581          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf,\
10582                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
10583          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
10584          DU_FREE(tnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
10585       }
10586       DU_FREE(tnlInfo->list.array, tnlInfo->list.size);
10587    }
10588 }
10589
10590 /*******************************************************************
10591  * @brief Free the memory allocated for DRB setup List
10592  *
10593  * @details
10594  *
10595  *    Function : freeDrbSetupList
10596  *
10597  *    Functionality:
10598  *       Free the memory allocated for DRB setup list
10599  *
10600  * @params[in] DRBs_Setup_List_t *
10601  * @return void
10602  *
10603  * ****************************************************************/
10604 void freeDrbSetupList(DRBs_Setup_List_t *drbSetupList)
10605 {
10606    uint8_t arrIdx = 0;
10607    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
10608
10609    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
10610    {
10611       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
10612       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
10613       DU_FREE(drbSetupList->list.array[arrIdx],  sizeof(DRBs_Setup_Item_t));
10614    }
10615    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
10616 }
10617
10618 /*******************************************************************
10619  * @brief Free the memory allocated for UE Setup response
10620  *
10621  * @details
10622  *
10623  *    Function : FreeUeContextSetupRsp
10624  *
10625  *    Functionality:
10626  *       Free the memory allocated for UE Setup response
10627  *
10628  * @params[in] F1AP PDU for UE setup response
10629  * @return ROK     - success
10630  *         RFAILED - failure
10631  *
10632  * ****************************************************************/
10633 void FreeUeContextSetupRsp(F1AP_PDU_t *f1apMsg)
10634 {
10635    uint8_t idx;
10636    UEContextSetupResponse_t *ueSetRsp = NULLP;
10637
10638    if(f1apMsg)
10639    {
10640       if(f1apMsg->choice.successfulOutcome)
10641       {
10642          ueSetRsp = &f1apMsg->choice.successfulOutcome->value.choice.\
10643                     UEContextSetupResponse;
10644          if(ueSetRsp->protocolIEs.list.array)
10645          {
10646             for(idx = 0; idx < ueSetRsp->protocolIEs.list.count; idx++)
10647             {
10648                if(ueSetRsp->protocolIEs.list.array[idx])
10649                {
10650                   switch(ueSetRsp->protocolIEs.list.array[idx]->id)
10651                   {
10652                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10653                         break;
10654                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10655                         break;
10656                      case ProtocolIE_ID_id_DUtoCURRCInformation:
10657                         {
10658                            CellGroupConfig_t *cellGrpCfg = NULLP;
10659                            cellGrpCfg  = &ueSetRsp->protocolIEs.list.array[idx]->value.choice.\
10660                                          DUtoCURRCInformation.cellGroupConfig;
10661                            if(cellGrpCfg->buf != NULLP)
10662                            {
10663                               DU_FREE(cellGrpCfg->buf, cellGrpCfg->size);
10664                               cellGrpCfg = NULLP;
10665                            }
10666                            break;
10667                         }
10668                     case ProtocolIE_ID_id_DRBs_Setup_List:
10669                         {
10670                            freeDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
10671                            break;
10672                         }
10673                      default:
10674                         DU_LOG("\nERROR  -->  DUAPP: Invalid Id %ld at FreeUeContextSetupRsp()",\
10675                         ueSetRsp->protocolIEs.list.array[idx]->id);
10676                         break;
10677                   }
10678                   DU_FREE(ueSetRsp->protocolIEs.list.array[idx],\
10679                         sizeof(UEContextSetupResponseIEs_t));
10680                }
10681             }
10682             DU_FREE(ueSetRsp->protocolIEs.list.array, \
10683                   ueSetRsp->protocolIEs.list.size);
10684          }
10685          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
10686       }
10687       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10688    }
10689 }
10690
10691 /*******************************************************************
10692  *
10693  * @brief Builds Ue context Setup Rsp DU To CU Info
10694  *
10695  * @details
10696  *
10697  *    Function : EncodeUeCntxtDuToCuInfo
10698  *
10699  *    Functionality: Builds Ue context Setup Rsp DU To CU Info
10700  *
10701  * @params[in] CellGroupConfig_t *, CellGroupConfigRrc_t *
10702  *
10703  * @return ROK     - success
10704  *         RFAILED - failure
10705  *
10706  ******************************************************************/
10707
10708 uint8_t EncodeUeCntxtDuToCuInfo(CellGroupConfig_t *duToCuCellGrp, CellGroupConfigRrc_t *duCellGrpCfg)
10709 {
10710    asn_enc_rval_t        encRetVal;
10711
10712    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, duCellGrpCfg);
10713    memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
10714    encBufSize = 0;
10715    encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, duCellGrpCfg, PrepFinalEncBuf, encBuf);
10716    /* Encode results */
10717    if(encRetVal.encoded == ENCODE_FAIL)
10718    {
10719       DU_LOG( "\nERROR  -->  F1AP : Could not encode UeCntxtDuToCuInfo (at %s)\n",\
10720             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10721       return RFAILED;
10722    }
10723    else
10724    {
10725       DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
10726       for(int i=0; i< encBufSize; i++)
10727       {
10728          printf("%x",encBuf[i]);
10729       }
10730    }
10731    duToCuCellGrp->size = encBufSize;
10732    DU_ALLOC(duToCuCellGrp->buf, duToCuCellGrp->size);
10733    if(!duToCuCellGrp->buf)
10734    {
10735       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in UeCntxtDuToCuInfo");
10736    }
10737    memcpy(duToCuCellGrp->buf, encBuf, duToCuCellGrp->size);
10738    return ROK;
10739 }
10740
10741 /*******************************************************************
10742  *
10743  * @brief Fills Dl Gtp tunnel Info
10744  *
10745  * @details
10746  *
10747  *    Function : fillGtpTunnelforDl
10748  *
10749  *    Functionality: Fills Dl Gtp tunnel Info
10750  *
10751  * @params[in]
10752  *
10753  * @return ROK     - success
10754  *         RFAILED - failure
10755  *
10756  * ****************************************************************/
10757
10758 uint8_t fillGtpTunnelforDl(GTPTunnel_t *gtpDl, GtpTnlCfg *gtpUeCfg)
10759 {
10760    uint8_t bufSize = 0;
10761
10762    gtpDl->transportLayerAddress.size    = 4*sizeof(uint8_t);
10763    DU_ALLOC(gtpDl->transportLayerAddress.buf, gtpDl->transportLayerAddress.size);
10764    if(gtpDl->transportLayerAddress.buf == NULLP)
10765    {
10766       return RFAILED;
10767    }
10768    memcpy(gtpDl->transportLayerAddress.buf, &gtpUeCfg->dlTnlAddress, gtpDl->transportLayerAddress.size);
10769
10770    /*GTP TEID*/
10771    gtpDl->gTP_TEID.size = 4 * sizeof(uint8_t);
10772    DU_ALLOC(gtpDl->gTP_TEID.buf, gtpDl->gTP_TEID.size);
10773    if(gtpDl->gTP_TEID.buf == NULLP)
10774    {
10775       return RFAILED;
10776    }
10777    bufSize = 3; /*forming an Octect String*/
10778    fillTeIdString(bufSize, gtpUeCfg->teId, gtpDl->gTP_TEID.buf);
10779
10780    return ROK;
10781 }
10782
10783 /*******************************************************************
10784  *
10785  * @brief Fills DL Tunnel Setup List
10786  *
10787  * @details
10788  *
10789  *    Function : fillDlTnlSetupList
10790  *
10791  *    Functionality: Fills the DL Tunnel Setup List
10792  *
10793  * @params[in]
10794  *
10795  * @return ROK     - success
10796  *         RFAILED - failure
10797  *
10798  * ****************************************************************/
10799
10800 uint8_t fillDlTnlSetupList(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo, UpTnlCfg *tnlCfg)
10801 {
10802    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
10803
10804    eleCount = 1;
10805    dlTnlInfo->list.count = eleCount;
10806    dlTnlInfo->list.size = (eleCount * sizeof(DLUPTNLInformation_ToBeSetup_Item_t *));
10807
10808    /* Initialize the DL Tnl Setup List Members */
10809    DU_ALLOC(dlTnlInfo->list.array, dlTnlInfo->list.size);
10810    if(dlTnlInfo->list.array == NULLP)
10811    {
10812       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL Tnl Setup List in fillDlTnlSetupList()");
10813       ret = RFAILED;
10814    }
10815    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
10816    {
10817       DU_ALLOC(dlTnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
10818       if(dlTnlInfo->list.array[arrIdx] == NULLP)
10819       {
10820          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDlTnlSetupList()", arrIdx);
10821          return RFAILED;
10822       }
10823       dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
10824       DU_ALLOC(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
10825       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel == NULLP)
10826       {
10827          DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL tunnel info in fillDlTnlSetupList()");
10828          return RFAILED;
10829       }
10830       ret = fillGtpTunnelforDl(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel,\
10831                tnlCfg->tnlCfg1);
10832       if(ret != ROK)
10833          break;
10834    }
10835    return ret;
10836 }
10837
10838 /*******************************************************************
10839  *
10840  * @brief Fills the Drb Setup List for Ue Context Setup Response
10841  *
10842  * @details
10843  *
10844  *    Function : fillDrbSetupList
10845  *
10846  *    Functionality: Fills the Drb Setup List for Ue Context Setup Response
10847  *
10848  * @params[in]
10849  *
10850  * @return ROK     - success
10851  *         RFAILED - failure
10852  *
10853  * ****************************************************************/
10854 uint8_t fillDrbSetupList(DRBs_Setup_List_t *drbSetupList, DuUeCfg *ueCfg)
10855 {
10856    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
10857    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
10858
10859    eleCount = ueCfg->numDrb;
10860    drbSetupList->list.count = eleCount;
10861    drbSetupList->list.size = \
10862         (eleCount * sizeof(DRBs_Setup_Item_t *));
10863
10864    /* Initialize the Drb Setup List Members */
10865    DU_ALLOC(drbSetupList->list.array, drbSetupList->list.size);
10866    if(drbSetupList->list.array == NULLP)
10867    {
10868       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DRB Setup List in fillDrbSetupList()");
10869       ret = RFAILED;
10870    }
10871
10872    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
10873    {
10874       DU_ALLOC(drbSetupList->list.array[arrIdx], sizeof(DRBs_Setup_Item_t));
10875       if(drbSetupList->list.array[arrIdx] == NULLP)
10876       {
10877          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDrbSetupList()", arrIdx);
10878          return RFAILED;
10879       }
10880       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
10881       drbItemIe->id = ProtocolIE_ID_id_DRBs_Setup_Item;
10882       drbItemIe->criticality = Criticality_reject;
10883       drbItemIe->value.present = DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item;
10884       drbItemIe->value.choice.DRBs_Setup_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
10885       ret = fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List,\
10886           &ueCfg->upTnlInfo[arrIdx]);
10887       if(ret != ROK)
10888          break;
10889    }
10890    return ret;
10891 }
10892
10893 /*******************************************************************
10894  *
10895  * @brief Builds and sends the UE Setup Response
10896  *
10897  * @details
10898  *
10899  *    Function : BuildAndSendUeContextSetupRsp
10900  *
10901  *    Functionality: Constructs the UE Setup Response and sends
10902  *                   it to the DU through SCTP.
10903  *
10904  * @params[in] uint8_t cellId,uint8_t ueIdx
10905  *
10906  * @return ROK     - success
10907  *         RFAILED - failure
10908  *
10909  * ****************************************************************/
10910 uint8_t BuildAndSendUeContextSetupRsp(uint8_t cellId,uint8_t ueIdx)
10911 {
10912    uint8_t   idx, ret, cellIdx, elementCnt;
10913    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
10914    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
10915    asn_enc_rval_t  encRetVal;        /* Encoder return value */
10916    F1AP_PDU_t               *f1apMsg = NULLP;
10917    UEContextSetupResponse_t *ueSetRsp = NULLP;
10918    CellGroupConfigRrc_t     *cellGrpCfg = NULLP;
10919    DuUeCb                   *ueCb = NULLP;
10920
10921    DU_LOG("\n INFO   -->  F1AP : Building UE Context Setup Response for cellId %d, ueIdx %d\n", cellId, ueIdx);
10922
10923    while(true)
10924    {
10925       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10926       if(f1apMsg == NULLP)
10927       {
10928          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
10929          ret = RFAILED;
10930          break;
10931       }
10932
10933       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
10934       DU_ALLOC(f1apMsg->choice.successfulOutcome,
10935             sizeof(SuccessfulOutcome_t));
10936       if(f1apMsg->choice.successfulOutcome == NULLP)
10937       {
10938          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
10939          ret = RFAILED;
10940          break;
10941       }
10942
10943       f1apMsg->choice.successfulOutcome->procedureCode = \
10944                                                          ProcedureCode_id_UEContextSetup;
10945       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
10946       f1apMsg->choice.successfulOutcome->value.present = \
10947                                                          SuccessfulOutcome__value_PR_UEContextSetupResponse;
10948
10949       ueSetRsp =
10950          &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
10951       elementCnt = 4;
10952       ueSetRsp->protocolIEs.list.count = elementCnt;
10953       ueSetRsp->protocolIEs.list.size = \
10954                                         elementCnt * sizeof(UEContextSetupResponse_t *);
10955
10956       /* Initialize the UESetup members */
10957       DU_ALLOC(ueSetRsp->protocolIEs.list.array, \
10958             ueSetRsp->protocolIEs.list.size);
10959       if(ueSetRsp->protocolIEs.list.array == NULLP)
10960       {
10961          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
10962          ret = RFAILED;
10963          break;
10964       }
10965
10966       for(idx=0; idx<elementCnt; idx++)
10967       {
10968          DU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
10969                sizeof(UEContextSetupResponseIEs_t));
10970          if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
10971          {
10972             DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
10973             ret = RFAILED;
10974             break;
10975          }
10976       }
10977       /* Fetching Ue Cb Info*/
10978       GET_CELL_IDX(cellId, cellIdx);
10979       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
10980       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
10981       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
10982
10983       idx = 0;
10984       /*GNB CU UE F1AP ID*/
10985       ueSetRsp->protocolIEs.list.array[idx]->id = \
10986                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
10987       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10988       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
10989                                                              UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
10990       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
10991
10992       /*GNB DU UE F1AP ID*/
10993       idx++;
10994       ueSetRsp->protocolIEs.list.array[idx]->id = \
10995                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
10996       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10997       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
10998                                                              UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
10999       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
11000
11001
11002       /*DUtoCURRC Information */
11003       idx++;
11004       ueSetRsp->protocolIEs.list.array[idx]->id  = \
11005                                                    ProtocolIE_ID_id_DUtoCURRCInformation;
11006       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11007       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
11008                                                             UEContextSetupResponseIEs__value_PR_DUtoCURRCInformation;
11009       if(ueCb->f1UeDb)
11010       {
11011          if(ueCb->f1UeDb->duUeCfg.cellGrpCfg)
11012          {
11013             cellGrpCfg = (CellGroupConfigRrc_t*)ueCb->f1UeDb->duUeCfg.cellGrpCfg;
11014             ret = EncodeUeCntxtDuToCuInfo(&ueSetRsp->protocolIEs.list.array[idx]->value.\
11015                      choice.DUtoCURRCInformation.cellGroupConfig, cellGrpCfg);
11016             if(ret == RFAILED)
11017             {
11018                DU_LOG("\nERROR  -->  F1AP : Failed to EncodeUeCntxtDuToCuInfo in BuildAndSendUeContextSetupRsp()");
11019                freeF1UeDb(ueCb->f1UeDb);
11020                ueCb->f1UeDb = NULLP;
11021                break;
11022             }
11023          }
11024       }
11025       else
11026       {
11027          DU_LOG("\nERROR  -->  F1AP : Failed to form DUtoCU RRCInfo at BuildAndSendUeContextSetupRsp()");
11028          ret = RFAILED;
11029          break;
11030       }
11031
11032       /* Drb Setup List */
11033       idx++;
11034       ueSetRsp->protocolIEs.list.array[idx]->id  = \
11035                                  ProtocolIE_ID_id_DRBs_Setup_List;
11036       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11037       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
11038                                  UEContextSetupResponseIEs__value_PR_DRBs_Setup_List;
11039       ret = fillDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List,\
11040                &ueCb->f1UeDb->duUeCfg);
11041       if(ret == RFAILED)
11042       {
11043          DU_LOG("\nERROR  -->  F1AP : Failed to fillDrbSetupList in BuildAndSendUeContextSetupRsp()");
11044          freeF1UeDb(ueCb->f1UeDb);
11045          ueCb->f1UeDb = NULLP;
11046          break;
11047       }
11048
11049        /* Free UeContext Db created during Ue context Req */
11050        freeF1UeDb(ueCb->f1UeDb);
11051        ueCb->f1UeDb = NULLP;
11052
11053       /* TODO: To send Drb list */
11054       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11055
11056       /* Encode the UE context setup response type as APER */
11057       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
11058       encBufSize = 0;
11059       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11060             encBuf);
11061       /* Encode results */
11062       if(encRetVal.encoded == ENCODE_FAIL)
11063       {
11064          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Response structure (at %s)\n",\
11065                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11066          ret = RFAILED;
11067          break;
11068       }
11069       else
11070       {
11071          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Setup Response\n");
11072          for(int i=0; i< encBufSize; i++)
11073          {
11074             printf("%x",encBuf[i]);
11075          }
11076       }
11077
11078       /* Sending  msg  */
11079       if(sendF1APMsg()  != ROK)
11080       {
11081          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Response failed");
11082          ret = RFAILED;
11083          break;
11084       }
11085       break;
11086    }
11087    FreeUeContextSetupRsp(f1apMsg);
11088    return ret;
11089 }/* End of BuildAndSendUeContextSetupRsp */
11090 /*******************************************************************
11091 *
11092 * @brief  Build And Send Ue Context Rsp
11093 *
11094 * @details
11095 *
11096 *    Function : BuildAndSendUeCtxtRsp
11097 *
11098 *    Functionality : Build And Send Ue Context Rsp
11099
11100 * @params[in]
11101 * @return sucess = ROK
11102 *         failure = RFAILED
11103 *
11104 * ****************************************************************/
11105 uint8_t BuildAndSendUeCtxtRsp(uint8_t cellId, uint8_t ueIdx)
11106 {
11107    uint8_t cellIdx = 0, actionType = 0;
11108
11109    GET_CELL_IDX(cellId, cellIdx);
11110    actionType = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].f1UeDb->actionType;
11111
11112    switch(actionType)
11113    {
11114       case UE_CTXT_SETUP:
11115          {
11116             BuildAndSendUeContextSetupRsp(cellId,ueIdx);
11117             break;
11118          }
11119       case UE_CTXT_MOD:
11120          {
11121             BuildAndSendUeContextModRsp(cellId, ueIdx);
11122             break;
11123          }
11124       default:
11125          DU_LOG("ERROR  -->  F1AP: Invalid Action Type %d at BuildAndSendUeCtxtRsp()", actionType);
11126          break;
11127
11128    }
11129    return ROK;
11130 }
11131
11132 /*******************************************************************
11133  *
11134  * @brief deallocating the memory of  F1reset msg
11135  *
11136  * @details
11137  *
11138  *    Function : FreeF1ResetReq
11139  *
11140  *    Functionality :
11141  *         - freeing memory of F1reset request msg
11142  *
11143  * @params[in]
11144  * @return void
11145  *
11146  *
11147  * ****************************************************************/
11148 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
11149 {
11150    uint8_t idx =0 ;
11151    Reset_t *f1ResetMsg;
11152
11153    if(f1apMsg)
11154    {
11155       if(f1apMsg->choice.initiatingMessage)
11156       {
11157          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11158
11159          if(f1ResetMsg->protocolIEs.list.array)
11160          {
11161             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
11162             {
11163                if(f1ResetMsg->protocolIEs.list.array[idx])
11164                {
11165                   DU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
11166                }
11167             }
11168             DU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
11169          }
11170          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11171       }
11172       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11173    }
11174 }
11175 /*******************************************************************
11176  *
11177  * @brief Build and Send F1reset request
11178  *
11179  * @details
11180  *
11181  *    Function : BuildAndSendF1ResetReq
11182  *
11183  *    Functionality:
11184  *         - Build and Send F1reset request msg
11185  *
11186  * @params[in]
11187  * @return ROK     - success
11188  *         RFAILED - failure
11189  *
11190  * ****************************************************************/
11191 uint8_t BuildAndSendF1ResetReq()
11192 {
11193    uint8_t          elementCnt=0;
11194    uint8_t          idx=0;
11195    uint8_t          ret= RFAILED;
11196    Reset_t          *f1ResetMsg = NULLP;
11197    F1AP_PDU_t       *f1apMsg = NULLP;
11198    asn_enc_rval_t   encRetVal;
11199    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset request \n");
11200    do
11201    {
11202       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11203       if(f1apMsg == NULLP)
11204       {
11205          break;
11206       }
11207       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
11208       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11209       if(f1apMsg->choice.initiatingMessage == NULLP)
11210       {
11211          break;
11212       }
11213       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
11214       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
11215       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
11216
11217       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11218
11219       elementCnt = 3;
11220       f1ResetMsg->protocolIEs.list.count = elementCnt;
11221       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
11222
11223       /* Initialize the F1Setup members */
11224       DU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
11225       if(f1ResetMsg->protocolIEs.list.array == NULLP)
11226       {
11227          break;
11228       }
11229       for(idx=0; idx<elementCnt; idx++)
11230       {
11231          DU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
11232          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
11233          {
11234             break;
11235          }
11236       }
11237
11238       /*TransactionID*/
11239       idx=0;
11240       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
11241       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11242       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
11243       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
11244
11245       /*Cause*/
11246       idx++;
11247       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
11248       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
11249       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
11250       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
11251       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
11252
11253       /*Reset Type*/
11254       idx++;
11255       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
11256       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11257       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
11258       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
11259       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
11260
11261       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11262
11263       /* Encode the F1SetupRequest type as APER */
11264       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11265       encBufSize = 0;
11266       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11267             encBuf);
11268
11269       /* Encode results */
11270       if(encRetVal.encoded == ENCODE_FAIL)
11271       {
11272          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
11273                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11274          break;
11275       }
11276       else
11277       {
11278          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1Reset\n");
11279          for(idx=0; idx< encBufSize; idx++)
11280          {
11281             printf("%x",encBuf[idx]);
11282          }
11283       }
11284
11285       if(sendF1APMsg() != ROK)
11286       {
11287          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
11288          break;
11289       }
11290
11291       ret = ROK;
11292       break;
11293    }while(true);
11294
11295    FreeF1ResetReq(f1apMsg);
11296    return ret;
11297 }
11298 /*******************************************************************
11299  *
11300  * @brief Build And Send F1ResetAck
11301  *
11302  * @details
11303  *
11304  *    Function : BuildAndSendF1ResetAck
11305  *
11306  *    Functionality:
11307  *         - Build And Send  F1ResetRSP
11308  *
11309  * @return ROK     - success
11310  *         RFAILED - failure
11311  *
11312  * ****************************************************************/
11313 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
11314 {
11315    uint8_t idx;
11316    ResetAcknowledge_t *f1ResetAck;
11317
11318    if(f1apMsg)
11319    {
11320       if(f1apMsg->choice.successfulOutcome)
11321       {
11322          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
11323
11324          if(f1ResetAck->protocolIEs.list.array)
11325          {
11326             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
11327             {
11328                if(f1ResetAck->protocolIEs.list.array[idx])
11329                {
11330                   DU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
11331                }
11332             }
11333             DU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
11334          }
11335          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11336       }
11337       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11338    }
11339 }
11340
11341 /*******************************************************************
11342  *
11343  * @brief Build And Send F1ResetAck
11344  *
11345  * @details
11346  *
11347  *    Function : BuildAndSendF1ResetAck
11348  *
11349  *    Functionality:
11350  *         - Build And Send  F1ResetRSP
11351  *
11352  *  @params[in]
11353  * @return ROK     - success
11354  *         RFAILED - failure
11355  *
11356  * ****************************************************************/
11357 uint8_t BuildAndSendF1ResetAck()
11358 {
11359    uint8_t                idx = 0;
11360    uint8_t                elementCnt = 0;
11361    uint8_t                ret = RFAILED;
11362    F1AP_PDU_t             *f1apMsg = NULL;
11363    ResetAcknowledge_t     *f1ResetAck = NULLP;
11364    asn_enc_rval_t         encRetVal;
11365    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset Acknowledgment \n");
11366
11367    do{
11368       /* Allocate the memory for F1ResetRequest_t */
11369       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11370       if(f1apMsg == NULLP)
11371       {
11372          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11373          break;
11374       }
11375
11376       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
11377
11378       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11379       if(f1apMsg->choice.successfulOutcome == NULLP)
11380       {
11381          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11382          break;
11383       }
11384       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
11385       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
11386       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
11387
11388       elementCnt = 1;
11389
11390       f1ResetAck->protocolIEs.list.count = elementCnt;
11391       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
11392
11393       DU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
11394       if(f1ResetAck->protocolIEs.list.array == NULLP)
11395       {
11396          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
11397          break;
11398       }
11399
11400       for(idx=0; idx<elementCnt; idx++)
11401       {
11402          DU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
11403          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
11404          {
11405             break;
11406          }
11407       }
11408       /*TransactionID*/
11409       idx = 0;
11410       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
11411       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11412       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
11413       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
11414
11415       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11416
11417       /* Encode the F1SetupRequest type as UPER */
11418       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11419       encBufSize = 0;
11420       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
11421
11422       /* Check encode results */
11423       if(encRetVal.encoded == ENCODE_FAIL)
11424       {
11425          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
11426                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11427          break;
11428       }
11429       else
11430       {
11431          DU_LOG("\nDUBUG   -->  F1AP : Created APER encoded buffer for F1ResetAck\n");
11432          for(int i=0; i< encBufSize; i++)
11433          {
11434             printf("%x",encBuf[i]);
11435          }
11436       }
11437       /* Sending msg */
11438       if(sendF1APMsg() != ROK)
11439       {
11440          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Acknowledgement failed");
11441          break;
11442       }
11443
11444       ret = ROK;
11445       break;
11446    }while(true);
11447
11448    FreeF1ResetAck(f1apMsg);
11449    return ret;
11450 }
11451 /******************************************************************
11452 *
11453 * @brief free F1 reset msg allocated by aper_decoder
11454 *
11455 * @details
11456 *
11457 *    Function : freeAperDecodeF1ResetMsg
11458 *
11459 *    Functionality: free F1 reset msg allocated by aper_decoder
11460 *
11461 * @params[in] Reset_t *f1ResetMsg
11462 * @return void
11463 *
11464 * ****************************************************************/
11465
11466 void freeAperDecodeF1ResetMsg(Reset_t *f1ResetMsg)
11467 {
11468    uint8_t ieIdx =0;
11469    if(f1ResetMsg->protocolIEs.list.array)
11470    {
11471       for(ieIdx=0 ;ieIdx < f1ResetMsg->protocolIEs.list.count ; ieIdx++)
11472       {
11473          if(f1ResetMsg->protocolIEs.list.array[ieIdx])
11474          {
11475             free(f1ResetMsg->protocolIEs.list.array[ieIdx]);
11476          }
11477       }
11478       free(f1ResetMsg->protocolIEs.list.array);
11479    }
11480 }
11481
11482 /******************************************************************
11483  *
11484  * @brief Processes DL RRC Message Transfer  sent by CU
11485  *
11486  * @details
11487  *
11488  *    Function : procF1ResetReq
11489  *
11490  *    Functionality: Processes DL RRC Message Transfer sent by CU
11491  *
11492  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11493  * @return ROK     - success
11494  *         RFAILED - failure
11495  *
11496  * ****************************************************************/
11497 uint8_t procF1ResetReq(F1AP_PDU_t *f1apMsg)
11498 {
11499    /* we are currently not supporting Ue release. right now we are supporting only init case of fireset */
11500    uint8_t       ieIdx = 0;
11501    uint8_t        ret = ROK;
11502    Reset_t       *f1ResetMsg = NULLP;
11503
11504    DU_LOG("\nINFO   -->  Processing F1 reset request");
11505    f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11506
11507    for(ieIdx=0; ieIdx<f1ResetMsg->protocolIEs.list.count; ieIdx++)
11508    {
11509       switch(f1ResetMsg->protocolIEs.list.array[ieIdx]->id)
11510       {
11511          case ProtocolIE_ID_id_TransactionID:
11512             break;
11513
11514          case ProtocolIE_ID_id_Cause:
11515             break;
11516
11517          case ProtocolIE_ID_id_ResetType:
11518             {
11519                break;
11520             }
11521
11522          default:
11523             break;
11524       }
11525    }
11526    ret = BuildAndSendF1ResetAck();
11527    DU_LOG("\nINFO   -->  UE release is not supported for now");
11528
11529    freeAperDecodeF1ResetMsg(f1ResetMsg);
11530
11531    return ret;
11532 }
11533
11534 /*******************************************************************
11535  *
11536  * @brief free the RRC delivery report
11537  *
11538  * @details
11539  *
11540  *    Function : freeRrcDeliveryReport
11541  *
11542  *    Functionality: free the RRC delivery report
11543  *
11544  * @params[in]
11545  * @return ROK     - success
11546  *         RFAILED - failure
11547  *
11548  * ****************************************************************/
11549 void freeRrcDeliveryReport(F1AP_PDU_t  *f1apMsg )
11550 {
11551    uint8_t idx=0;
11552    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11553
11554    if(f1apMsg)
11555    {
11556       if(f1apMsg->choice.initiatingMessage)
11557       {
11558          rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11559          if(rrcDeliveryReport->protocolIEs.list.array)
11560          {
11561             for(idx =0 ;idx <rrcDeliveryReport->protocolIEs.list.count ;
11562                   idx++)
11563             {
11564                if(rrcDeliveryReport->protocolIEs.list.array[idx])
11565                {
11566                   DU_FREE(rrcDeliveryReport->protocolIEs.list.array[idx],
11567                         sizeof(RRCDeliveryReportIEs_t));
11568                }
11569             }
11570             DU_FREE(rrcDeliveryReport->protocolIEs.list.array,
11571                   rrcDeliveryReport->protocolIEs.list.size);
11572          }
11573          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11574       }
11575       DU_FREE(f1apMsg,
11576             sizeof(F1AP_PDU_t));
11577    }
11578 }
11579
11580 /*******************************************************************
11581 *
11582 * @brief Builds and sends the RRC delivery report
11583 *
11584 * @details
11585 *
11586 *    Function : BuildAndSendRrcDeliveryReport
11587 *
11588 *    Functionality: Builds and sends the RRC delivery report
11589 *
11590 * @params[in]
11591 *
11592 * @return ROK     - success
11593 *         RFAILED - failure
11594 *
11595 * ****************************************************************/
11596 uint8_t BuildAndSendRrcDeliveryReport(uint32_t gnbCuUeF1apId, \
11597    uint32_t gnbDuUeF1apId, RrcDeliveryReport *rrcDelivery)
11598 {
11599    uint8_t             ret = RFAILED;
11600    uint8_t             idx    = 0;
11601    uint8_t             idx1   = 0;
11602    uint8_t             elementCnt = 0;
11603    F1AP_PDU_t          *f1apMsg = NULLP;
11604    asn_enc_rval_t      encRetVal;
11605    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11606
11607    do{
11608
11609       DU_LOG("\nINFO   -->  F1AP : Building RRC delivery Message Transfer Message\n");
11610       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11611       if(f1apMsg == NULLP)
11612       {
11613          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11614          break;
11615       }
11616       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
11617       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11618       if(f1apMsg->choice.initiatingMessage == NULLP)
11619       {
11620          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU  failed");
11621          break;
11622       }
11623       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_RRCDeliveryReport;
11624       f1apMsg->choice.initiatingMessage->criticality   = Criticality_ignore;
11625       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RRCDeliveryReport;
11626
11627       rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11628       elementCnt = 4;
11629       rrcDeliveryReport->protocolIEs.list.count = elementCnt;
11630       rrcDeliveryReport->protocolIEs.list.size = elementCnt * sizeof(RRCDeliveryReportIEs_t *);
11631
11632       /* Initialize the F1Setup members */
11633       DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array, rrcDeliveryReport->protocolIEs.list.size);
11634       if(rrcDeliveryReport->protocolIEs.list.array == NULLP)
11635       {
11636          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRC Delivery  failed");
11637          break;
11638       }
11639       for(idx =0 ;idx <elementCnt; idx++)
11640       {
11641          DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array[idx], sizeof(RRCDeliveryReportIEs_t));
11642          if(rrcDeliveryReport->protocolIEs.list.array[idx] == NULLP)
11643          {
11644             break;
11645          }
11646       }
11647
11648       idx1 = 0;
11649
11650       /*GNB CU UE F1AP ID*/
11651       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11652       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
11653       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_CU_UE_F1AP_ID;
11654       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
11655
11656       /*GNB DU UE F1AP ID*/
11657       idx1++;
11658       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11659       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
11660       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_DU_UE_F1AP_ID;
11661       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
11662
11663       /*RRC delivery status*/
11664       idx1++;
11665       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_RRCDeliveryStatus;
11666       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
11667       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_RRCDeliveryStatus;
11668       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.delivery_status =\
11669       rrcDelivery->rrcDeliveryStatus.deliveryStatus;
11670       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.triggering_message =\
11671       rrcDelivery->rrcDeliveryStatus.triggeringMessage;
11672
11673       /* SRB ID */
11674       idx1++;
11675       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
11676       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
11677       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_SRBID;
11678       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.SRBID =  rrcDelivery->srbId;
11679
11680       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11681
11682       /* Encode the RRC DELIVERY REPORT type as APER */
11683       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11684       encBufSize = 0;
11685       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11686             encBuf);
11687
11688       /* Encode results */
11689       if(encRetVal.encoded == ENCODE_FAIL)
11690       {
11691          DU_LOG("\nERROR  -->  F1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
11692                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11693          break;
11694       }
11695       else
11696       {
11697          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for RRC Delivery Msg \n");
11698          for(idx=0; idx< encBufSize; idx++)
11699          {
11700             printf("%x",encBuf[idx]);
11701          }
11702       }
11703
11704       /* Sending msg */
11705       if(sendF1APMsg() != ROK)
11706       {
11707          DU_LOG("\nERROR  -->  F1AP : Sending RRC delivery  msg request failed");
11708          break;
11709       }
11710       ret = ROK;
11711       break;
11712
11713    }while(true);
11714
11715    freeRrcDeliveryReport(f1apMsg);
11716    return ret;
11717 }
11718
11719 /*******************************************************************
11720  *
11721  * @brief Processes cells to be activated
11722  *
11723  * @details
11724  *
11725  *    Function : extractCellsToBeActivated
11726  *
11727  *    Functionality:
11728  *      - Processes cells to be activated list received in F1SetupRsp
11729  *
11730  * @params[in] void
11731  * @return ROK     - success
11732  *         RFAILED - failure
11733  *
11734  * ****************************************************************/
11735
11736 uint8_t extractCellsToBeActivated(Cells_to_be_Activated_List_t cellsToActivate)
11737 {
11738    uint8_t  ret = ROK;
11739    uint16_t idx, nci, pci = 0;
11740    Cells_to_be_Activated_List_Item_t cell;
11741
11742    for(idx=0; idx<cellsToActivate.list.count; idx++)
11743    {
11744       nci = 0;
11745       cell = cellsToActivate.list.array[idx]->value.choice.Cells_to_be_Activated_List_Item;
11746       bitStringToInt(&cell.nRCGI.nRCellIdentity, &nci);
11747
11748       if(cell.nRPCI)
11749       {
11750          pci = *cell.nRPCI;
11751       }
11752       ret = duProcCellsToBeActivated(cell.nRCGI.pLMN_Identity.buf, nci, pci);
11753    }
11754    return ret;
11755 }
11756 /******************************************************************
11757 *
11758 * @brief Processes F1 Setup Response allocated by aper_decoder
11759 *
11760 * @details
11761 *
11762 *    Function : freeF1SetupRsp
11763 *
11764 *    Functionality: free F1 Setup Response allocated by aper_decoder
11765 *
11766 * @params[in] F1SetupResponse_t *f1SetRspMsg
11767 * @return void
11768 *
11769 * ****************************************************************/
11770
11771 void freeAperDecodeF1SetupRsp(F1SetupResponse_t *f1SetRspMsg)
11772 {
11773    uint8_t ieIdx =0;
11774    uint8_t arrIdx =0;
11775    Cells_to_be_Activated_List_t *cellToActivate =NULLP;
11776    RRC_Version_t      *rrcVer =NULLP;
11777
11778    if(f1SetRspMsg->protocolIEs.list.array)
11779    {
11780       for(ieIdx=0; ieIdx<f1SetRspMsg->protocolIEs.list.count; ieIdx++)
11781       {
11782          if(f1SetRspMsg->protocolIEs.list.array[ieIdx])
11783          {
11784             switch(f1SetRspMsg->protocolIEs.list.array[ieIdx]->id)
11785             {
11786                case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11787                   {
11788                      cellToActivate =
11789                         &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.Cells_to_be_Activated_List;
11790                      if(cellToActivate->list.array)
11791                      {
11792                         for(arrIdx=0; arrIdx<cellToActivate->list.count ; arrIdx++)
11793                         {
11794                            if(cellToActivate->list.array[arrIdx])
11795                            {
11796
11797                               if(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.\
11798                               pLMN_Identity.buf)
11799                               {
11800                                  if(cellToActivate->list.array[0]->value.choice.\
11801                                        Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf)
11802                                  {
11803                                     free(cellToActivate->list.array[0]->value.choice.\
11804                                           Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf);
11805                                  }
11806
11807                                  free(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
11808                                        nRCGI.pLMN_Identity.buf);
11809                               }
11810                               free(cellToActivate->list.array[arrIdx]);
11811                            }
11812                         }
11813                         free(cellToActivate->list.array);
11814                      }
11815                      break;
11816                   }
11817                case ProtocolIE_ID_id_TransactionID:
11818                   {
11819                      break;
11820                   }
11821                case ProtocolIE_ID_id_gNB_CU_Name:
11822                   {
11823                      free(f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_Name.buf);
11824                      break;
11825                   }
11826                case ProtocolIE_ID_id_GNB_CU_RRC_Version:
11827                   {
11828                      rrcVer = &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
11829                      if(rrcVer->latest_RRC_Version.buf)
11830                      {
11831                         if(rrcVer->iE_Extensions)
11832                         {
11833                            if(rrcVer->iE_Extensions->list.array)
11834                            {
11835                               if(rrcVer->iE_Extensions->list.array[0])
11836                               {
11837                                  if(rrcVer->iE_Extensions->list.\
11838                                        array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf)
11839                                  {
11840                                     free(rrcVer->iE_Extensions->list.\
11841                                           array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf);
11842                                  }
11843                                  free(rrcVer->iE_Extensions->list.array[0]);
11844                               }
11845                               free(rrcVer->iE_Extensions->list.array);
11846                            }
11847                            free(rrcVer->iE_Extensions);
11848                         }
11849                         free(rrcVer->latest_RRC_Version.buf);
11850                      }
11851                      break;
11852
11853                   }
11854                default:
11855                   {
11856                      DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
11857                            f1SetRspMsg->protocolIEs.list.array[ieIdx]->id);
11858                   }
11859             }
11860             free(f1SetRspMsg->protocolIEs.list.array[ieIdx]);
11861          }
11862       }
11863       free(f1SetRspMsg->protocolIEs.list.array);
11864    }
11865 }
11866 /******************************************************************
11867  *
11868  * @brief Processes F1 Setup Response sent by CU
11869  *
11870  * @details
11871  *
11872  *    Function : procF1SetupRsp
11873  *
11874  *    Functionality: Processes F1 Setup Response sent by CU
11875  *
11876  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11877  * @return ROK     - success
11878  *         RFAILED - failure
11879  *
11880  * ****************************************************************/
11881 uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg)
11882 {
11883    uint8_t ret = ROK;
11884    uint16_t idx =0;
11885    F1SetupResponse_t *f1SetRspMsg = NULLP;
11886    GNB_CU_Name_t     *cuName = NULLP;
11887    F1SetupRsp  f1SetRspDb;
11888    RRC_Version_t      *rrcVer =NULLP;
11889
11890    memset(&f1SetRspDb, 0, sizeof(F1SetupRsp));
11891
11892    DU_LOG("\nINFO   -->  F1AP : F1 Setup Response received");
11893    f1SetRspMsg = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
11894
11895    for(idx=0; idx<f1SetRspMsg->protocolIEs.list.count; idx++)
11896    {
11897       switch(f1SetRspMsg->protocolIEs.list.array[idx]->id)
11898       {
11899          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11900             {
11901                extractCellsToBeActivated(f1SetRspMsg->protocolIEs.list.array[idx]->\
11902                      value.choice.Cells_to_be_Activated_List);
11903                break;
11904             }
11905          case ProtocolIE_ID_id_TransactionID:
11906             {
11907                f1SetRspDb.transId = f1SetRspMsg->protocolIEs.list.array[idx]->\
11908                                     value.choice.TransactionID;
11909                break;
11910             }
11911          case ProtocolIE_ID_id_gNB_CU_Name:
11912             {
11913                cuName = &f1SetRspMsg->protocolIEs.list.array[idx]->\
11914                         value.choice.GNB_CU_Name;
11915                strcpy(f1SetRspDb.cuName, (const char*)cuName->buf);
11916                break;
11917             }
11918          case ProtocolIE_ID_id_GNB_CU_RRC_Version:
11919             {
11920                rrcVer = &f1SetRspMsg->protocolIEs.list.array[idx]->value.choice.RRC_Version;
11921                strcpy(f1SetRspDb.rrcVersion.rrcVer,
11922                      (const char*)rrcVer->latest_RRC_Version.buf);
11923                break;
11924             }
11925          default:
11926             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
11927                   f1SetRspMsg->protocolIEs.list.array[idx]->id);
11928       }
11929       duProcF1SetupRsp();
11930    }
11931
11932    freeAperDecodeF1SetupRsp(f1SetRspMsg);
11933    return ret;
11934 }
11935 /*******************************************************************
11936 *
11937 * @brief free GNB DU config update ack
11938 *
11939 * @details
11940 *
11941 *    Function : freeAperDecodeGnbDuAck
11942 *
11943 *    Functionality: Processes GNB DU config update ack And
11944 *                     added free part for the memory allocated by aper_decoder
11945 *
11946 * @params[in] F1AP_PDU_t ASN decoded F1AP message
11947 * @return ROK     - success
11948 *         RFAILED - failure
11949 *
11950 * ****************************************************************/
11951
11952 void freeAperDecodeGnbDuAck(GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck)
11953 {
11954    uint8_t ieIdx = 0;
11955
11956    if(gnbDuAck->protocolIEs.list.array)
11957    {
11958       for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
11959       {
11960          if(gnbDuAck->protocolIEs.list.array[ieIdx])
11961          {
11962             free(gnbDuAck->protocolIEs.list.array[ieIdx]);
11963          }
11964       }
11965       free(gnbDuAck->protocolIEs.list.array);
11966    }
11967 }
11968
11969 /*******************************************************************
11970 *
11971 * @brief Building  result of gnb-du config update ack output
11972 *
11973 * @details
11974 *
11975 *    Function : duProcGnbDuCfgUpdAckMsg
11976 *
11977 *    Functionality:
11978 *        Building output of gnb-du config update ack
11979 *
11980 * @params[in] transId
11981 * @return void
11982 *
11983 * ****************************************************************/
11984
11985 uint8_t duProcGnbDuCfgUpdAckMsg(uint8_t transId)
11986 {
11987    uint8_t  ieIdx=0, arrIdx=0,ret=ROK;
11988    uint8_t  ueId =0 , ueIdx =0;
11989    uint16_t cellId =0, cellIdx =0, crnti=0;
11990    CmLList *f1apPduNode = NULLP;
11991    ReservedF1apPduInfo *f1apPduInfo =NULLP;
11992    F1AP_PDU_t *f1apMsgPdu = NULLP;
11993    GNBDUConfigurationUpdate_t *gnbDuConfigUpdate = NULLP;
11994    BIT_STRING_t *cellIdentity=NULLP;
11995    struct Served_Cells_To_Delete_ItemIEs *deleteItemIe=NULLP;
11996    Served_Cells_To_Delete_List_t *cellsToDelete=NULLP;
11997    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
11998
11999    DU_LOG("\nINFO   -->  DU APP: GNB-DU config update Ack received ");
12000    f1apPduNode = searchFromReservedF1apPduList(transId);
12001    f1apPduInfo = (ReservedF1apPduInfo *)f1apPduNode->node;
12002    f1apMsgPdu = (F1AP_PDU_t *)f1apPduInfo->f1apMsg;
12003
12004    if(f1apMsgPdu)
12005    {
12006       if(f1apMsgPdu->choice.initiatingMessage)
12007       {
12008          gnbDuConfigUpdate = &f1apMsgPdu->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
12009          for(ieIdx=0; ieIdx < gnbDuConfigUpdate->protocolIEs.list.count; ieIdx++)
12010          {
12011             switch(gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->id)
12012             {
12013                case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
12014                   {
12015                      cellsToDelete = &gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
12016                                      Served_Cells_To_Delete_List;
12017                      if(cellsToDelete->list.array)
12018                      {
12019                         if(cellsToDelete->list.array[arrIdx])
12020                         {
12021                            deleteItemIe = (Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx];
12022                            deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
12023                            if(deleteItem->oldNRCGI.nRCellIdentity.buf)
12024                            {
12025                               cellIdentity = &deleteItem->oldNRCGI.nRCellIdentity;
12026                               bitStringToInt(cellIdentity, &cellId);
12027                            }
12028                         }
12029                      }
12030
12031                      GET_CELL_IDX(cellId, cellIdx);
12032                      if(duCb.actvCellLst[cellIdx] != NULLP)
12033                      {
12034                         if(duCb.actvCellLst[cellIdx]->numActvUes == 0)
12035                         {
12036                            duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
12037                            ret = duSendCellDeletReq(cellId);
12038                            if(ret == RFAILED)
12039                            {
12040                               DU_LOG("ERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to send cell delete\
12041                               request for cellId[%d]", cellId);
12042                            }
12043                         }
12044                         else
12045                         {
12046                            for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
12047                            {
12048                               crnti = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].crnti;
12049                               GET_UE_IDX(crnti,ueId);
12050                               ret = BuildAndSendUeContextReleaseReq(cellId, ueId);
12051                               if(ret == RFAILED)
12052                               {
12053                                  DU_LOG("ERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to build and send UE delete\
12054                                  request for cellId[%d]", cellId);
12055                               }
12056                            }
12057                         }
12058                      }
12059                      else
12060                      {
12061                         DU_LOG("ERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): CellId [%d] not found", cellId);
12062                         ret = RFAILED;
12063                      }
12064                      break;
12065                   }
12066
12067                default:
12068                   break;
12069             }
12070          }
12071       }
12072    }
12073
12074    FreeDUConfigUpdate(f1apMsgPdu);
12075    deleteFromReservedF1apPduList(f1apPduNode);
12076    return ret;
12077 }
12078
12079 /*******************************************************************
12080 *
12081 * @brief Processes GNB DU config update ack
12082 *
12083 * @details
12084 *
12085 *    Function : procF1GNBDUCfgUpdAck
12086 *
12087 *    Functionality: added free part for the memory allocated by aper_decoder
12088 *
12089 * @params[in] F1AP_PDU_t *f1apMsg
12090 * @return void
12091 *
12092 * ****************************************************************/
12093 uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
12094 {
12095    uint8_t ieIdx=0,transId=0;
12096    GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
12097
12098    DU_LOG("\nINFO   -->  F1AP : GNB-DU config update acknowledgment");
12099    gnbDuAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
12100
12101    for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
12102    {
12103       switch(gnbDuAck->protocolIEs.list.array[ieIdx]->id)
12104       {
12105          case ProtocolIE_ID_id_TransactionID:
12106             {
12107                transId = gnbDuAck->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
12108                break;
12109             }
12110          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
12111             {
12112                break;
12113             }
12114          default :
12115             {
12116                DU_LOG("\nERROR  -->  F1AP: procF1GNBDUCfgUpdAck(): Invalid IE Received: %ld", \
12117                      gnbDuAck->protocolIEs.list.array[ieIdx]->id);
12118                break;
12119             }
12120       }
12121    }
12122
12123    duProcGnbDuCfgUpdAckMsg(transId);
12124
12125 #if 0
12126    /* presently we are not supporting F1 Reset from DU to CU , we are only
12127     * supporting F1 Reset from CU to DU */
12128
12129    if(BuildAndSendF1ResetReq() != ROK)
12130    {
12131       return RFAILED;
12132    }
12133 #endif
12134
12135    freeAperDecodeGnbDuAck(gnbDuAck);
12136    return ROK;
12137 }
12138 /******************************************************************
12139 *
12140 * @brief free DL RRC Message Transfer allocated by aper_decoder
12141 *
12142 * @details
12143 *
12144 *    Function : freeAperDecodef1DlRrcMsg
12145 *
12146 *    Functionality: free DL RRC Message Transfer allocated by aper_decoder
12147 *
12148 * @params[in] DLRRCMessageTransfer_t *f1DlRrcMsg
12149 * @return ROK     - success
12150 *         RFAILED - failure
12151 *
12152 * ****************************************************************/
12153
12154 void freeAperDecodef1DlRrcMsg(DLRRCMessageTransfer_t *f1DlRrcMsg)
12155 {
12156    uint8_t ieIdx =0;
12157    RRCContainer_t *rrcContainer = NULLP;
12158
12159    if(f1DlRrcMsg->protocolIEs.list.array)
12160    {
12161       for(ieIdx=0; ieIdx<f1DlRrcMsg->protocolIEs.list.count; ieIdx++)
12162       {
12163          if(f1DlRrcMsg->protocolIEs.list.array[ieIdx])
12164          {
12165             switch(f1DlRrcMsg->protocolIEs.list.array[ieIdx]->id)
12166             {
12167                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12168                   break;
12169                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12170                   break;
12171                case ProtocolIE_ID_id_SRBID:
12172                   break;
12173                case ProtocolIE_ID_id_RRCContainer:
12174                   {
12175                      rrcContainer =&f1DlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
12176                      free(rrcContainer->buf);
12177                   }
12178                case ProtocolIE_ID_id_ExecuteDuplication:
12179                   break;
12180                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
12181                   break;
12182                   break;
12183             }
12184             free(f1DlRrcMsg->protocolIEs.list.array[ieIdx]);
12185          }
12186       }
12187       free(f1DlRrcMsg->protocolIEs.list.array);
12188    }
12189 }
12190 /******************************************************************
12191  *
12192  * @brief Processes DL RRC Message Transfer  sent by CU
12193  *
12194  * @details
12195  *
12196  *    Function : procF1DlRrcMsgTrans
12197  *
12198  *    Functionality: Processes DL RRC Message Transfer sent by CU
12199  *
12200  * @params[in] F1AP_PDU_t ASN decoded F1AP message
12201  * @return ROK     - success
12202  *         RFAILED - failure
12203  *
12204  * ****************************************************************/
12205 uint8_t procF1DlRrcMsgTrans(F1AP_PDU_t *f1apMsg)
12206 {
12207    uint8_t  idx, ret;
12208    DLRRCMessageTransfer_t *f1DlRrcMsg = NULLP;
12209    F1DlRrcMsg dlMsg;
12210    memset(&dlMsg, 0, sizeof(F1DlRrcMsg));
12211
12212    DU_LOG("\nINFO   -->  DU_APP : DL RRC message transfer Recevied");
12213    f1DlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
12214
12215    ret = ROK;
12216
12217    for(idx=0; idx<f1DlRrcMsg->protocolIEs.list.count; idx++)
12218    {
12219       switch(f1DlRrcMsg->protocolIEs.list.array[idx]->id)
12220       {
12221          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12222             {
12223                dlMsg.gnbCuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
12224                break;
12225             }
12226          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12227             {
12228                dlMsg.gnbDuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
12229                break;
12230             }
12231          case ProtocolIE_ID_id_SRBID:
12232             {
12233                dlMsg.srbId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
12234                break;
12235             }
12236          case ProtocolIE_ID_id_ExecuteDuplication:
12237             dlMsg.execDup = true;
12238             break;
12239
12240          case ProtocolIE_ID_id_RRCContainer:
12241             {
12242                if(f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0)
12243                {
12244                   dlMsg.rrcMsgSize = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
12245                   DU_ALLOC_SHRABL_BUF(dlMsg.rrcMsgPdu, dlMsg.rrcMsgSize);
12246                   if(dlMsg.rrcMsgPdu)
12247                   {
12248                      memcpy(dlMsg.rrcMsgPdu, f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
12249                         dlMsg.rrcMsgSize);
12250                   }
12251                   else
12252                   {
12253                      DU_LOG("\nERROR  -->  DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
12254                      return RFAILED;
12255                   }
12256                }
12257                else
12258                {
12259                   DU_LOG("\nERROR  -->  DU_APP : RRC Container Size is invalid:%ld",\
12260                   f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
12261                   return RFAILED;
12262                }
12263                break;
12264             }
12265          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
12266             {
12267                dlMsg.deliveryStatRpt = true;
12268                break;
12269             }
12270          default:
12271             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
12272                   f1DlRrcMsg->protocolIEs.list.array[idx]->id);
12273       }
12274    }
12275
12276    ret = duProcDlRrcMsg(&dlMsg);
12277
12278    freeAperDecodef1DlRrcMsg(f1DlRrcMsg);
12279    return ret;
12280 }
12281 /*******************************************************************
12282  *
12283 * @brief Builds the DRB to be Setup Mod list
12284 *
12285 * @details
12286 *
12287 *    Function :
12288 *
12289 *    Functionality: Constructs the DRB to be Setup Mod list
12290 *
12291 * @params[in] DRBs_SetupMod_List_t *drbSet
12292 *
12293 * @return ROK     - success
12294 *         RFAILED - failure
12295 *
12296 * ****************************************************************/
12297
12298 uint8_t BuildDrbSetupModList(DRBs_SetupMod_List_t *drbSet , DuUeCfg *ueCfg)
12299 {
12300    uint8_t arrIdx =0;
12301    uint8_t drbCnt =0;
12302    struct DRBs_SetupMod_ItemIEs *drbItemIe;
12303
12304    drbCnt = 1;
12305    drbSet->list.count = drbCnt;
12306    drbSet->list.size = drbCnt * sizeof(DRBs_SetupMod_ItemIEs_t *);
12307    DU_ALLOC(drbSet->list.array, drbSet->list.size);
12308    if(drbSet->list.array == NULLP)
12309    {
12310       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
12311       return  RFAILED;
12312    }
12313    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
12314    {
12315       DU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
12316       if(drbSet->list.array[arrIdx] == NULLP)
12317       {
12318               DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
12319               return  RFAILED;
12320       }
12321
12322       drbItemIe = (struct DRBs_SetupMod_ItemIEs *)drbSet->list.array[arrIdx];
12323       drbItemIe->id = ProtocolIE_ID_id_DRBs_SetupMod_Item;
12324       drbItemIe->criticality = Criticality_reject;
12325       drbItemIe->value.present = DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item;
12326       drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
12327       if(fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List,\
12328       &ueCfg->upTnlInfo[arrIdx])!= ROK)
12329       {
12330          DU_LOG("\nERROR  -->  F1AP : Failed to fill DlTnl SetupList in BuildDrbToBeSetupModList");
12331          return RFAILED;
12332       }
12333
12334    }
12335
12336    return ROK;
12337 }
12338 /*******************************************************************
12339 * @brief Free the memory allocated for DRB setup List
12340 *
12341 * @details
12342 *
12343 *    Function : FreeDrbSetupModList
12344 *
12345 *    Functionality:
12346 *       Free the memory allocated for DRB setup list
12347 *
12348 * @params[in] DRBs_Setup_List_t *
12349 * @return void
12350 *
12351 * ****************************************************************/
12352 void FreeDrbSetupModList(DRBs_SetupMod_List_t *drbSetupList)
12353 {
12354    uint8_t arrIdx = 0;
12355    DRBs_SetupMod_ItemIEs_t *drbItemIe = NULLP;
12356
12357    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
12358    {
12359       drbItemIe = ((DRBs_SetupMod_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
12360       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
12361       DU_FREE(drbSetupList->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
12362    }
12363    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
12364 }
12365 /*******************************************************************
12366 * @brief Free the memory allocated for UE Context Mod Response
12367 *
12368 * @details
12369 *
12370 *    Function : FreeUeContextModResp
12371 *
12372 *    Functionality:
12373 *       Free the memory allocated for UE Context Mod Response
12374 *
12375 * @params[in] F1AP_PDU_t *f1apMsg
12376 * @return void
12377 *
12378 * ****************************************************************/
12379
12380 void FreeUeContextModResp(F1AP_PDU_t *f1apMsg)
12381 {
12382    uint8_t ieIdx;
12383    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
12384    if(f1apMsg)
12385    {
12386       if(f1apMsg->choice.successfulOutcome)
12387       {
12388          ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
12389          if(ueContextModifyRes->protocolIEs.list.array)
12390          {
12391             for(ieIdx=0 ; ieIdx<ueContextModifyRes->protocolIEs.list.count; ieIdx++)
12392             {
12393                if(ueContextModifyRes->protocolIEs.list.array[ieIdx])
12394                {
12395                   switch(ueContextModifyRes->protocolIEs.list.array[ieIdx]->id)
12396                   {
12397                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12398                         break;
12399                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12400                         break;
12401                      case ProtocolIE_ID_id_DRBs_SetupMod_List:
12402                         {
12403                             FreeDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
12404                             value.choice.DRBs_SetupMod_List));
12405                             break;
12406                         }
12407                   }
12408                   DU_FREE(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
12409                }
12410
12411             }
12412             DU_FREE(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
12413          }
12414          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12415       }
12416       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12417    }
12418 }
12419
12420 /*****************************************************************i
12421 *
12422 * @brief Creating the ue context modifcation response and sending
12423 *
12424 * @details
12425 *
12426 *    Function : BuildAndSendUeContextModRsp
12427 *
12428 *    Functionality:
12429 *         - Creating the ue context modifcation response
12430 *
12431 * @params[in] uint8_t cellId,uint8_t ueIdx
12432 * @return ROK     - success
12433 *         RFAILED - failure
12434 *
12435 * ****************************************************************/
12436 uint8_t BuildAndSendUeContextModRsp(uint8_t cellId,uint8_t ueIdx)
12437 {
12438    uint8_t   ieIdx = 0;
12439    uint8_t   cellIdx =0;
12440    uint8_t   elementCnt = 0;
12441    uint8_t   ret = RFAILED;
12442    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
12443    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
12444    F1AP_PDU_t *f1apMsg = NULLP;
12445    asn_enc_rval_t         encRetVal;
12446    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
12447    DuUeCb                   *ueCb = NULLP;
12448
12449    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification response\n");
12450
12451    while(1)
12452    {
12453       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12454       if(f1apMsg == NULLP)
12455       {
12456          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
12457          break;
12458       }
12459
12460       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
12461
12462       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12463       if(f1apMsg->choice.successfulOutcome == NULLP)
12464       {
12465          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
12466          break;
12467       }
12468       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextModification;
12469       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
12470       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_UEContextModificationResponse;
12471
12472       ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
12473
12474       elementCnt = 3;
12475       ueContextModifyRes->protocolIEs.list.count = elementCnt;
12476       ueContextModifyRes->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationResponse_t*);
12477
12478       /* Initialize the UE context modification members */
12479       DU_ALLOC(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
12480       if(ueContextModifyRes->protocolIEs.list.array == NULLP)
12481       {
12482          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
12483          break;
12484       }
12485
12486       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
12487       {
12488          DU_ALLOC(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
12489          if(ueContextModifyRes->protocolIEs.list.array[ieIdx] == NULLP)
12490          {
12491             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
12492             break;
12493          }
12494       }
12495
12496       /* Fetching Ue Cb Info*/
12497       GET_CELL_IDX(cellId, cellIdx);
12498       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
12499       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
12500       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
12501
12502       ieIdx=0;
12503       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
12504       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12505       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
12506       UEContextModificationResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
12507       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
12508
12509       ieIdx++;
12510       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
12511       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12512       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present=\
12513       UEContextModificationResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
12514       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
12515
12516       ieIdx++;
12517       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_SetupMod_List;
12518       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12519       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
12520       UEContextModificationResponseIEs__value_PR_DRBs_SetupMod_List;
12521       if(ueCb->f1UeDb)
12522       {
12523          ret = BuildDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
12524                   value.choice.DRBs_SetupMod_List) , &ueCb->f1UeDb->duUeCfg);
12525          if(ret != ROK)
12526          {
12527             DU_LOG( "\nERROR  -->  F1AP : Failed to build drb setupmod List ");
12528             break;
12529          }
12530          freeF1UeDb(ueCb->f1UeDb);
12531          ueCb->f1UeDb = NULLP;
12532       }
12533       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12534
12535       /* Encode the F1SetupRequest type as APER */
12536       memset(encBuf, 0, ENC_BUF_MAX_LEN);
12537       encBufSize = 0;
12538       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,encBuf);
12539
12540       /* Encode results */
12541       if(encRetVal.encoded == ENCODE_FAIL)
12542       {
12543          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
12544                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12545          ret = RFAILED;
12546          break;
12547       }
12548       else
12549       {
12550          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Modification Response\n");
12551          for(int i=0; i< encBufSize; i++)
12552          {
12553             printf("%x",encBuf[i]);
12554          }
12555       }
12556
12557       /* Sending  msg  */
12558       if(sendF1APMsg() != ROK)
12559       {
12560          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Res Failed");
12561          ret = RFAILED;
12562          break;
12563       }
12564       break;
12565    }
12566    FreeUeContextModResp(f1apMsg);
12567    return ret;
12568 }
12569 /*******************************************************************
12570  *
12571  * @brief Deallocating the memory allocated by the aper decoder
12572  *          for QOSInfo
12573  *
12574  * @details
12575  *
12576  *    Function : freeAperDecodeQosInfo
12577  *
12578  *    Functionality:  Deallocating the memory allocated for QOSInfo
12579  *
12580  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
12581  *
12582  * @return void
12583  *
12584  * ****************************************************************/
12585
12586 void freeAperDecodeQosInfo(QoSFlowLevelQoSParameters_t *drbQos)
12587 {
12588    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
12589    {
12590       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
12591       {
12592          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
12593          {
12594             free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
12595          }
12596          free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
12597       }
12598       free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI);
12599    }
12600 }
12601 /*******************************************************************
12602  *
12603  * @brief Deallocating the memory allocated by the aper decoder
12604  *          for UlTnlInfoforDrb
12605  *
12606  * @details
12607  *
12608  *    Function : freeAperDecodeUlTnlInfoforDrbSetupMod
12609  *
12610  *    Functionality:  Deallocating memory allocated for UlTnlInfoforDrb
12611  *
12612  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
12613  *
12614  * @return void
12615  *
12616  * ****************************************************************/
12617 void freeAperDecodeUlTnlInfoforDrbSetupMod(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
12618 {
12619    uint8_t arrIdx =0;
12620
12621    if(ulInfo->list.array)
12622    {
12623       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
12624       {
12625          if(ulInfo->list.array[arrIdx])
12626          {
12627             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
12628             {
12629                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
12630                {
12631                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
12632                   {
12633                      free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12634                            gTP_TEID.buf);
12635                   }
12636                   free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12637                         transportLayerAddress.buf);
12638                }
12639                free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel);
12640             }
12641             free(ulInfo->list.array[arrIdx]);
12642          }
12643       }
12644       free(ulInfo->list.array);
12645    }
12646 }
12647 /*******************************************************************
12648  *
12649  * @brief Deallocating the memory allocated by the aper decoder
12650  *          for DrbSetupModItem
12651  *
12652  * @details
12653  *
12654  *    Function : freeAperDecodeDrbSetupModItem
12655  *
12656  *    Functionality:  Deallocating memory allocated for DrbSetupModItem
12657  *
12658  * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
12659  *
12660  * @return void
12661  *
12662  * ****************************************************************/
12663
12664 void freeAperDecodeDrbSetupModItem(DRBs_ToBeSetupMod_Item_t *drbItem)
12665 {
12666    uint8_t arrIdx =0;
12667    SNSSAI_t *snssai =NULLP;
12668    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
12669
12670    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
12671    switch(drbItem->qoSInformation.present)
12672    {
12673       case QoSInformation_PR_NOTHING:
12674          break;
12675       case QoSInformation_PR_eUTRANQoS:
12676          {
12677             if(drbItem->qoSInformation.choice.eUTRANQoS)
12678             {
12679                free(drbItem->qoSInformation.choice.eUTRANQoS);
12680             }
12681             break;
12682          }
12683       case QoSInformation_PR_choice_extension:
12684          {
12685             if(drbItem->qoSInformation.choice.choice_extension)
12686             {
12687                freeAperDecodeQosInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.\
12688                      DRB_Information.dRB_QoS);
12689                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
12690                if(snssai->sST.buf)
12691                {
12692                   free(snssai->sST.buf);
12693                }
12694                if(snssai->sD)
12695                {
12696                   if(snssai->sD->buf)
12697                   {
12698                      free(snssai->sD->buf);
12699                   }
12700                   free(snssai->sD);
12701                }
12702
12703                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.\
12704                          DRB_Information.flows_Mapped_To_DRB_List;
12705                if(flowMap->list.array)
12706                {
12707                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
12708                   {
12709                      if(flowMap->list.array[arrIdx] )
12710                      {
12711                         freeAperDecodeQosInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
12712                         free(flowMap->list.array[arrIdx]);
12713                      }
12714                   }
12715                   free(flowMap->list.array);
12716                }
12717
12718                free(drbItem->qoSInformation.choice.choice_extension);
12719             }
12720             break;
12721          }
12722
12723    }
12724    freeAperDecodeUlTnlInfoforDrbSetupMod(&drbItem->uLUPTNLInformation_ToBeSetup_List);
12725    if(drbItem->uLConfiguration)
12726    {
12727       free(drbItem->uLConfiguration);
12728    }
12729 }
12730
12731 /*******************************************************************
12732  *
12733  * @brief Deallocating the memory allocated by the aper decoder
12734  *          for DrbToBeSetupModList
12735  *
12736  * @details
12737  *
12738  *    Function : freeAperDecodeDrbToBeSetupModList
12739  *
12740  *    Functionality:  Deallocating memory allocated for DrbToBeSetupModList
12741  *
12742  * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
12743  *
12744  * @return void
12745  *
12746  * ****************************************************************/
12747
12748 void freeAperDecodeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
12749 {
12750    uint8_t arrIdx =0;
12751    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
12752
12753    if(drbSet->list.array)
12754    {
12755       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
12756       {
12757          if(drbSet->list.array[arrIdx] != NULLP)
12758          {
12759             if(arrIdx == 0)
12760             {
12761                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
12762                freeAperDecodeDrbSetupModItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
12763             }
12764             free(drbSet->list.array[arrIdx]);
12765          }
12766       }
12767       free(drbSet->list.array);
12768    }
12769
12770 }
12771 /*******************************************************************
12772  *
12773  * @brief Deallocating the memory allocated by the aper decoder
12774  *          for UeContextModificationReqMsg
12775  *
12776  * @details
12777  *
12778  *    Function : freeAperDecodeUeContextModificationReqMsg
12779  *
12780  *    Functionality:  Deallocating memory allocated for
12781  *                  UeContextModificationReqMsg
12782  *
12783  * @params[in] UEContextModificationRequest_t *UeContextModifyReq
12784  *
12785  * @return void
12786  *
12787  * ****************************************************************/
12788 void freeAperDecodeUeContextModificationReqMsg(UEContextModificationRequest_t *UeContextModifyReq )
12789 {
12790    uint8_t arrIdx, ieId;
12791
12792    if(UeContextModifyReq->protocolIEs.list.array)
12793    {
12794       for( arrIdx = 0 ; arrIdx<UeContextModifyReq->protocolIEs.list.count ; arrIdx++)
12795       {
12796          if(UeContextModifyReq->protocolIEs.list.array[arrIdx])
12797          {
12798             ieId = UeContextModifyReq->protocolIEs.list.array[arrIdx]->id;
12799             switch(ieId)
12800             {
12801                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12802                   break;
12803                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12804                   break;
12805                case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
12806                   {
12807                      freeAperDecodeDrbToBeSetupModList(&UeContextModifyReq->protocolIEs.list.array[arrIdx]->\
12808                            value.choice.DRBs_ToBeSetupMod_List);
12809                      break;
12810                   }
12811             }
12812             free(UeContextModifyReq->protocolIEs.list.array[arrIdx]);
12813          }
12814       }
12815       free(UeContextModifyReq->protocolIEs.list.array);
12816    }
12817 }
12818 /*******************************************************************
12819  *
12820  * @brief processing the F1 UeContextModificationReq
12821  *
12822  * @details
12823  *
12824  *    Function : procF1UeContextModificationReq
12825  *
12826  *    Functionality:  processing the F1 UeContextModificationReq
12827  *
12828  * @params[in] F1AP_PDU_t *f1apMsg
12829  *
12830  * @return
12831  * ****************************************************************/
12832 uint8_t procF1UeContextModificationReq(F1AP_PDU_t *f1apMsg)
12833 {
12834    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
12835    uint8_t  ret = ROK, ieIdx = 0, cellIdx=0, ueIdx=0;
12836    DuUeCb   *duUeCb = NULLP;
12837    DRBs_ToBeSetupMod_List_t *drbSetupModCfg;
12838    uint32_t gnbCuUeF1apId, gnbDuUeF1apId;
12839
12840    ueContextModifyReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
12841    for(ieIdx=0; (ieIdx < ueContextModifyReq->protocolIEs.list.count && ret == ROK); ieIdx++)
12842    {
12843       switch(ueContextModifyReq->protocolIEs.list.array[ieIdx]->id)
12844       {
12845          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12846             {
12847                gnbCuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
12848                break;
12849             }
12850          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12851             {
12852                gnbDuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
12853                break;
12854             }
12855          case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
12856             {
12857                for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
12858                {
12859                   for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
12860                   {
12861                      if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
12862                            (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
12863                      {
12864
12865                         duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
12866                            DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
12867                            if(duUeCb->f1UeDb)
12868                            {
12869                               duUeCb->f1UeDb->actionType = UE_CTXT_MOD;
12870                               drbSetupModCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
12871                               choice.DRBs_ToBeSetupMod_List;
12872                               if(extractDrbListToSetup(NULL, drbSetupModCfg ,drbSetupModCfg->list.count, \
12873                               &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap))
12874                               {
12875                                  DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetup()");
12876                                  ret = RFAILED;
12877                               }
12878                            }
12879                         break;
12880                      }
12881                   }
12882                   if(ueIdx >= duCb.actvCellLst[cellIdx]->numActvUes)
12883                   {
12884                      DU_LOG("\nERROR  -->  DU APP : wrong values of gnbCuUeF1apId and gnbDuUeF1apId ");
12885                      ret = RFAILED;
12886                   }
12887                }
12888                break;
12889             }
12890       }
12891    }
12892    if(ret != RFAILED)
12893    {
12894       ret = duProcUeContextModReq(duUeCb);
12895    }
12896    freeAperDecodeUeContextModificationReqMsg(ueContextModifyReq);
12897    return ret;
12898 }
12899 /*****************************************************************i
12900 *
12901 * @brief Free memory allocated for UE Context Release Request
12902 *
12903 * @details
12904 *
12905 *    Function : FreeUeContextReleaseReq
12906 *
12907 *    Functionality:
12908 *         - Free memory allocated for UE Context Release Request
12909 *
12910 * @params[in] F1AP_PDU_t *f1apMsg
12911 * @return void
12912 *
12913 * *************************************************************/
12914 void FreeUeContextReleaseReq(F1AP_PDU_t *f1apMsg)
12915 {
12916    uint8_t ieIdx;
12917    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
12918
12919    if(f1apMsg)
12920    {
12921       if(f1apMsg->choice.initiatingMessage)
12922       {
12923          ueReleaseReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
12924          if(ueReleaseReq->protocolIEs.list.array)
12925          {
12926             for(ieIdx=0 ; ieIdx<ueReleaseReq->protocolIEs.list.count; ieIdx++)
12927             {
12928                DU_FREE(ueReleaseReq->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseRequest_t));
12929             }
12930             DU_FREE(ueReleaseReq->protocolIEs.list.array, ueReleaseReq->protocolIEs.list.size);
12931          }
12932          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
12933       }
12934       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12935    }
12936
12937 }
12938 /*****************************************************************i
12939 *
12940 * @brief Build and Send UE Context Release Request
12941 *
12942 * @details
12943 *
12944 *    Function : BuildAndSendUeContextReleaseReq
12945 *
12946 *    Functionality:
12947 *         - Build and Send UE Context Release Request
12948 *
12949 * @params[in]
12950 * @return ROK     - success
12951 *         RFAILED - failure
12952 *
12953 * *************************************************************/
12954 uint8_t BuildAndSendUeContextReleaseReq(uint16_t cellId, uint8_t ueIdx)
12955 {
12956    bool memAllocFail = false;
12957    uint8_t ieIdx =0;
12958    uint8_t ret = RFAILED;
12959    uint16_t cellIdx =0;
12960    uint16_t crnti = 0;
12961    uint8_t  elementCnt = 0;
12962    uint32_t  gnbCuUeF1apId =0;   /* gNB-CU UE F1AP Id */
12963    uint32_t  gnbDuUeF1apId =0;   /* gNB-DU UE F1AP Id */
12964    asn_enc_rval_t encRetVal;
12965    F1AP_PDU_t *f1apMsg = NULLP;
12966    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
12967
12968    DU_LOG("\nINFO  --> Building the UE Context Release Request");
12969    do
12970    {
12971       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12972       if(f1apMsg == NULLP)
12973       {
12974          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for f1apMsg");
12975          break;
12976       }
12977
12978       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
12979       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
12980       if(f1apMsg->choice.initiatingMessage == NULLP)
12981       {
12982          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for\
12983          initiatingMessage");
12984          break;
12985       }
12986       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextReleaseRequest;
12987       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
12988       f1apMsg->choice.initiatingMessage->value.present = \
12989       InitiatingMessage__value_PR_UEContextReleaseRequest;
12990
12991       ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
12992
12993       elementCnt = 2;
12994
12995       ueReleaseReq->protocolIEs.list.count = elementCnt;
12996       ueReleaseReq->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseRequest_t *);
12997
12998       /* Initialize the F1Setup members */
12999       DU_ALLOC(ueReleaseReq->protocolIEs.list.array,ueReleaseReq->protocolIEs.list.size);
13000       if(ueReleaseReq->protocolIEs.list.array == NULLP)
13001       {
13002          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE array");
13003          break;
13004       }
13005       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
13006       {
13007          DU_ALLOC(ueReleaseReq->protocolIEs.list.array[ieIdx],\
13008                sizeof(UEContextReleaseRequest_t));
13009          if(ueReleaseReq->protocolIEs.list.array[ieIdx] == NULLP)
13010          {
13011             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE elements");
13012             memAllocFail = true;
13013             break;
13014          }
13015       }
13016       if(memAllocFail == true)
13017          break;
13018
13019       /* Fetching Ue Cb Info*/
13020       GET_CELL_IDX(cellId, cellIdx);
13021       if(duCb.actvCellLst[cellIdx] == NULLP)
13022       {
13023          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): CellId[%d] does not exist", cellId);
13024          break;
13025       }
13026       else
13027       {
13028          GET_CRNTI(crnti, ueIdx);
13029          if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].crnti != crnti)
13030          {
13031             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): crnti[%d] does not exist", crnti);
13032             break;
13033          }
13034          gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
13035          gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
13036       }
13037
13038       ieIdx=0;
13039       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
13040       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13041       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present = \
13042       UEContextReleaseRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
13043       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
13044
13045       ieIdx++;
13046       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
13047       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13048       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present =\
13049       UEContextReleaseRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
13050       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
13051
13052       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13053
13054       /* Encode the F1SetupRequest type as APER */
13055       memset(encBuf, 0, ENC_BUF_MAX_LEN);
13056       encBufSize = 0;
13057       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
13058       /* Encode results */
13059       if(encRetVal.encoded == ENCODE_FAIL)
13060       {
13061          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseRequest structure (at %s)\n",\
13062                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13063          break;
13064       }
13065       else
13066       {
13067          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseRequest\n");
13068          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
13069          {
13070             printf("%x",encBuf[ieIdx]);
13071          }
13072       }
13073
13074       /* Sending msg */
13075       if(sendF1APMsg() != ROK)
13076       {
13077          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Request failed");
13078          break;
13079       }
13080       ret = ROK;
13081       break;
13082    }while(true);
13083
13084    FreeUeContextReleaseReq(f1apMsg);
13085    return ret;
13086 }
13087 /*****************************************************************i
13088  *
13089  * @brief Free memory allocated for UE Context Release Complete
13090  *
13091  * @details
13092  *
13093  *    Function : FreeUeContextReleaseComplete
13094  *
13095  *    Functionality:
13096  *         - Free memory allocated for UE Context Release Complete
13097  *
13098  * @params[in] F1AP_PDU_t *f1apMsg
13099  * @return void
13100  *
13101  * *************************************************************/
13102 void FreeUeContextReleaseComplete(F1AP_PDU_t *f1apMsg)
13103 {
13104    uint8_t ieIdx;
13105    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
13106
13107    if(f1apMsg)
13108    {
13109       if(f1apMsg->choice.successfulOutcome)
13110       {
13111          ueReleaseComplete =&f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
13112          if(ueReleaseComplete->protocolIEs.list.array)
13113          {
13114             for(ieIdx=0 ; ieIdx<ueReleaseComplete->protocolIEs.list.count; ieIdx++)
13115             {
13116                DU_FREE(ueReleaseComplete->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseComplete_t));
13117             }
13118             DU_FREE(ueReleaseComplete->protocolIEs.list.array, ueReleaseComplete->protocolIEs.list.size);
13119          }
13120          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
13121       }
13122       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
13123    }
13124
13125 }
13126 /*****************************************************************i
13127  *
13128  * @brief Build and Send UE Context Release Complete
13129  *
13130  * @details
13131  *
13132  *    Function : BuildAndSendUeContextReleaseComplete
13133  *
13134  *    Functionality:
13135  *         - Build and Send UE Context Release Complete
13136  *
13137  * @params[in]  cellId,  gnbCuUeF1apId, gnbDuUeF1apId
13138  * @return ROK     - success
13139  *         RFAILED - failure
13140  *
13141  * *************************************************************/
13142 uint8_t BuildAndSendUeContextReleaseComplete(uint16_t cellId, uint32_t gnbCuUeF1apId, uint32_t gnbDuUeF1apId)
13143 {
13144    bool memAllocFail = false;
13145    uint8_t ieIdx =0, ret = RFAILED, elementCnt = 0;
13146    asn_enc_rval_t encRetVal;
13147    F1AP_PDU_t *f1apMsg = NULLP;
13148    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
13149
13150    DU_LOG("\nINFO  --> Building the UE Context Release Complete");
13151    do
13152    {
13153       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
13154       if(f1apMsg == NULLP)
13155       {
13156          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for f1apMsg");
13157          break;
13158       }
13159
13160       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
13161       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
13162       if(f1apMsg->choice.successfulOutcome == NULLP)
13163       {
13164          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for\
13165                successfulOutcome");
13166          break;
13167       }
13168       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextRelease;
13169       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
13170       f1apMsg->choice.successfulOutcome->value.present = \
13171       SuccessfulOutcome__value_PR_UEContextReleaseComplete;
13172
13173       ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
13174
13175       elementCnt = 2;
13176       ueReleaseComplete->protocolIEs.list.count = elementCnt;
13177       ueReleaseComplete->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseComplete_t *);
13178
13179       /* Initialize the UE Release Complete members */
13180       DU_ALLOC(ueReleaseComplete->protocolIEs.list.array,ueReleaseComplete->protocolIEs.list.size);
13181       if(ueReleaseComplete->protocolIEs.list.array == NULLP)
13182       {
13183          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE array");
13184          break;
13185       }
13186       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
13187       {
13188          DU_ALLOC(ueReleaseComplete->protocolIEs.list.array[ieIdx],\
13189                sizeof(UEContextReleaseComplete_t));
13190          if(ueReleaseComplete->protocolIEs.list.array[ieIdx] == NULLP)
13191          {
13192             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE\
13193             elements");
13194             memAllocFail = true;
13195             break;
13196          }
13197       }
13198       if(memAllocFail == true)
13199          break;
13200
13201
13202       ieIdx=0;
13203       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
13204       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13205       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present = \
13206       UEContextReleaseCompleteIEs__value_PR_GNB_CU_UE_F1AP_ID;
13207       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
13208
13209       ieIdx++;
13210       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
13211       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13212       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present =\
13213       UEContextReleaseCompleteIEs__value_PR_GNB_DU_UE_F1AP_ID;
13214       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
13215
13216       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13217
13218       /* Encode the F1SetupComplete type as APER */
13219       memset(encBuf, 0, ENC_BUF_MAX_LEN);
13220       encBufSize = 0;
13221       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
13222       /* Encode results */
13223       if(encRetVal.encoded == ENCODE_FAIL)
13224       {
13225          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseComplete structure (at %s)\n",\
13226                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13227          break;
13228       }
13229       else
13230       {
13231          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseComplete\n");
13232          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
13233          {
13234             printf("%x",encBuf[ieIdx]);
13235          }
13236       }
13237
13238       /* Sending msg */
13239       if(sendF1APMsg() != ROK)
13240       {
13241          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Complete failed");
13242          break;
13243       }
13244       ret = ROK;
13245       break;
13246    }while(true);
13247
13248    if(ret == ROK)
13249    {
13250       duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
13251       ret = duSendCellDeletReq(cellId);
13252       if(ret != ROK)
13253       {
13254          DU_LOG("\nERROR  -->  F1AP: BuildAndSendUeContextReleaseComplete(): Failed to process cell\
13255                Delete req for CellId");
13256       }
13257    }
13258    FreeUeContextReleaseComplete(f1apMsg);
13259    return ret;
13260
13261 }
13262
13263 /*******************************************************************
13264 *
13265 * @brief added free part for the memory allocated by aper_decoder
13266 *
13267 * @details
13268 *
13269 *    Function : freeAperDecodeUeContextReleaseCommand
13270 *
13271 *    Functionality: added free part for the memory allocated by aper_decoder
13272 *
13273 * @params[in] F1AP_PDU_t *f1apMsg
13274 * @return void
13275 *
13276 * ****************************************************************/
13277 void freeAperDecodeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
13278 {
13279    uint8_t ieIdx=0;
13280    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
13281
13282    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
13283
13284    if(ueContextReleaseCommand->protocolIEs.list.array)
13285    {
13286       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
13287       {
13288          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
13289          {
13290             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
13291             {
13292                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13293                   break;
13294                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13295                   break;
13296                case ProtocolIE_ID_id_Cause:
13297                   break;
13298                case ProtocolIE_ID_id_RRCContainer:
13299                {
13300                   if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
13301                   {
13302                      free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
13303                   }
13304                   break;
13305                }
13306                default :
13307                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
13308                        ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
13309                   break;
13310             }
13311          }
13312          free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]);
13313       }
13314       free(ueContextReleaseCommand->protocolIEs.list.array);
13315    }
13316 }
13317 /*******************************************************************
13318 *
13319 * @brief processing of UE Context Release Command
13320 *
13321 * @details
13322 *
13323 *    Function : procF1UeContextReleaseCommand
13324 *
13325 *    Functionality: processing of UE Context Release Command
13326 *
13327 * @params[in] F1AP_PDU_t *f1apMsg
13328 * @return void
13329 *
13330 * ****************************************************************/
13331 uint8_t procF1UeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
13332 {
13333    uint8_t  ieIdx=0, ret=ROK, ueIdx=0;
13334    uint16_t cellIdx =0;
13335    bool ueIdxFound;
13336    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0;
13337    DuUeCb   *duUeCb = NULLP;
13338    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
13339
13340    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
13341
13342    if(ueContextReleaseCommand->protocolIEs.list.array)
13343    {
13344       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
13345       {
13346          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
13347          {
13348             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
13349             {
13350                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13351                   {
13352                      gnbCuUeF1apId= ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13353                                     value.choice.GNB_CU_UE_F1AP_ID;
13354                      break;
13355                   }
13356
13357                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13358                   {
13359                      gnbDuUeF1apId = ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13360                                      value.choice.GNB_DU_UE_F1AP_ID;
13361                      break;
13362                   }
13363
13364                case ProtocolIE_ID_id_Cause:
13365                   {
13366                      break;
13367                   }
13368
13369                case ProtocolIE_ID_id_RRCContainer:
13370                   {
13371                      for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
13372                      {
13373                         for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
13374                         {
13375                            if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
13376                                  (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
13377                            {
13378                               duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
13379                               DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
13380                               if(duUeCb->f1UeDb)
13381                               {
13382                                  memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
13383                                  duUeCb->f1UeDb->actionType = UE_CTXT_RELEASE;
13384                                  duUeCb->f1UeDb->cellIdx = cellIdx;
13385                                  /* Filling Dl RRC Msg Info */
13386                                  DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
13387                                  if(!duUeCb->f1UeDb->dlRrcMsg)
13388                                  {
13389                                     DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
13390                                     Memory allocation failed ");
13391                                     ret = RFAILED;
13392                                  }
13393                                  else
13394                                  {
13395                                     duUeCb->f1UeDb->dlRrcMsgPres = true;
13396                                     memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
13397                                     ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
13398                                           &ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13399                                           value.choice.RRCContainer);
13400                                  }
13401
13402                               }
13403                               else
13404                               {
13405                                  DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
13406                                  Memory allocation failed ");
13407                                  ret = RFAILED;
13408
13409                               }
13410
13411                               ueIdxFound = true;
13412                               break;
13413                            }
13414                         }
13415                         if(ueIdxFound == true)
13416                         {
13417                            break;
13418                         }
13419                      }
13420                      if(!ueIdxFound)
13421                      {
13422                         DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
13423                         ret = RFAILED;
13424                      }
13425
13426
13427                      break;
13428                   }
13429                default :
13430                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
13431                         ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
13432                   break;
13433             }
13434          }
13435       }
13436    }
13437    if(ret != RFAILED)
13438    {
13439       duProcUeContextReleaseCommand(duUeCb);
13440    }
13441    freeAperDecodeUeContextReleaseCommand(f1apMsg);
13442    return ret;
13443 }
13444 /**************************************************************
13445  *
13446  * @brief Handles received F1AP message and sends back response
13447  *
13448  * @details
13449  *
13450  *    Function : F1APMsgHdlr
13451  *
13452  *    Functionality:
13453  *         - Decodes received F1AP control message
13454  *         - Prepares response message, encodes and sends to SCTP
13455  *
13456  * @params[in]
13457  * @return ROK     - success
13458  *         RFAILED - failure
13459  *
13460  * ****************************************************************/
13461 void F1APMsgHdlr(Buffer *mBuf)
13462 {
13463    int i =0;
13464    char *recvBuf =NULLP;
13465    MsgLen copyCnt =0;
13466    MsgLen recvBufLen =0;
13467    F1AP_PDU_t *f1apMsg =NULLP;
13468    asn_dec_rval_t rval; /* Decoder return value */
13469    F1AP_PDU_t f1apasnmsg ;
13470    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
13471    ODU_PRINT_MSG(mBuf, 0,0);
13472
13473    /* Copy mBuf into char array to decode it */
13474    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
13475    DU_ALLOC(recvBuf, (Size)recvBufLen);
13476
13477    if(recvBuf == NULLP)
13478    {
13479       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
13480       return;
13481    }
13482    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
13483    {
13484       DU_LOG("\nERROR   -->  F1AP : Failed while copying %d", copyCnt);
13485       return;
13486    }
13487
13488    printf("\nDEBUG   -->  F1AP : Received flat buffer to be decoded : ");
13489    for(i=0; i< recvBufLen; i++)
13490    {
13491       printf("%x",recvBuf[i]);
13492    }
13493
13494    /* Decoding flat buffer into F1AP messsage */
13495    f1apMsg = &f1apasnmsg;
13496    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
13497
13498    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
13499    DU_FREE(recvBuf, (Size)recvBufLen);
13500
13501    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
13502    {
13503       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
13504       return;
13505    }
13506    printf("\n");
13507    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13508
13509    switch(f1apMsg->present)
13510    {
13511       case F1AP_PDU_PR_successfulOutcome:
13512          {
13513             switch(f1apMsg->choice.successfulOutcome->value.present)
13514             {
13515                case SuccessfulOutcome__value_PR_ResetAcknowledge:
13516                   {
13517                      DU_LOG("\nINFO   -->  F1AP : F1ResetAcknowledge is received successfully ");
13518                      break;
13519                   }
13520                case SuccessfulOutcome__value_PR_F1SetupResponse:
13521                   {
13522 #ifndef ODU_TEST_STUB
13523                      procF1SetupRsp(f1apMsg);
13524 #endif
13525                      break;
13526                   }
13527
13528                case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
13529                   {
13530                      procF1GNBDUCfgUpdAck(f1apMsg);
13531                      break;
13532                   }
13533
13534                default:
13535                   {
13536                      DU_LOG("\nERROR  -->  F1AP : Invalid type of SuccessfulOutcome__value_PR_ResetAcknowledge [%d]",\
13537                            f1apMsg->choice.successfulOutcome->value.present);
13538                      return;
13539                   }
13540             }/* End of switch(successfulOutcome) */
13541             free(f1apMsg->choice.successfulOutcome);
13542             break;
13543          }
13544       case F1AP_PDU_PR_initiatingMessage:
13545          {
13546             switch(f1apMsg->choice.initiatingMessage->value.present)
13547             {
13548                case InitiatingMessage__value_PR_Reset:
13549                   {
13550                      procF1ResetReq(f1apMsg);
13551                      break;
13552                   }
13553                case InitiatingMessage__value_PR_DLRRCMessageTransfer:
13554                   {
13555                      procF1DlRrcMsgTrans(f1apMsg);
13556                      break;
13557                   }
13558                case InitiatingMessage__value_PR_UEContextSetupRequest:
13559                   {
13560                      procF1UeContextSetupReq(f1apMsg);
13561                      break;
13562                   }
13563                case InitiatingMessage__value_PR_UEContextModificationRequest:
13564                   {
13565                      procF1UeContextModificationReq(f1apMsg);
13566                      break;
13567                   }
13568                case InitiatingMessage__value_PR_UEContextReleaseCommand:
13569                   {
13570                       procF1UeContextReleaseCommand(f1apMsg);
13571                       break;
13572                   }
13573                default:
13574                   {
13575                      DU_LOG("\nERROR  -->  F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
13576                            f1apMsg->choice.initiatingMessage->value.present);
13577                      return;
13578                   }
13579             }/* End of switch(initiatingMessage) */
13580             free(f1apMsg->choice.initiatingMessage);
13581             break;
13582          }
13583
13584       default:
13585          {
13586             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
13587             return;
13588          }
13589          free(f1apMsg);
13590
13591    }/* End of switch(f1apMsg->present) */
13592
13593 } /* End of F1APMsgHdlr */
13594
13595 /**********************************************************************
13596   End of file
13597  **********************************************************************/