src/du_app/du_f1ap_msg_hdl.c

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   4 #                                                                              #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
   6 #   you may not use this file except in compliance with the License.           #
   7 #   You may obtain a copy of the License at                                    #
   8 #                                                                              #
   9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10 #                                                                              #
  11 #   Unless required by applicable law or agreed to in writing, software        #
  12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
  14 #   See the License for the specific language governing permissions and        #
  15 #   limitations under the License.                                             #
  16 ################################################################################
  17 *******************************************************************************/
  18
  19 /* This file contains F1AP message handler functions */
  20 #include "common_def.h"
  21 #include "lrg.h"
  22 #include "legtp.h"
  23 #include "lkw.x"
  24 #include "lrg.x"
  25 #include "F1AP-PDU.h"
  26 #include "du_app_mac_inf.h"
  27 #include "du_cfg.h"
  28 #include "du_app_rlc_inf.h"
  29 #include "du_mgr_main.h"
  30 #include "du_utils.h"
  31 #include "RAT-Type.h"
  32 #include "FeatureSetUplinkPerCC.h"
  33 #include "FeatureSetDownlinkPerCC.h"
  34 #include "FeatureSets.h"
  35 #include "UE-NR-Capability.h"
  36 #include "UE-CapabilityRAT-Container.h"
  37 #include "UE-CapabilityRAT-ContainerListRRC.h"
  38 #include "GNB-DU-System-Information.h"
  39 #include "CellGroupConfigRrc.h"
  40 #include "MAC-CellGroupConfig.h"
  41 #include "SchedulingRequestConfig.h"
  42 #include "SchedulingRequestToAddMod.h"
  43 #include "BSR-Config.h"
  44 #include "TAG-Config.h"
  45 #include "TAG.h"
  46 #include "PHR-Config.h"
  47 #include "RLC-Config.h"
  48 #include "UL-AM-RLC.h"
  49 #include "DL-AM-RLC.h"
  50 #include "LogicalChannelConfig.h"
  51 #include "RLC-BearerConfig.h"
  52 #include "PhysicalCellGroupConfig.h"
  53 #include "SpCellConfig.h"
  54 #include "TDD-UL-DL-ConfigDedicated.h"
  55 #include "ServingCellConfig.h"
  56 #include "ControlResourceSet.h"
  57 #include "SearchSpace.h"
  58 #include "PDCCH-Config.h"
  59 #include "PDSCH-TimeDomainResourceAllocation.h"
  60 #include "PDSCH-TimeDomainResourceAllocationList.h"
  61 #include "PDSCH-CodeBlockGroupTransmission.h"
  62 #include "PDSCH-ServingCellConfig.h"
  63 #include "DMRS-DownlinkConfig.h"
  64 #include "PDSCH-Config.h"
  65 #include "BWP-DownlinkDedicated.h"
  66 #include "PUSCH-TimeDomainResourceAllocation.h"
  67 #include "PUSCH-TimeDomainResourceAllocationList.h"
  68 #include "DMRS-UplinkConfig.h"
  69 #include "PUSCH-Config.h"
  70 #include "SRS-ResourceId.h"
  71 #include "SRS-Resource.h"
  72 #include "SRS-ResourceSet.h"
  73 #include "SRS-Config.h"
  74 #include "BWP-UplinkDedicated.h"
  75 #include "PUSCH-ServingCellConfig.h"
  76 #include "UplinkConfig.h"
  77 #include "DUtoCURRCContainer.h"
  78 #include "GBR-QoSFlowInformation.h"
  79 #include "QoSFlowLevelQoSParameters.h"
  80 #include "PUCCH-Config.h"
  81 #include "PUCCH-ResourceSet.h"
  82 #include "PUCCH-Resource.h"
  83 #include "PUCCH-PowerControl.h"
  84 #include "P0-PUCCH.h"
  85 #include "PUCCH-PathlossReferenceRS.h"
  86 #include "PUCCH-format0.h"
  87 #include "PUCCH-format1.h"
  88 #include "PUCCH-format2.h"
  89 #include "PUCCH-format3.h"
  90 #include "PUCCH-format4.h"
  91 #include "PUCCH-FormatConfig.h"
  92 #include "SchedulingRequestResourceConfig.h"
  93 #include<ProtocolIE-Field.h>
  94 #include "ProtocolExtensionField.h"
  95 #include "odu_common_codec.h"
  96 #include "du_mgr.h"
  97 #include "du_cell_mgr.h"
  98 #include "du_f1ap_msg_hdl.h"
  99 #include "DRBs-Setup-Item.h"
 100 #include "DLUPTNLInformation-ToBeSetup-List.h"
 101 #include "DLUPTNLInformation-ToBeSetup-Item.h"
 102 #include "UPTransportLayerInformation.h"
 103 #include "GTPTunnel.h"
 104
 105 #ifdef O1_ENABLE
 106 #include "ConfigInterface.h"
 107 extern StartupConfig g_cfg;
 108 #endif
 109
 110 DuCfgParams duCfgParam;
 111
 112 /************************************************************************
 113  *
 114  * @brief Converts enum values into actual value of Poll retransmit timer
 115  *
 116  * @details
 117  *
 118  *    Function : getPollPdu
 119  *
 120  *    Functionality: Converts enum values into actual value of poll
 121  *    retransmit timer
 122  *
 123  * @params[in] Enum value of pollPdu
 124  * @return Actual value of pollPdu
 125  *
 126  * **********************************************************************/
 127
 128 uint16_t getPollRetxTmr(uint8_t pollRetxTmrCfg)
 129 {
 130    uint16_t pollRetxTmr;
 131
 132    /* All values of poll retx timer are at interval of 5ms.
 133     * This is valid upto 250ms
 134     * Hence converting the enum value to actual value by multiplying it to 5
 135     */
 136    if(pollRetxTmrCfg <= T_PollRetransmit_ms250)
 137       pollRetxTmr = (pollRetxTmrCfg + 1) * 5;
 138    else
 139    {
 140       switch(pollRetxTmrCfg)
 141       {
 142          case T_PollRetransmit_ms300:
 143             pollRetxTmr = 300;
 144             break;
 145          case T_PollRetransmit_ms350:
 146             pollRetxTmr = 350;
 147             break;
 148          case T_PollRetransmit_ms400:
 149             pollRetxTmr = 400;
 150             break;
 151          case T_PollRetransmit_ms450:
 152             pollRetxTmr = 450;
 153             break;
 154          case T_PollRetransmit_ms500:
 155             pollRetxTmr = 500;
 156             break;
 157          case T_PollRetransmit_ms800:
 158             pollRetxTmr = 800;
 159             break;
 160          default:
 161             DU_LOG("\nERROR  -->  F1AP: Invalid value of Poll Retransmit timer");
 162             pollRetxTmr = 0;
 163       }
 164    }
 165    return pollRetxTmr;
 166 }
 167
 168 /*******************************************************************
 169  *
 170  * @brief Converts enum values into actual value of PollPdu
 171  *
 172  * @details
 173  *
 174  *    Function : getPollPdu
 175  *
 176  *    Functionality: Converts enum values into actual value of PollPdu
 177  *
 178  * @params[in] Enum value of pollPdu
 179  * @return Actual value of pollPdu
 180  *
 181  * ****************************************************************/
 182 int32_t getPollPdu(uint8_t pollPduCfg)
 183 {
 184    int32_t pollPdu;
 185    switch(pollPduCfg)
 186    {
 187       case PollPDU_p4:
 188          pollPdu = 4;
 189          break;
 190       case PollPDU_p8:
 191          pollPdu = 8;
 192          break;
 193       case PollPDU_p16:
 194          pollPdu = 16;
 195          break;
 196       case PollPDU_p32:
 197          pollPdu = 32;
 198          break;
 199       case PollPDU_p64:
 200          pollPdu = 64;
 201          break;
 202       case PollPDU_p128:
 203          pollPdu = 128;
 204          break;
 205       case PollPDU_p256:
 206          pollPdu = 256;
 207          break;
 208       case PollPDU_p512:
 209          pollPdu = 512;
 210          break;
 211       case PollPDU_p1024:
 212          pollPdu = 1024;
 213          break;
 214       case PollPDU_p2048:
 215          pollPdu = 2048;
 216          break;
 217       case PollPDU_p4096:
 218          pollPdu = 4096;
 219          break;
 220       case PollPDU_p6144:
 221          pollPdu = 6144;
 222          break;
 223       case PollPDU_p8192:
 224          pollPdu = 8192;
 225          break;
 226       case PollPDU_p12288:
 227          pollPdu = 12288;
 228          break;
 229       case PollPDU_p16384:
 230          pollPdu = 16384;
 231          break;
 232       case PollPDU_p20480:
 233          pollPdu = 20480;
 234          break;
 235       case PollPDU_p24576:
 236          pollPdu = 24576;
 237          break;
 238       case PollPDU_p28672:
 239          pollPdu = 28672;
 240          break;
 241       case PollPDU_p32768:
 242          pollPdu = 32768;
 243          break;
 244       case PollPDU_p40960:
 245          pollPdu = 40960;
 246          break;
 247       case PollPDU_p49152:
 248          pollPdu = 49152;
 249          break;
 250       case PollPDU_p57344:
 251          pollPdu = 57344;
 252          break;
 253       case PollPDU_p65536:
 254          pollPdu = 65536;
 255          break;
 256       case PollPDU_infinity:
 257          pollPdu = -1;
 258          break;
 259       default:
 260          DU_LOG("\nERROR  -->  F1AP: Invalid value of poll pdu");
 261          pollPdu = 0;
 262          break;
 263    }
 264    return pollPdu;
 265 }
 266
 267 /*******************************************************************
 268  *
 269  * @brief Converts enum values into actual value of poll bytes
 270  *
 271  * @details
 272  *
 273  *    Function : getPollByte
 274  *
 275  *    Functionality: Converts enum values into actual value of pollBytes
 276  *
 277  * @params[in] Enum value
 278  * @return Actual value
 279  *
 280  * ****************************************************************/
 281 int32_t getPollByte(uint16_t pollBytesCfg)
 282 {
 283    int32_t pollBytes;
 284    switch(pollBytesCfg)
 285    {
 286       case PollByte_kB1:
 287          pollBytes = 1000;
 288          break;
 289       case PollByte_kB2:
 290          pollBytes = 2000;
 291          break;
 292       case PollByte_kB5:
 293          pollBytes = 5000;
 294          break;
 295       case PollByte_kB8:
 296          pollBytes = 8000;
 297          break;
 298       case PollByte_kB10:
 299          pollBytes = 10000;
 300          break;
 301       case PollByte_kB15:
 302          pollBytes = 15000;
 303          break;
 304       case PollByte_kB25:
 305          pollBytes = 25000;
 306          break;
 307       case PollByte_kB50:
 308          pollBytes = 50000;
 309          break;
 310       case PollByte_kB75:
 311          pollBytes = 75000;
 312          break;
 313       case PollByte_kB100:
 314          pollBytes = 100000;
 315          break;
 316       case PollByte_kB125:
 317          pollBytes = 125000;
 318          break;
 319       case PollByte_kB250:
 320          pollBytes = 250000;
 321          break;
 322       case PollByte_kB375:
 323          pollBytes = 375000;
 324          break;
 325       case PollByte_kB500:
 326          pollBytes = 500000;
 327          break;
 328       case PollByte_kB750:
 329          pollBytes = 750000;
 330          break;
 331       case PollByte_kB1000:
 332          pollBytes = 1000000;
 333          break;
 334       case PollByte_kB1250:
 335          pollBytes = 1250000;
 336          break;
 337       case PollByte_kB1500:
 338          pollBytes = 1500000;
 339          break;
 340       case PollByte_kB2000:
 341          pollBytes = 2000000;
 342          break;
 343       case PollByte_kB3000:
 344          pollBytes = 3000000;
 345          break;
 346       case PollByte_kB4000:
 347          pollBytes = 4000000;
 348          break;
 349       case PollByte_kB4500:
 350          pollBytes = 4500000;
 351          break;
 352       case PollByte_kB5000:
 353          pollBytes = 5000000;
 354          break;
 355       case PollByte_kB5500:
 356          pollBytes = 5500000;
 357          break;
 358       case PollByte_kB6000:
 359          pollBytes = 6000000;
 360          break;
 361       case PollByte_kB6500:
 362          pollBytes = 6500000;
 363          break;
 364       case PollByte_kB7000:
 365          pollBytes = 7000000;
 366          break;
 367       case PollByte_kB7500:
 368          pollBytes = 7500000;
 369          break;
 370       case PollByte_mB8:
 371          pollBytes = 8000000;
 372          break;
 373       case PollByte_mB9:
 374          pollBytes = 9000000;
 375          break;
 376       case PollByte_mB10:
 377          pollBytes = 10000000;
 378          break;
 379       case PollByte_mB11:
 380          pollBytes = 11000000;
 381          break;
 382       case PollByte_mB12:
 383          pollBytes = 12000000;
 384          break;
 385       case PollByte_mB13:
 386          pollBytes = 13000000;
 387          break;
 388       case PollByte_mB14:
 389          pollBytes = 14000000;
 390          break;
 391       case PollByte_mB15:
 392          pollBytes = 15000000;
 393          break;
 394       case PollByte_mB16:
 395          pollBytes = 16000000;
 396          break;
 397       case PollByte_mB17:
 398          pollBytes = 17000000;
 399          break;
 400       case PollByte_mB18:
 401          pollBytes = 18000000;
 402          break;
 403       case PollByte_mB20:
 404          pollBytes = 20000000;
 405          break;
 406       case PollByte_mB25:
 407          pollBytes = 25000000;
 408          break;
 409       case PollByte_mB30:
 410          pollBytes = 30000000;
 411          break;
 412       case PollByte_mB40:
 413          pollBytes = 40000000;
 414          break;
 415       case PollByte_infinity:
 416          pollBytes = -1;
 417          break;
 418       default:
 419          DU_LOG("\nERROR  -->  F1AP: Invalid value of poll bytes");
 420          pollBytes = 0;
 421    }
 422    return pollBytes;
 423 }
 424
 425 /*******************************************************************
 426  *
 427  * @brief Converts enum values into actual value of maxRetx
 428  *
 429  * @details
 430  *
 431  *    Function : getMaxRetx
 432  *
 433  *    Functionality: Converts enum values into actual value of maxRetx
 434  *
 435  * @params[in] Enum value
 436  * @return Actual value
 437  *
 438  * ****************************************************************/
 439 uint8_t getMaxRetx(uint8_t maxRetxCfg)
 440 {
 441    uint8_t maxRetx;
 442    switch(maxRetxCfg)
 443    {
 444       case UL_AM_RLC__maxRetxThreshold_t1:
 445          maxRetx = 1;
 446          break;
 447       case UL_AM_RLC__maxRetxThreshold_t2:
 448          maxRetx = 2;
 449          break;
 450       case UL_AM_RLC__maxRetxThreshold_t3:
 451          maxRetx = 3;
 452          break;
 453       case UL_AM_RLC__maxRetxThreshold_t4:
 454          maxRetx = 4;
 455          break;
 456       case UL_AM_RLC__maxRetxThreshold_t6:
 457          maxRetx = 6;
 458          break;
 459       case UL_AM_RLC__maxRetxThreshold_t8:
 460          maxRetx = 8;
 461          break;
 462       case UL_AM_RLC__maxRetxThreshold_t16:
 463          maxRetx = 16;
 464          break;
 465       case UL_AM_RLC__maxRetxThreshold_t32:
 466          maxRetx = 32;
 467          break;
 468       default:
 469          DU_LOG("\nERROR  -->  F1AP: Invalid configuration for Max retransmission threshold");
 470          maxRetx = 0;
 471    }
 472    return maxRetx;
 473 }
 474
 475 /*******************************************************************
 476  * @brief Converts enum values into actual value of reassembly timer
 477  *
 478  * @details
 479  *
 480  *    Function : getReAsmblTmr
 481  *
 482  *    Functionality: Converts enum values into actual value of reassembly
 483  *    timer
 484  *
 485  * @params[in] Enum value of reassembly timer
 486  * @return Actual value of reassembly timer
 487  *
 488  * **********************************************************************/
 489
 490 int8_t getReAsmblTmr(uint8_t reAsmblTmrCfg)
 491 {
 492    int8_t reAsmblTmr = 0;
 493
 494    if(reAsmblTmrCfg == T_Reassembly_ms0)
 495    {
 496       reAsmblTmr = 0;
 497    }
 498    else if(reAsmblTmrCfg >= T_Reassembly_ms5 || reAsmblTmrCfg <= T_Reassembly_ms100)
 499    {
 500      /* All values of re assembly timer are at interval of 5ms.
 501       * This is valid upto 100ms
 502       * Hence converting the enum value to actual value by multiplying it to 5
 503       */
 504       reAsmblTmr = reAsmblTmrCfg * 5;
 505    }
 506    else if(reAsmblTmrCfg >= T_Reassembly_ms110 || reAsmblTmrCfg <= T_Reassembly_ms200)
 507    {
 508      /* All values of re assembly timer are at interval of 10ms.
 509       * This is valid upto 200ms
 510       * since enum value starts from 20 for 100ms, subtracting 10 and
 511       * converting the enum value to actual value by multiplying it to 10
 512       */
 513       reAsmblTmr = ((reAsmblTmrCfg-10) * 10);
 514    }
 515    else
 516    {
 517       DU_LOG("\nERROR  -->  F1AP : Invalid value of Re Assembly timer %d", reAsmblTmrCfg);
 518       reAsmblTmr = -1;
 519    }
 520    return reAsmblTmr;
 521 }
 522
 523 /************************************************************************
 524  *
 525  * @brief Converts enum values into actual value of status prohibit timer
 526  *
 527  * @details
 528  *
 529  *    Function : getStatProhTmr
 530  *
 531  *    Functionality: Converts enum values into actual value of status prohibit
 532  *    timer
 533  *
 534  * @params[in] Enum value of status prohibit timer
 535  * @return Actual value of status prohibit timer
 536  *
 537  * **********************************************************************/
 538
 539 int16_t getStatProhTmr(uint8_t statProhTmrCfg)
 540 {
 541    int16_t statProhTmr =0;
 542
 543    if(statProhTmrCfg == T_StatusProhibit_ms0)
 544    {
 545       statProhTmr = 0;
 546    }
 547    else if(statProhTmrCfg >= T_StatusProhibit_ms5 || statProhTmrCfg <= T_StatusProhibit_ms250)
 548    {
 549       /* All values of re assembly timer are at interval of 5ms.
 550        * This is valid upto 250ms
 551        * Hence converting the enum value to actual value by multiplying it to 5
 552        */
 553       statProhTmr = statProhTmrCfg * 5;
 554    }
 555    else
 556    {
 557       switch(statProhTmrCfg)
 558       {
 559          case T_StatusProhibit_ms300:
 560             statProhTmr = 300;
 561             break;
 562          case T_StatusProhibit_ms350:
 563             statProhTmr = 350;
 564             break;
 565          case T_StatusProhibit_ms400:
 566             statProhTmr = 400;
 567             break;
 568          case T_StatusProhibit_ms450:
 569             statProhTmr = 450;
 570             break;
 571          case T_StatusProhibit_ms500:
 572             statProhTmr = 500;
 573             break;
 574          case T_StatusProhibit_ms800:
 575             statProhTmr = 800;
 576             break;
 577          case T_StatusProhibit_ms1000:
 578             statProhTmr = 1000;
 579             break;
 580          case T_StatusProhibit_ms1200:
 581             statProhTmr = 1200;
 582             break;
 583          case T_StatusProhibit_ms1600:
 584             statProhTmr = 1600;
 585             break;
 586          case T_StatusProhibit_ms2000:
 587             statProhTmr = 2000;
 588             break;
 589          case T_StatusProhibit_ms2400:
 590             statProhTmr = 2400;
 591             break;
 592          default:
 593             DU_LOG("\nInvalid value of Status Prohibit timer %d", statProhTmrCfg);
 594             statProhTmr = -1;
 595             break;
 596       }
 597    }
 598    return statProhTmr;
 599 }
 600
 601 /*******************************************************************
 602 *
 603 * @brief Adding F1AP pdu to reserved pdu list
 604 *
 605 * @details
 606 *
 607 *    Function : addToReservedF1apPduList
 608 *
 609 *    Functionality: Adding F1AP pdu to reserved pdu list.
 610 *     These pdu are awaiting aknowledgment from CU
 611 *
 612 * @params[in] uint8_t transId, F1AP_PDU_t *f1apMsg
 613 *
 614 * @return ROK - success
 615 *         RFAILED - failure
 616 *
 617 * ****************************************************************/
 618
 619 void addToReservedF1apPduList(uint8_t transId, F1AP_PDU_t *f1apPdu)
 620 {
 621    CmLList         *node = NULLP;
 622    ReservedF1apPduInfo *pduInfo = NULLP;
 623    DU_ALLOC(pduInfo, sizeof(ReservedF1apPduInfo));
 624    if(pduInfo)
 625    {
 626       DU_ALLOC(node, sizeof(CmLList));
 627       if(node)
 628       {
 629          pduInfo->transId = transId;
 630          pduInfo->f1apMsg = (void*) f1apPdu;
 631
 632          node->node = (PTR)pduInfo;
 633          cmLListAdd2Tail(&duCb.reservedF1apPduList, node);
 634       }
 635    }
 636 }
 637
 638 /*******************************************************************
 639 *
 640 * @brief searching for F1AP pdu from ReservedF1apPduList
 641 *
 642 * @details
 643 *
 644 *    Function : searchFromReservedF1apPduList
 645 *
 646 *    Functionality: searching for F1AP pdu information
 647 *
 648 * @params[in] uint8_t transId
 649 *
 650 * @return pointer to F1AP_PDU_t
 651 *
 652 * ****************************************************************/
 653
 654 CmLList *searchFromReservedF1apPduList(uint8_t transId)
 655 {
 656    CmLList         *node;
 657    ReservedF1apPduInfo *f1apPdu;
 658    if(duCb.reservedF1apPduList.count)
 659    {
 660       CM_LLIST_FIRST_NODE(&duCb.reservedF1apPduList, node);
 661       while(node)
 662       {
 663          f1apPdu = (ReservedF1apPduInfo*)node->node;
 664          if(f1apPdu->transId == transId)
 665          {
 666             return node;
 667          }
 668          node = node->next;
 669       }
 670    }
 671    return NULL;
 672 }
 673
 674 /*******************************************************************
 675 *
 676 * @brief deleting F1AP pdu information from ReservedF1apPduList
 677 *
 678 * @details
 679 *
 680 *    Function : deleteFromReservedF1apPduList
 681 *
 682 *    Functionality: deleting pdu information from ReservedF1apPduList
 683 *
 684 * @params[in] CmLList *node
 685 *
 686 * @return void
 687 *
 688 * ****************************************************************/
 689
 690 void deleteFromReservedF1apPduList(CmLList *node)
 691 {
 692    ReservedF1apPduInfo *f1apPdu;
 693
 694    if(node != NULL)
 695    {
 696       f1apPdu = (ReservedF1apPduInfo *)node->node;
 697       cmLListDelFrm(&duCb.reservedF1apPduList, node);
 698       DU_FREE(f1apPdu, sizeof(ReservedF1apPduInfo));
 699       DU_FREE(node, sizeof(CmLList));
 700       node = NULL;
 701    }
 702 }
 703
 704 /*******************************************************************
 705  *
 706  * @brief Builds Uplink Info for NR
 707  *
 708  * @details
 709  *
 710  *    Function : BuildULNRInfo
 711  *
 712  *    Functionality: Building NR Uplink Info
 713  *
 714  * @params[in] NRFreqInfo_t *ulnrfreq
 715  * @return ROK     - success
 716  *         RFAILED - failure
 717  *
 718  * ****************************************************************/
 719 uint8_t BuildULNRInfo(NRFreqInfo_t *ulnrfreq)
 720 {
 721    uint8_t idx=0;
 722    ulnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 723                        fdd.ulNrFreqInfo.nrArfcn;
 724    ulnrfreq->freqBandListNr.list.count = 1;
 725    ulnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 726    DU_ALLOC(ulnrfreq->freqBandListNr.list.array,ulnrfreq->freqBandListNr.list.size);
 727    if(ulnrfreq->freqBandListNr.list.array == NULLP)
 728    {
 729       return RFAILED;
 730    }
 731    for(idx=0;idx<ulnrfreq->freqBandListNr.list.count;idx++)
 732    {
 733       DU_ALLOC(ulnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 734       if(ulnrfreq->freqBandListNr.list.array[idx] == NULLP)
 735       {
 736          return RFAILED;
 737       }
 738    }
 739    ulnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 740                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
 741                                                                  freqBand[0].nrFreqBand;
 742    ulnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 743    return ROK;
 744 }
 745 /*******************************************************************
 746  *
 747  * @brief Builds Downlink NR Info
 748  *
 749  * @details
 750  *
 751  *    Function : BuildDLNRInfo
 752  *
 753  *    Functionality: Building Downlink NR Info
 754  *
 755  * @params[in] NRFreqInfo_t *dlnrfreq
 756  * @return ROK     - success
 757  *         RFAILED - failure
 758  *
 759  * ****************************************************************/
 760 uint8_t BuildDLNRInfo(NRFreqInfo_t *dlnrfreq)
 761 {
 762    uint8_t idx=0;
 763    dlnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 764                        fdd.dlNrFreqInfo.nrArfcn;
 765    dlnrfreq->freqBandListNr.list.count = 1;
 766    dlnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 767    DU_ALLOC(dlnrfreq->freqBandListNr.list.array,dlnrfreq->freqBandListNr.list.size);
 768    if(dlnrfreq->freqBandListNr.list.array == NULLP)
 769    {
 770       return RFAILED;
 771    }
 772    for(idx=0;idx< dlnrfreq->freqBandListNr.list.count;idx++)
 773    {
 774       DU_ALLOC(dlnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 775       if(dlnrfreq->freqBandListNr.list.array[idx] == NULLP)
 776       {
 777          return RFAILED;
 778       }
 779    }
 780    dlnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 781                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
 782                                                                  freqBand[0].nrFreqBand;
 783    dlnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 784
 785    return ROK;
 786 }
 787
 788 /*******************************************************************
 789  *
 790  * @brief Builds NRCell ID
 791  *
 792  * @details
 793  *
 794  *    Function : BuildNrCellId
 795  *
 796  *    Functionality: Building the NR Cell ID
 797  *
 798  * @params[in] BIT_STRING_t *nrcell
 799  * @return ROK     - success
 800  *         RFAILED - failure
 801  *
 802  * ****************************************************************/
 803
 804 S16 BuildNrCellId(BIT_STRING_t *nrcell)
 805 {
 806    memset(nrcell->buf, 0, nrcell->size);
 807    nrcell->buf[4]   = 16;
 808    nrcell->bits_unused = 4;
 809    return ROK;
 810 }
 811
 812 /*******************************************************************
 813  *
 814  * @brief Builds Nrcgi
 815  *
 816  * @details
 817  *
 818  *    Function : BuildNrcgi
 819  *
 820  *    Functionality: Building the PLMN ID and NR Cell id
 821  *
 822  * @params[in] NRCGI_t *nrcgi
 823  * @return ROK     - success
 824  *         RFAILED - failure
 825  *
 826  * ****************************************************************/
 827 uint8_t BuildNrcgi(NRCGI_t *nrcgi)
 828 {
 829    uint8_t ret;
 830    uint8_t byteSize = 5;
 831    /* Allocate Buffer Memory */
 832    nrcgi->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 833    DU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
 834    if(nrcgi->pLMN_Identity.buf == NULLP)
 835    {
 836       return RFAILED;
 837    }
 838    ret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 839          nrcgi->pLMN_Identity.buf); // Building PLMN function
 840    if(ret != ROK)
 841    {
 842       return RFAILED;
 843    }
 844    /*nrCellIdentity*/
 845    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
 846    DU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
 847    if(nrcgi->nRCellIdentity.buf == NULLP)
 848    {
 849       return RFAILED;
 850    }
 851    BuildNrCellId(&nrcgi->nRCellIdentity);
 852
 853    return ROK;
 854 }
 855 /*******************************************************************
 856  *
 857  * @brief Builds FiveGStac
 858  *
 859  * @details
 860  *
 861  *    Function : BuildFiveGSTac
 862  *
 863  *    Functionality: Building the FiveGSTac
 864  *
 865  * @params[in] OCTET_STRING_t *fivegsTac
 866  * @return ROK     - success
 867  *         RFAILED - failure
 868  *
 869  * ****************************************************************/
 870 uint8_t BuildFiveGSTac(Served_Cell_Information_t *servcell)
 871 {
 872    DU_ALLOC(servcell->fiveGS_TAC,sizeof(FiveGS_TAC_t));
 873    if(servcell->fiveGS_TAC == NULLP)
 874    {
 875       return RFAILED;
 876    }
 877    servcell->fiveGS_TAC->size = 3 * sizeof(uint8_t);
 878    DU_ALLOC(servcell->fiveGS_TAC->buf,\
 879          sizeof(servcell->fiveGS_TAC->size));
 880    if(servcell->fiveGS_TAC->buf == NULLP)
 881    {
 882       return RFAILED;
 883    }
 884    servcell->fiveGS_TAC->buf[0] = 0;
 885    servcell->fiveGS_TAC->buf[1] = 0;
 886    servcell->fiveGS_TAC->buf[2] = duCfgParam.srvdCellLst[0].duCellInfo.tac;
 887    return ROK;
 888 }
 889 /*******************************************************************
 890  *
 891  * @brief Builds NR Mode
 892  *
 893  * @details
 894  *
 895  *    Function : BuildNrMode
 896  *
 897  *    Functionality: Building the NR Mode
 898  *
 899  * @params[in] NR_Mode_Info_t *fdd
 900  * @return ROK     - success
 901  *         RFAILED - failure
 902  *
 903  * ****************************************************************/
 904 uint8_t BuildNrMode(NR_Mode_Info_t *mode)
 905 {
 906    uint8_t BuildDLNRInforet=0;
 907    uint8_t BuildULNRInforet=0;
 908    /* FDD Mode */
 909    mode->present = NR_Mode_Info_PR_fDD;
 910    if(mode->present == NR_Mode_Info_PR_fDD)
 911    {
 912       DU_ALLOC(mode->choice.fDD,sizeof(FDD_Info_t));
 913       if(mode->choice.fDD == NULLP)
 914       {
 915          return RFAILED;
 916       }
 917       BuildULNRInforet = BuildULNRInfo(&mode->choice.fDD->uL_NRFreqInfo);
 918       if(BuildULNRInforet != ROK)
 919       {
 920          return RFAILED;
 921       }
 922       BuildDLNRInforet = BuildDLNRInfo(&mode->choice.fDD->dL_NRFreqInfo);
 923       if(BuildDLNRInforet != ROK)
 924       {
 925          return RFAILED;
 926       }
 927    }
 928    mode->choice.fDD->uL_Transmission_Bandwidth.nRSCS = \
 929                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 930                                                        f1Mode.mode.fdd.ulTxBw.nrScs;
 931    mode->choice.fDD->uL_Transmission_Bandwidth.nRNRB = \
 932                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 933                                                        f1Mode.mode.fdd.ulTxBw.nrb;
 934    mode->choice.fDD->dL_Transmission_Bandwidth.nRSCS = \
 935                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 936                                                        f1Mode.mode.fdd.dlTxBw.nrScs;
 937    mode->choice.fDD->dL_Transmission_Bandwidth.nRNRB = \
 938                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 939                                                        f1Mode.mode.fdd.dlTxBw.nrb;
 940    return ROK;
 941 }
 942 /*******************************************************************
 943  *
 944  * @brief Builds IE Extensions for Served PLMNs
 945  *
 946  * @details
 947  *
 948  *    Function : BuildExtensions
 949  *
 950  *    Functionality: Building the IE Extensions
 951  *
 952  * @params[in] struct ProtocolExtensionContainer_4624P3 *buildextend
 953  * @return ROK     - success
 954  *         RFAILED - failure
 955  *
 956  * ****************************************************************/
 957 uint8_t BuildExtensions(ProtocolExtensionContainer_4624P3_t **ieExtend)
 958 {
 959    uint8_t idx;
 960    uint8_t plmnidx;
 961    uint8_t extensionCnt=1;
 962    uint8_t sliceId=0;
 963    uint8_t sdId;
 964    DU_ALLOC(*ieExtend,sizeof(ProtocolExtensionContainer_4624P3_t));
 965    if((*ieExtend) == NULLP)
 966    {
 967       return RFAILED;
 968    }
 969    (*ieExtend)->list.count = extensionCnt;
 970    (*ieExtend)->list.size = \
 971                             extensionCnt * sizeof(ServedPLMNs_ItemExtIEs_t *);
 972    DU_ALLOC((*ieExtend)->list.array,(*ieExtend)->list.size);
 973    if((*ieExtend)->list.array == NULLP)
 974    {
 975       return RFAILED;
 976    }
 977    for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
 978    {
 979       DU_ALLOC((*ieExtend)->list.array[plmnidx],\
 980             sizeof(ServedPLMNs_ItemExtIEs_t));
 981       if((*ieExtend)->list.array[plmnidx] == NULLP)
 982       {
 983          return RFAILED;
 984       }
 985    }
 986    idx = 0;
 987    (*ieExtend)->list.array[idx]->id = ProtocolIE_ID_id_TAISliceSupportList;
 988    (*ieExtend)->list.array[idx]->criticality = Criticality_ignore;
 989    (*ieExtend)->list.array[idx]->extensionValue.present = \
 990                                                           ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
 991    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 992       list.count = 1;
 993    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 994       list.size = sizeof(SliceSupportItem_t *);
 995    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 996          list.array,sizeof(SliceSupportItem_t *));
 997    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 998          list.array == NULLP)
 999    {
1000       return RFAILED;
1001    }
1002    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1003          list.array[sliceId],sizeof(SliceSupportItem_t));
1004    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1005          list.array[sliceId] == NULLP)
1006    {
1007       return RFAILED;
1008    }
1009    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1010       list.array[sliceId]->sNSSAI.sST.size = sizeof(uint8_t);
1011    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
1012          .list.array[sliceId]->sNSSAI.sST.buf,(*ieExtend)->list.array[idx]->\
1013          extensionValue.choice.SliceSupportList.\
1014          list.array[sliceId]->sNSSAI.sST.size);
1015    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
1016          .list.array[sliceId]->sNSSAI.sST.buf == NULLP)
1017    {
1018       return RFAILED;
1019    }
1020    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1021       list.array[sliceId]->sNSSAI.sST.buf[0] = 3;
1022    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1023          list.array[sliceId]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1024    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1025          list.array[sliceId]->sNSSAI.sD == NULLP)
1026    {
1027       return RFAILED;
1028    }
1029    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1030       list.array[sliceId]->sNSSAI.sD->size = 3*sizeof(uint8_t);
1031    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1032          list.array[sliceId]->sNSSAI.sD->buf,(*ieExtend)->list.array[idx]->extensionValue.choice.\
1033          SliceSupportList.list.array[sliceId]->sNSSAI.sD->size);
1034    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1035          list.array[sliceId]->sNSSAI.sD->buf == NULLP)
1036    {
1037       return RFAILED;
1038    }
1039    sdId = 0;
1040    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1041       list.array[sliceId]->sNSSAI.sD->buf[sdId] = 3;
1042    sdId++;
1043    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1044       list.array[sliceId]->sNSSAI.sD->buf[sdId] = 6;
1045    sdId++;
1046    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1047       list.array[sliceId]->sNSSAI.sD->buf[sdId] = 9;
1048    return ROK;
1049 }
1050 /*******************************************************************
1051  *
1052  * @brief Builds Served PLMN
1053  *
1054  * @details
1055  *
1056  *    Function : BuildServedPlmn
1057  *
1058  *    Functionality: Building the Served PLMN
1059  *
1060  * @params[in] GNB_DU_Served_Cells_Item_t *srvCellItem
1061  * @return ROK     - success
1062  *         RFAILED - failure
1063  *
1064  * ****************************************************************/
1065 uint8_t  BuildServedPlmn(ServedPLMNs_List_t *srvplmn)
1066 {
1067    uint8_t  plmnidx;
1068    uint8_t  servPlmnCnt=1;
1069    uint8_t buildPlmnIdret=0;
1070    uint8_t BuildExtensionsret=0;
1071    srvplmn->list.count = servPlmnCnt;
1072    srvplmn->list.size = \
1073                         servPlmnCnt*sizeof(ServedPLMNs_Item_t *);
1074    DU_ALLOC(srvplmn->list.array,srvplmn->list.size);
1075    if(srvplmn->list.array == NULLP)
1076    {
1077       return RFAILED;
1078    }
1079    for(plmnidx=0; plmnidx<servPlmnCnt; plmnidx++)
1080    {
1081       DU_ALLOC(srvplmn->list.array[plmnidx],\
1082             sizeof(ServedPLMNs_Item_t));
1083       if(srvplmn->list.array[plmnidx] == NULLP)
1084       {
1085          return RFAILED;
1086       }
1087    }
1088    srvplmn->list.array[0]->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
1089    DU_ALLOC(srvplmn->list.array[0]->pLMN_Identity.buf, srvplmn->list.array[0]->pLMN_Identity.size);
1090    buildPlmnIdret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
1091          srvplmn->list.array[0]->pLMN_Identity.buf);
1092    if(buildPlmnIdret!= ROK)
1093    {
1094       return RFAILED;
1095    }
1096    BuildExtensionsret = BuildExtensions(&srvplmn->list.array[0]->iE_Extensions);
1097    if(BuildExtensionsret!= ROK)
1098    {
1099       return RFAILED;
1100    }
1101    return ROK;
1102 }
1103 /*******************************************************************
1104  *
1105  * @brief Builds Served Cell List
1106  *
1107  * @details
1108  *
1109  *    Function : BuildServedCellList
1110  *
1111  *    Functionality: Building Served Cell List
1112  *
1113  * @params[in] PLMNID plmn
1114  * @return ROK     - success
1115  *         RFAILED - failure
1116  *
1117  * ****************************************************************/
1118
1119 uint8_t BuildServedCellList(GNB_DU_Served_Cells_List_t *duServedCell)
1120 {
1121    uint8_t  BuildNrcgiret=0;
1122    uint8_t  BuildFiveGSTacret=0;
1123    uint8_t  BuildServedPlmnret=0;
1124    uint8_t  BuildNrModeret=0;
1125    uint8_t  idx;
1126    uint8_t  plmnidx;
1127    uint8_t  plmnCnt=1;
1128    GNB_DU_Served_Cells_Item_t *srvCellItem;
1129    duServedCell->list.size = plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t *);
1130    duServedCell->list.count = plmnCnt;
1131
1132    DU_ALLOC(duServedCell->list.array, duServedCell->list.size);
1133    if(duServedCell->list.array == NULLP)
1134    {
1135       return RFAILED;
1136    }
1137    for(plmnidx=0; plmnidx<plmnCnt; plmnidx++)
1138    {
1139       DU_ALLOC(duServedCell->list.array[plmnidx],\
1140             sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1141       if(duServedCell->list.array[plmnidx] == NULLP)
1142       {
1143          return RFAILED;
1144       }
1145    }
1146    idx = 0;
1147    duServedCell->list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_Served_Cells_Item;
1148    duServedCell->list.array[idx]->criticality = Criticality_reject;
1149    duServedCell->list.array[idx]->value.present = \
1150                                                   GNB_DU_Served_Cells_ItemIEs__value_PR_GNB_DU_Served_Cells_Item;
1151    srvCellItem = \
1152                  &duServedCell->list.array[idx]->value.choice.GNB_DU_Served_Cells_Item;
1153    /*nRCGI*/
1154    BuildNrcgiret = BuildNrcgi(&srvCellItem->served_Cell_Information.nRCGI);
1155    if(BuildNrcgiret != ROK)
1156    {
1157       return RFAILED;
1158    }
1159    /*nRPCI*/
1160    srvCellItem->served_Cell_Information.nRPCI = \
1161                                                 duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
1162
1163    /*fiveGS_TAC*/
1164    BuildFiveGSTacret = BuildFiveGSTac(&srvCellItem->served_Cell_Information);
1165    if(BuildFiveGSTacret != ROK)
1166    {
1167       return RFAILED;
1168    }
1169    /*Served PLMNs*/
1170    BuildServedPlmnret = BuildServedPlmn(&srvCellItem->served_Cell_Information.servedPLMNs);
1171    if(BuildServedPlmnret !=ROK)
1172    {
1173       return RFAILED;
1174    }
1175    /*nR Mode Info with FDD*/
1176    BuildNrModeret = BuildNrMode(&srvCellItem->served_Cell_Information.nR_Mode_Info);
1177    if(BuildNrModeret != ROK)
1178    {
1179       return RFAILED;
1180    }
1181    /*Measurement timing Config*/
1182    srvCellItem->served_Cell_Information.measurementTimingConfiguration.\
1183       size = sizeof(uint8_t);
1184    DU_ALLOC(srvCellItem->served_Cell_Information.\
1185          measurementTimingConfiguration.buf,srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1186    if(srvCellItem->served_Cell_Information.\
1187          measurementTimingConfiguration.buf == NULLP)
1188    {
1189       return RFAILED;
1190    }
1191    srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf[0] = \
1192                                                                                 duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
1193
1194    /* GNB DU System Information */
1195    DU_ALLOC(srvCellItem->gNB_DU_System_Information,
1196          sizeof(GNB_DU_System_Information_t));
1197    if(!srvCellItem->gNB_DU_System_Information)
1198    {
1199       return RFAILED;
1200    }
1201    /* MIB */
1202    srvCellItem->gNB_DU_System_Information->mIB_message.size = duCfgParam.srvdCellLst[0].duSysInfo.mibLen;
1203    DU_ALLOC(srvCellItem->gNB_DU_System_Information->mIB_message.buf,
1204          srvCellItem->gNB_DU_System_Information->mIB_message.size);
1205    if(!srvCellItem->gNB_DU_System_Information->mIB_message.buf)
1206    {
1207       return RFAILED;
1208    }
1209    memcpy(srvCellItem->gNB_DU_System_Information->mIB_message.buf, duCfgParam.srvdCellLst[0].duSysInfo.mibMsg, \
1210                    srvCellItem->gNB_DU_System_Information->mIB_message.size);
1211
1212    /* SIB1 */
1213    srvCellItem->gNB_DU_System_Information->sIB1_message.size =\
1214                                                               duCfgParam.srvdCellLst[0].duSysInfo.sib1Len;
1215
1216    DU_ALLOC(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,
1217          srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1218    if(!srvCellItem->gNB_DU_System_Information->sIB1_message.buf)
1219    {
1220       return RFAILED;
1221    }
1222    for(int x=0; x<srvCellItem->gNB_DU_System_Information->sIB1_message.size; x++)
1223    {
1224       srvCellItem->gNB_DU_System_Information->sIB1_message.buf[x]=\
1225                                                                   duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg[x];
1226    }
1227    return ROK;
1228 }
1229 /*******************************************************************
1230  *
1231  * @brief Builds RRC Version
1232  *
1233  * @details
1234  *
1235  *    Function : BuildRrcVer
1236  *
1237  *    Functionality: Building RRC Version
1238  *
1239  * @params[in] int idx,int elementCnt,RRC_Version_t *rrcver
1240  * @return ROK     - success
1241  *         RFAILED - failure
1242  *
1243  * ****************************************************************/
1244 uint8_t BuildRrcVer(RRC_Version_t *rrcVer)
1245 {
1246    uint8_t rrcExt;
1247    uint8_t rrcLatest;
1248    rrcVer->latest_RRC_Version.size = sizeof(uint8_t);
1249    DU_ALLOC(rrcVer->latest_RRC_Version.buf,sizeof(uint8_t));
1250    if(rrcVer->latest_RRC_Version.buf == NULLP)
1251    {
1252       return RFAILED;
1253    }
1254    rrcVer->latest_RRC_Version.buf[0] = 0;
1255    rrcVer->latest_RRC_Version.bits_unused = 5;
1256    DU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1257    if(rrcVer->iE_Extensions == NULLP)
1258    {
1259       return RFAILED;
1260    }
1261    rrcVer->iE_Extensions->list.count = 1;
1262    rrcVer->iE_Extensions->list.size = sizeof(RRC_Version_ExtIEs_t *);
1263    DU_ALLOC(rrcVer->iE_Extensions->list.array,rrcVer->iE_Extensions->list.size);
1264    if(rrcVer->iE_Extensions->list.array == NULLP)
1265    {
1266       return RFAILED;
1267    }
1268    rrcExt = 0;
1269    DU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
1270          sizeof(RRC_Version_ExtIEs_t));
1271    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
1272    {
1273       return RFAILED;
1274    }
1275    rrcVer->iE_Extensions->list.array[rrcExt]->id = \
1276                                                    ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
1277    rrcVer->iE_Extensions->list.array[rrcExt]->criticality = Criticality_reject;
1278    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.present =\
1279                                                                       RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
1280    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1281       .Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
1282    DU_ALLOC(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1283          .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1284          array[rrcExt]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1285    if(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1286          .Latest_RRC_Version_Enhanced.buf == NULLP)
1287    {
1288       return RFAILED;
1289    }
1290    rrcLatest = 0;
1291    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1292       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 15;
1293    rrcLatest++;
1294    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1295       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 5;
1296    rrcLatest++;
1297    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1298       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 0;
1299    return ROK;
1300 }
1301 /*******************************************************************
1302  *
1303  * @brief Sends F1 msg over SCTP
1304  *
1305  * @details
1306  *
1307  *    Function : sendF1APMsg
1308  *
1309  *    Functionality: Sends F1 msg over SCTP
1310  *
1311  * @params[in] Region region
1312  *             Pool pool
1313  * @return ROK     - success
1314  *         RFAILED - failure
1315  *
1316  * ****************************************************************/
1317 uint8_t sendF1APMsg()
1318 {
1319    Buffer *mBuf = NULLP;
1320
1321    if(ODU_GET_MSG_BUF(DU_APP_MEM_REGION, DU_POOL, &mBuf) == ROK)
1322    {
1323       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
1324       {
1325             ODU_PRINT_MSG(mBuf, 0,0);
1326
1327             if(sctpSend(mBuf, F1_INTERFACE) != ROK)
1328             {
1329                DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
1330                ODU_PUT_MSG_BUF(mBuf);
1331                return RFAILED;
1332             }
1333       }
1334       else
1335       {
1336          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
1337          ODU_PUT_MSG_BUF(mBuf);
1338          return RFAILED;
1339       }
1340       ODU_PUT_MSG_BUF(mBuf);
1341    }
1342    else
1343    {
1344       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
1345       return RFAILED;
1346    }
1347    return ROK;
1348 } /* sendF1APMsg */
1349
1350 /*******************************************************************
1351  *
1352  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1353  *
1354  * @details
1355  *
1356  *    Function :  FreeRrcVer
1357  *
1358  *    Functionality: deallocating the memory of function BuildRrcVer
1359  *
1360  * @params[in] RRC_Version_t *rrcVer
1361  *
1362  * @return void
1363  *
1364  *****************************************************************/
1365 void FreeRrcVer(RRC_Version_t *rrcVer)
1366 {
1367    if(rrcVer->latest_RRC_Version.buf != NULLP)
1368    {
1369       if(rrcVer->iE_Extensions != NULLP)
1370       {
1371          if(rrcVer->iE_Extensions->list.array != NULLP)
1372          {
1373             if(rrcVer->iE_Extensions->list.array[0] != NULLP)
1374             {
1375                if(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf
1376                      != NULLP)
1377                {
1378                   DU_FREE(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice\
1379                         .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1380                         array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1381                }
1382                DU_FREE(rrcVer->iE_Extensions->list.array[0],sizeof(RRC_Version_ExtIEs_t));
1383             }
1384             DU_FREE(rrcVer->iE_Extensions->list.array,sizeof(RRC_Version_ExtIEs_t*));
1385          }
1386          DU_FREE(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1387       }
1388       DU_FREE(rrcVer->latest_RRC_Version.buf,rrcVer->latest_RRC_Version.size);
1389    }
1390 }
1391 /*******************************************************************
1392  *
1393  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1394  *
1395  * @details
1396  *
1397  *    Function :  FreeServedCellList
1398  *
1399  *    Functionality:  deallocating the memory of function BuildServedCellList
1400
1401  *
1402  * @params[in] GNB_DU_Served_Cells_List_t *duServedCell
1403  *
1404  * @return void
1405  *
1406  * ****************************************************************/
1407 void FreeServedCellList( GNB_DU_Served_Cells_List_t *duServedCell)
1408 {
1409    uint8_t   plmnCnt=1;
1410    uint8_t  sliceId=0;
1411    uint8_t  extensionCnt=1;
1412    uint8_t  plmnIdx=0;
1413    GNB_DU_Served_Cells_Item_t *srvCellItem;
1414    ServedPLMNs_Item_t  *servedPlmnItem;
1415    SliceSupportItem_t  *sliceSupportItem;
1416
1417    if(duServedCell->list.array!=NULLP)
1418    {
1419       if(duServedCell->list.array[0]!=NULLP)
1420       {
1421          srvCellItem= &duServedCell->list.array[0]->value.choice.GNB_DU_Served_Cells_Item;
1422
1423          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1424                srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size * sizeof(uint8_t));
1425          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1426                srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size * sizeof(uint8_t));
1427
1428          if(srvCellItem->served_Cell_Information.fiveGS_TAC!=NULLP)
1429          {
1430             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
1431                   sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
1432             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,sizeof(FiveGS_TAC_t));
1433          }
1434
1435          if(srvCellItem->served_Cell_Information.servedPLMNs.list.array!=NULLP)
1436          {
1437             if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx] != NULLP)
1438             {
1439                servedPlmnItem = srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx];
1440                DU_FREE(servedPlmnItem->pLMN_Identity.buf, servedPlmnItem->pLMN_Identity.size * sizeof(uint8_t));
1441
1442                if(servedPlmnItem->iE_Extensions != NULLP)
1443                {
1444                   if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1445                   {
1446                      if(servedPlmnItem->iE_Extensions->list.array[0] != NULLP)
1447                      {
1448                         if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.list.\
1449                               array != NULLP)
1450                         {
1451                            if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.list.\
1452                                  array[sliceId] != NULLP)
1453                            {
1454                               sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1455                                                  SliceSupportList.list.array[sliceId];
1456
1457                               DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sizeof(uint8_t));
1458
1459                               if(sliceSupportItem->sNSSAI.sD != NULLP)
1460                               {
1461                                  DU_FREE(sliceSupportItem->sNSSAI.sD->buf, sliceSupportItem->sNSSAI.sD->size);
1462                                  DU_FREE(sliceSupportItem->sNSSAI.sD, sizeof(OCTET_STRING_t));
1463                               }
1464
1465                               DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1466                                     list.array[sliceId], sizeof(SliceSupportItem_t));
1467                            }
1468                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
1469                                  list.array, sizeof(SliceSupportItem_t*));
1470                         }
1471                         DU_FREE(servedPlmnItem->iE_Extensions->list.array[0], sizeof(ServedPLMNs_ItemExtIEs_t));
1472                      }
1473                      DU_FREE(servedPlmnItem->iE_Extensions->list.array, extensionCnt*sizeof(ServedPLMNs_ItemExtIEs_t*));
1474                   }
1475                   DU_FREE(servedPlmnItem->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P3_t));
1476                }
1477                DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx], sizeof(ServedPLMNs_Item_t));
1478             }
1479             DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array, sizeof(ServedPLMNs_Item_t *));
1480          }
1481
1482          if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD != NULLP)
1483          {
1484             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
1485                   freqBandListNr.list.array != NULLP)
1486             {
1487                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.\
1488                      list.array[0],sizeof(FreqBandNrItem_t));
1489                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.\
1490                      list.array,sizeof(FreqBandNrItem_t*));
1491             }
1492
1493             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1494                   freqBandListNr.list.array)
1495             {
1496                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1497                      freqBandListNr.list.array[0],sizeof(FreqBandNrItem_t));
1498                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1499                      freqBandListNr.list.array,sizeof(FreqBandNrItem_t *));
1500             }
1501             DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD, sizeof(FDD_Info_t));
1502          }
1503
1504          DU_FREE(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1505                srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1506
1507          if(srvCellItem->gNB_DU_System_Information != NULLP)
1508          {
1509             if(srvCellItem->gNB_DU_System_Information->mIB_message.buf != NULLP)
1510             {
1511                DU_FREE(srvCellItem->gNB_DU_System_Information->mIB_message.buf,\
1512                      srvCellItem->gNB_DU_System_Information->mIB_message.size);
1513             }
1514
1515             if(srvCellItem->gNB_DU_System_Information->sIB1_message.buf != NULLP)
1516             {
1517                DU_FREE(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,\
1518                      srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1519             }
1520
1521             DU_FREE(srvCellItem->gNB_DU_System_Information, sizeof(GNB_DU_System_Information_t));
1522          }
1523
1524          DU_FREE(duServedCell->list.array[0], sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1525       }
1526       DU_FREE(duServedCell->list.array, plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t*));
1527    }
1528 }
1529
1530 /*******************************************************************
1531  *
1532  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1533  *
1534  * @details
1535  *
1536  *    Function :  FreeF1SetupReq
1537  *
1538  *    Functionality:  deallocating the memory of function BuildAndSendF1SetupReq
1539  *
1540  * @params[in] F1AP_PDU_t *f1apMsg
1541  *
1542  * @return void
1543  *
1544  * ****************************************************************/
1545 void FreeF1SetupReq(F1AP_PDU_t *f1apMsg)
1546 {
1547    uint8_t ieIdx, ieIdx2;
1548    F1SetupRequest_t *f1SetupReq=NULLP;
1549
1550    if(f1apMsg != NULLP)
1551    {
1552       if(f1apMsg->choice.initiatingMessage != NULLP)
1553       {
1554          f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1555          if(f1SetupReq->protocolIEs.list.array != NULLP)
1556          {
1557             for(ieIdx = 0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
1558             {
1559                if(f1SetupReq->protocolIEs.list.array[ieIdx] != NULLP)
1560                {
1561                   switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
1562                   {
1563                      case ProtocolIE_ID_id_TransactionID:
1564                         break;
1565                      case ProtocolIE_ID_id_gNB_DU_ID:
1566                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1567                               f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1568                         break;
1569                      case ProtocolIE_ID_id_gNB_DU_Name:
1570                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,\
1571                               strlen((char *)duCfgParam.duName));
1572                         break;
1573                      case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
1574                         FreeServedCellList(&f1SetupReq->protocolIEs.list.\
1575                               array[ieIdx]->value.choice.GNB_DU_Served_Cells_List);
1576                         break;
1577                      case ProtocolIE_ID_id_GNB_DU_RRC_Version:
1578                         FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version);
1579                         break;
1580                      default:
1581                         DU_LOG("\nERROR  -->  Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id);
1582                         break;
1583                   }
1584                }
1585             }
1586             for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++)
1587             {
1588                DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx2],sizeof(F1SetupRequestIEs_t));
1589             }
1590             DU_FREE(f1SetupReq->protocolIEs.list.array,\
1591                   f1SetupReq->protocolIEs.list.size);
1592          }
1593          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1594       }
1595       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1596    }
1597 }
1598 /*******************************************************************
1599  *
1600  * @brief Builds and Send the F1SetupRequest
1601  *
1602  * @details
1603  *
1604  *    Function : BuildAndSendF1SetupReq
1605  *
1606  * Functionality:Fills the F1SetupRequest
1607  *
1608  * @return ROK     - success
1609  *         RFAILED - failure
1610  *
1611  ******************************************************************/
1612 uint8_t BuildAndSendF1SetupReq()
1613 {
1614    uint8_t   ret, ieIdx, elementCnt;
1615    F1AP_PDU_t                 *f1apMsg = NULLP;
1616    F1SetupRequest_t           *f1SetupReq=NULLP;
1617    GNB_DU_Served_Cells_List_t *duServedCell=NULLP;
1618    RRC_Version_t              *rrcVer=NULLP;
1619    asn_enc_rval_t             encRetVal;        /* Encoder return value */
1620    ret= RFAILED;
1621
1622    DU_LOG("\nINFO   -->  F1AP : Building F1 Setup Request\n");
1623    do
1624    {
1625       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1626       if(f1apMsg == NULLP)
1627       {
1628          break;
1629       }
1630       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1631       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1632       if(f1apMsg->choice.initiatingMessage == NULLP)
1633       {
1634          break;
1635       }
1636       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_F1Setup;
1637       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
1638       f1apMsg->choice.initiatingMessage->value.present = \
1639                                                          InitiatingMessage__value_PR_F1SetupRequest;
1640
1641       f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1642
1643       elementCnt = (duCfgParam.duName != NULL) ? 5 : 4;
1644
1645       f1SetupReq->protocolIEs.list.count = elementCnt;
1646       f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t );
1647
1648       /* Initialize the F1Setup members */
1649       DU_ALLOC(f1SetupReq->protocolIEs.list.array,f1SetupReq->protocolIEs.list.size);
1650       if(f1SetupReq->protocolIEs.list.array == NULLP)
1651       {
1652          break;
1653       }
1654       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
1655       {
1656          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx],\
1657                sizeof(F1SetupRequestIEs_t));
1658          if(f1SetupReq->protocolIEs.list.array[ieIdx] == NULLP)
1659          {
1660             break;
1661          }
1662       }
1663
1664       ieIdx = 0;
1665       /*TransactionID*/
1666       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransactionID;
1667       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1668       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present =\
1669                                                                F1SetupRequestIEs__value_PR_TransactionID;
1670       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = \
1671                                                                              TRANS_ID;
1672
1673       /*DU ID*/
1674       ieIdx++;
1675       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
1676       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1677       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1678                                                                 F1SetupRequestIEs__value_PR_GNB_DU_ID;
1679       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size =\
1680                                                                              sizeof(uint8_t);
1681
1682       DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1683             f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1684       if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == \
1685             NULLP)
1686       {
1687          break;
1688       }
1689
1690       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] =\
1691          duCfgParam.duId;
1692
1693       /*DU Name*/
1694       if(duCfgParam.duName != NULL)
1695       {
1696          ieIdx++;
1697          f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_Name;
1698          f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
1699          f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = F1SetupRequestIEs__value_PR_GNB_DU_Name;
1700          f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.size =\
1701             strlen((char *)duCfgParam.duName);
1702          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.\
1703                GNB_DU_Name.buf, strlen((char *)duCfgParam.duName));
1704          if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.\
1705                buf == NULLP)
1706          {
1707             break;
1708          }
1709          strcpy((char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.\
1710                choice.GNB_DU_Name.buf,
1711                (char*)&duCfgParam.duName);
1712
1713       }
1714
1715       /*Served Cell list */
1716       ieIdx++;
1717       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1718                                                      ProtocolIE_ID_id_gNB_DU_Served_Cells_List;
1719       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1720       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1721                                                                 F1SetupRequestIEs__value_PR_GNB_DU_Served_Cells_List;
1722       duServedCell = &f1SetupReq->protocolIEs.list.\
1723                      array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
1724       if(BuildServedCellList(duServedCell))
1725       {
1726          break;
1727       }
1728       /*RRC Version*/
1729       ieIdx++;
1730       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1731                                                      ProtocolIE_ID_id_GNB_DU_RRC_Version ;
1732       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1733       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1734                                                                 F1SetupRequestIEs__value_PR_RRC_Version;
1735       rrcVer = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
1736       if(BuildRrcVer(rrcVer))
1737       {
1738          break;
1739       }
1740       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1741
1742       /* Encode the F1SetupRequest type as APER */
1743       memset(encBuf, 0, ENC_BUF_MAX_LEN);
1744       encBufSize = 0;
1745       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1746             encBuf);
1747
1748       /* Encode results */
1749       if(encRetVal.encoded == ENCODE_FAIL)
1750       {
1751          DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupRequest structure (at %s)\n",\
1752                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1753          break;
1754       }
1755       else
1756       {
1757          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1SetupRequest\n");
1758          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
1759          {
1760             printf("%x",encBuf[ieIdx]);
1761          }
1762       }
1763
1764       /* Sending msg */
1765       if(sendF1APMsg() != ROK)
1766       {
1767          DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup request failed");
1768          break;
1769       }
1770
1771       ret=ROK;
1772       break;
1773    }while(true);
1774
1775    FreeF1SetupReq(f1apMsg);
1776
1777    return ret;
1778 }/* End of BuildAndSendF1SetupReq */
1779
1780 /*******************************************************************
1781  *
1782  * @brief Deallocating memory allocated for Served_Cells_To_Modify_Item_t
1783  *
1784  * @details
1785  *
1786  *    Function : freeCellsToModifyItem
1787  *
1788  *    Functionality: Deallocating memory of variables allocated in
1789  *                    BuildAndSendDUConfigUpdate function
1790  *
1791  * @params[in]  Served_Cells_To_Modify_Item_t *modifyItem
1792  *
1793  * @return ROK     - void
1794  *
1795  * ****************************************************************/
1796
1797 void freeCellsToModifyItem(Served_Cells_To_Modify_Item_t *modifyItem)
1798 {
1799    uint8_t arrIdx=0,i=0;
1800    ServedPLMNs_Item_t *servedPlmnItem = NULLP;
1801    SliceSupportItem_t *sliceSupportItem = NULLP;
1802
1803    DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf, modifyItem->oldNRCGI.pLMN_Identity.size);
1804    DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf, modifyItem->oldNRCGI.nRCellIdentity.size);
1805
1806    DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1807            modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
1808    DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1809          modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
1810
1811    if(modifyItem->served_Cell_Information.servedPLMNs.list.array != NULLP)
1812    {
1813       if(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx] != NULLP)
1814       {
1815          servedPlmnItem = modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx];
1816
1817          DU_FREE(servedPlmnItem->pLMN_Identity.buf,servedPlmnItem->pLMN_Identity.size);
1818
1819          if(servedPlmnItem->iE_Extensions != NULLP)
1820          {
1821             if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1822             {
1823                if(servedPlmnItem->iE_Extensions->list.array[arrIdx] != NULLP)
1824                {
1825                   if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.list.array != NULLP)
1826                   {
1827                      if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.list.array[arrIdx] != NULLP)
1828                      {
1829                         sliceSupportItem = modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx]->iE_Extensions->\
1830                                            list.array[arrIdx]->extensionValue.choice.SliceSupportList.list.array[arrIdx];
1831
1832                         DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sliceSupportItem->sNSSAI.sST.size);
1833                         if(sliceSupportItem->sNSSAI.sD != NULLP)
1834                         {
1835                            DU_FREE(sliceSupportItem->sNSSAI.sD->buf, sliceSupportItem->sNSSAI.sD->size);
1836                            DU_FREE(sliceSupportItem->sNSSAI.sD,sizeof(OCTET_STRING_t));
1837                         }
1838                         DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1839                               list.array[arrIdx], sizeof(SliceSupportItem_t));
1840                      }
1841                      DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.list.array,
1842                            servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.list.size);
1843                   }
1844                }
1845                for(i=0; i < servedPlmnItem->iE_Extensions->list.count ; i++)
1846                {
1847                   DU_FREE(servedPlmnItem->iE_Extensions->list.array[i], sizeof(ServedPLMNs_ItemExtIEs_t ));
1848                }
1849                DU_FREE(servedPlmnItem->iE_Extensions->list.array, servedPlmnItem->iE_Extensions->list.size);
1850             }
1851             DU_FREE(servedPlmnItem->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1852          }
1853       }
1854       for(i=0;i<modifyItem->served_Cell_Information.servedPLMNs.list.count;i++)
1855       {
1856          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[i], sizeof(ServedPLMNs_Item_t));
1857       }
1858       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1859             modifyItem->served_Cell_Information.servedPLMNs.list.size);
1860    }
1861
1862    if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD != NULLP)
1863    {
1864       if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1865       {
1866          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
1867                array[arrIdx], sizeof(FreqBandNrItem_t));
1868          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array, \
1869                modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1870       }
1871
1872       if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1873       {
1874          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.\
1875              array[arrIdx], sizeof(FreqBandNrItem_t));
1876          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,\
1877                modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1878       }
1879       DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD,sizeof(FDD_Info_t));
1880    }
1881
1882    DU_FREE(modifyItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1883       modifyItem->served_Cell_Information.measurementTimingConfiguration.size);
1884 }
1885
1886 /*******************************************************************
1887  *
1888  * @brief Deallocating memory of BuildAndSendDUConfigUpdate
1889  *
1890  * @details
1891  *
1892  *    Function : FreeDUConfigUpdate
1893  *
1894  *    Functionality: Deallocating memory of variables allocated in
1895  *                    BuildAndSendDUConfigUpdate function
1896  *
1897  * @params[in]  F1AP_PDU_t *f1apDuCfg
1898  *
1899  * @return ROK     - void
1900  *
1901  * ****************************************************************/
1902 void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg)
1903 {
1904    uint8_t  ieIdx=0, cellModifyIdx=0, cellDeleteIdx=0;
1905    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
1906    Served_Cells_To_Modify_List_t  *cellsToModify=NULLP;
1907    Served_Cells_To_Delete_List_t  *cellsToDelete=NULLP;
1908    Served_Cells_To_Delete_Item_t  *deleteItem = NULLP;
1909    Served_Cells_To_Delete_ItemIEs_t *deleteItemIe = NULLP;
1910
1911    if(f1apDuCfg != NULLP)
1912    {
1913       if(f1apDuCfg->choice.initiatingMessage != NULLP)
1914       {
1915          duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->\
1916                        value.choice.GNBDUConfigurationUpdate;
1917          if(duCfgUpdate->protocolIEs.list.array != NULLP)
1918          {
1919             for(ieIdx=0; ieIdx<duCfgUpdate->protocolIEs.list.count; ieIdx++)
1920             {
1921                if(duCfgUpdate->protocolIEs.list.array[ieIdx] != NULLP)
1922                {
1923                   switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
1924                   {
1925                      case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
1926                         {
1927                            cellsToModify = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1928                                            value.choice.Served_Cells_To_Modify_List;
1929                            if(cellsToModify->list.array != NULLP)
1930                            {
1931                               for(cellModifyIdx=0; cellModifyIdx<cellsToModify->list.count ;cellModifyIdx++)
1932                               {
1933                                  if(cellsToModify->list.array[cellModifyIdx] != NULLP)
1934                                  {
1935                                     freeCellsToModifyItem(&cellsToModify->list.array[cellModifyIdx]->value.choice.\
1936                                           Served_Cells_To_Modify_Item);
1937                                     DU_FREE(cellsToModify->list.array[cellModifyIdx],\
1938                                           sizeof(Served_Cells_To_Modify_ItemIEs_t));
1939                                  }
1940                               }
1941                               DU_FREE(cellsToModify->list.array,cellsToModify->list.size);
1942                            }
1943                            break;
1944                         }
1945                      case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
1946                         {
1947                            cellsToDelete = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1948                                            value.choice.Served_Cells_To_Delete_List;
1949                            if(cellsToDelete->list.array != NULLP)
1950                            {
1951                               for(cellDeleteIdx=0; cellDeleteIdx<cellsToDelete->list.count ;cellDeleteIdx++)
1952                               {
1953                                  if(cellsToDelete->list.array[cellDeleteIdx] != NULLP)
1954                                  {
1955                                     deleteItemIe = ((Served_Cells_To_Delete_ItemIEs_t*)\
1956                                           cellsToDelete->list.array[cellDeleteIdx]);
1957                                     deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
1958                                     DU_FREE(deleteItem->oldNRCGI.pLMN_Identity.buf,\
1959                                           deleteItem->oldNRCGI.pLMN_Identity.size);
1960                                     DU_FREE(deleteItem->oldNRCGI.nRCellIdentity.buf,\
1961                                           deleteItem->oldNRCGI.nRCellIdentity.size);
1962                                     DU_FREE(cellsToDelete->list.array[cellDeleteIdx],\
1963                                           sizeof(Served_Cells_To_Delete_ItemIEs_t));
1964                                  }
1965                               }
1966                               DU_FREE(cellsToDelete->list.array,cellsToDelete->list.size);
1967                            }
1968
1969                            break;
1970                         }
1971                      case ProtocolIE_ID_id_gNB_DU_ID:
1972                         {
1973                            DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1974                                  duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1975                            break;
1976                         }
1977                   }
1978                   DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx],\
1979                         sizeof(GNBDUConfigurationUpdateIEs_t));
1980                }
1981             }
1982             DU_FREE(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
1983          }
1984          DU_FREE(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
1985       }
1986       DU_FREE(f1apDuCfg, (Size)sizeof(F1AP_PDU_t));
1987    }
1988 }
1989
1990 /*******************************************************************
1991  *
1992  * @brief Fills Served Plmns required in ServCellInfo IE
1993  *
1994  * @details
1995  *
1996  *    Function : fillServedPlmns
1997  *
1998  *    Functionality: Fills Served Plmns required in ServCellInfo IE
1999  *
2000  * @params[in] Pointer to ServedPLMNs_List_t *
2001  *
2002  * @return ROK     - success
2003  *         RFAILED - failure
2004  *
2005  *****************************************************************/
2006
2007 uint8_t fillServedPlmns(ServedPLMNs_List_t *servedPlmn)
2008 {
2009    uint8_t ieIdx, ieListCnt;
2010
2011    servedPlmn->list.array[0]->pLMN_Identity.size = 3*sizeof(uint8_t);
2012    DU_ALLOC(servedPlmn->list.array[0]->pLMN_Identity.buf, servedPlmn->list.\
2013          array[0]->pLMN_Identity.size);
2014    if(servedPlmn->list.array[0]->pLMN_Identity.buf == NULLP)
2015    {
2016       return RFAILED;
2017    }
2018    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.plmn[0],\
2019          servedPlmn->list.array[0]->pLMN_Identity.buf);
2020    DU_ALLOC(servedPlmn->list.array[0]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
2021    if(servedPlmn->list.array[0]->iE_Extensions == NULLP)
2022    {
2023       return RFAILED;
2024    }
2025
2026    ieListCnt=1;
2027    servedPlmn->list.array[0]->iE_Extensions->list.count = ieListCnt;
2028    servedPlmn->list.array[0]->iE_Extensions->list.size = ieListCnt *sizeof(ServedPLMNs_ItemExtIEs_t *);
2029    DU_ALLOC(servedPlmn->list.array[0]->iE_Extensions->list.array,servedPlmn->list.array[0]->\
2030          iE_Extensions->list.size);
2031    if(servedPlmn->list.array[0]->iE_Extensions->list.array == NULLP)
2032    {
2033       return RFAILED;
2034    }
2035    for(ieIdx=0;ieIdx<ieListCnt;ieIdx++)
2036    {
2037       DU_ALLOC(servedPlmn->list.array[0]->iE_Extensions->list.array[ieIdx],\
2038             sizeof(ServedPLMNs_ItemExtIEs_t));
2039       if(servedPlmn->list.array[0]->iE_Extensions->list.array[ieIdx] == NULLP)
2040       {
2041          return RFAILED;
2042       }
2043    }
2044    //plmnIeExt = servedPlmn->list.array[0]->iE_Extensions;
2045    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->id =ProtocolIE_ID_id_TAISliceSupportList;
2046    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->criticality = Criticality_ignore;
2047    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->extensionValue.present = \
2048       ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
2049    servedPlmn->list.array[0]->iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2050       list.count = 1;
2051    servedPlmn->list.array[0]->\
2052       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2053       list.size = sizeof(SliceSupportItem_t *);
2054    DU_ALLOC(servedPlmn->list.array[0]->\
2055          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2056          list.array,servedPlmn->list.array[0]->\
2057          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.list.size);
2058    if(servedPlmn->list.array[0]->\
2059          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2060          list.array == NULLP)
2061    {
2062       return RFAILED;
2063    }
2064
2065    DU_ALLOC(servedPlmn->list.array[0]->\
2066          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2067          list.array[0],sizeof( SliceSupportItem_t));
2068    if(servedPlmn->list.array[0]->\
2069          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2070          list.array[0] == NULLP)
2071    {
2072       return RFAILED;
2073    }
2074    servedPlmn->list.array[0]->\
2075       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2076       list.array[0]->sNSSAI.sST.size = sizeof(uint8_t);
2077    DU_ALLOC(servedPlmn->list.array[0]->\
2078          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2079          list.array[0]->sNSSAI.sST.buf,servedPlmn->list.array[0]->\
2080          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.list.array[0]->sNSSAI.sST.size);
2081    if(servedPlmn->list.array[0]->\
2082          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2083          list.array[0]->sNSSAI.sST.buf == NULLP)
2084    {
2085       return RFAILED;
2086    }
2087    servedPlmn->list.array[0]->\
2088       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2089       list.array[0]->sNSSAI.sST.buf[0] = 3;
2090    DU_ALLOC(servedPlmn->list.array[0]->\
2091          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2092          list.array[0]->sNSSAI.sD,sizeof(OCTET_STRING_t));
2093    if(servedPlmn->list.array[0]->\
2094          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2095          list.array[0]->sNSSAI.sD == NULLP)
2096    {
2097       return RFAILED;
2098    }
2099    servedPlmn->list.array[0]->\
2100       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2101       list.array[0]->sNSSAI.sD->size = 3*sizeof(uint8_t);
2102    DU_ALLOC(servedPlmn->list.array[0]->\
2103          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2104          list.array[0]->sNSSAI.sD->buf,servedPlmn->list.array[0]->\
2105          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2106          list.array[0]->sNSSAI.sD->size);
2107    if(servedPlmn->list.array[0]->\
2108          iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2109          list.array[0]->sNSSAI.sD->buf == NULLP)
2110    {
2111       return RFAILED;
2112    }
2113    servedPlmn->list.array[0]->\
2114       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2115       list.array[0]->sNSSAI.sD->buf[0] = 3;
2116    servedPlmn->list.array[0]->\
2117       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2118       list.array[0]->sNSSAI.sD->buf[1] = 6;
2119    servedPlmn->list.array[0]->\
2120       iE_Extensions->list.array[0]->extensionValue.choice.SliceSupportList.\
2121       list.array[0]->sNSSAI.sD->buf[2] = 9;
2122    return ROK;
2123 }
2124
2125 /*******************************************************************
2126  *
2127  * @brief Fills Nr Fdd Info required in ServCellInfo IE
2128  *
2129  * @details
2130  *
2131  *    Function : fillNrFddInfo
2132  *
2133  *    Functionality: Fills Nr Fdd Info required in ServCellInfo IE
2134  *
2135  * @params[in] Pointer to NR_Mode_Info_t *
2136  *
2137  * @return ROK     - success
2138  *         RFAILED - failure
2139  *
2140  *****************************************************************/
2141
2142 uint8_t fillNrFddInfo(NR_Mode_Info_t *nrFdd)
2143 {
2144    nrFdd->choice.fDD->uL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.\
2145       f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn;
2146    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.count = 1;
2147    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t*);
2148    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
2149          array, nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size);
2150    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2151    {
2152       return RFAILED;
2153    }
2154    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0], \
2155       sizeof(FreqBandNrItem_t));
2156    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2157    {
2158       return RFAILED;
2159    }
2160    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2161       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
2162       freqBand[0].nrFreqBand;
2163    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2164    nrFdd->choice.fDD->dL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.\
2165       dlNrFreqInfo.nrArfcn;
2166    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.count = 1;
2167    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
2168    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,nrFdd->\
2169          choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
2170    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2171    {
2172       return RFAILED;
2173    }
2174    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0],\
2175          sizeof(FreqBandNrItem_t));
2176    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2177    {
2178       return RFAILED;
2179    }
2180    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2181       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
2182       freqBand[0].nrFreqBand;
2183    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2184
2185    /*Transmission Bandwidth*/
2186    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2187       f1Mode.mode.fdd.ulTxBw.nrScs;
2188    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2189       f1Mode.mode.fdd.ulTxBw.nrb;
2190    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2191       f1Mode.mode.fdd.dlTxBw.nrScs;
2192    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2193       f1Mode.mode.fdd.dlTxBw.nrb;
2194
2195    return ROK;
2196 }
2197
2198 /*******************************************************************
2199  *
2200  * @brief Fills ServCellInfo IE
2201  *
2202  * @details
2203  *
2204  *    Function : fillServedCellInfo
2205  *
2206  *    Functionality: Fills ServCellInfo
2207  *
2208  * @params[in] Pointer to Served_Cell_Information_t *
2209  *
2210  * @return ROK     - success
2211  *         RFAILED - failure
2212  *
2213  *****************************************************************/
2214
2215 uint8_t fillServedCellInfo(Served_Cell_Information_t *srvCellInfo)
2216 {
2217    uint8_t tmp, ieIdx, ieListCnt;
2218
2219    /*nRCGI*/
2220    srvCellInfo->nRCGI.pLMN_Identity.size =3*sizeof(uint8_t);
2221    DU_ALLOC(srvCellInfo->nRCGI.pLMN_Identity.buf,\
2222          srvCellInfo->nRCGI.pLMN_Identity.size);
2223    if(srvCellInfo->nRCGI.pLMN_Identity.buf == NULLP)
2224    {
2225       return RFAILED;
2226    }
2227    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2228          srvCellInfo->nRCGI.pLMN_Identity.buf);
2229    srvCellInfo->nRCGI.nRCellIdentity.size =5*sizeof(uint8_t);
2230    DU_ALLOC(srvCellInfo->nRCGI.nRCellIdentity.buf,\
2231          srvCellInfo->nRCGI.nRCellIdentity.size);
2232    if(srvCellInfo->nRCGI.nRCellIdentity.buf == NULLP)
2233    {
2234       return RFAILED;
2235    }
2236    for (tmp = 0 ; tmp < srvCellInfo->\
2237          nRCGI.nRCellIdentity.size-1 ; tmp++)
2238    {
2239       srvCellInfo->nRCGI.nRCellIdentity.buf[tmp] = 0;
2240    }
2241    srvCellInfo->nRCGI.nRCellIdentity.buf[4] = 16;
2242    srvCellInfo->nRCGI.nRCellIdentity.bits_unused =4;
2243
2244    /*nRPCI*/
2245    srvCellInfo->nRPCI = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
2246
2247    /*servedPLMNs*/
2248    ieListCnt = 1;
2249    srvCellInfo->servedPLMNs.list.count = ieListCnt;
2250    srvCellInfo->servedPLMNs.list.size = ieListCnt*sizeof(ServedPLMNs_Item_t *);
2251    DU_ALLOC(srvCellInfo->servedPLMNs.list.array,\
2252          srvCellInfo->servedPLMNs.list.size);
2253    if(srvCellInfo->servedPLMNs.list.array == NULLP)
2254    {
2255       return RFAILED;
2256    }
2257    for(ieIdx=0; ieIdx < ieListCnt; ieIdx++)
2258    {
2259       DU_ALLOC(srvCellInfo->servedPLMNs.list.array[ieIdx],\
2260             sizeof(ServedPLMNs_Item_t));
2261       if(srvCellInfo->servedPLMNs.list.array[ieIdx]== NULLP)
2262       {
2263          return RFAILED;
2264       }
2265    }
2266    if(fillServedPlmns(&srvCellInfo->servedPLMNs))
2267    {
2268       return RFAILED;
2269    }
2270
2271    /*nR Mode Info with FDD*/
2272    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_fDD;
2273    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.fDD,\
2274          sizeof(FDD_Info_t));
2275    if(srvCellInfo->nR_Mode_Info.choice.fDD == NULLP)
2276    {
2277       return RFAILED;
2278    }
2279    if(fillNrFddInfo(&srvCellInfo->nR_Mode_Info))
2280       return RFAILED;
2281
2282    /*Measurement timing Config*/
2283    srvCellInfo->measurementTimingConfiguration.size = sizeof(uint8_t);
2284    DU_ALLOC(srvCellInfo->measurementTimingConfiguration.\
2285          buf,srvCellInfo->measurementTimingConfiguration.size);
2286    if(srvCellInfo->measurementTimingConfiguration.buf == NULLP)
2287    {
2288       return RFAILED;
2289    }
2290    srvCellInfo->measurementTimingConfiguration.\
2291          buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
2292
2293    return ROK;
2294 }
2295
2296 /*******************************************************************
2297  *
2298  * @brief Fills ServCellToModItem IE
2299  *
2300  * @details
2301  *
2302  *    Function : fillServCellToModItem
2303  *
2304  *    Functionality: Fills ServCellToModItem IE
2305  *
2306  * @params[in] Pointer to Served_Cells_To_Modify_Item_t *
2307  *
2308  * @return ROK     - success
2309  *         RFAILED - failure
2310  *
2311  *****************************************************************/
2312
2313 uint8_t fillServCellToModItem(Served_Cells_To_Modify_Item_t *modifyItem)
2314 {
2315    uint8_t ieIdx;
2316
2317    /*pLMN_Identity*/
2318    modifyItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2319    DU_ALLOC(modifyItem->oldNRCGI.pLMN_Identity.buf,modifyItem->oldNRCGI.pLMN_Identity.size);
2320    if(modifyItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2321    {
2322       return RFAILED;
2323    }
2324    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2325          modifyItem->oldNRCGI.pLMN_Identity.buf);
2326
2327    /*nRCellIdentity*/
2328    modifyItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2329    DU_ALLOC(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2330          modifyItem->oldNRCGI.nRCellIdentity.size);
2331    if(modifyItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2332    {
2333       return RFAILED;
2334    }
2335    for(ieIdx = 0; ieIdx < modifyItem->oldNRCGI.nRCellIdentity.size-1; ieIdx++)
2336    {
2337       modifyItem->oldNRCGI.nRCellIdentity.buf[ieIdx] = 0;
2338    }
2339    modifyItem->oldNRCGI.nRCellIdentity.buf[4] = 16;
2340    modifyItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
2341
2342    if(fillServedCellInfo(&modifyItem->served_Cell_Information))
2343       return RFAILED;
2344    else
2345       return ROK;
2346 }
2347
2348 /*******************************************************************
2349  *
2350  * @brief Builds ServCellToModList
2351  *
2352  * @details
2353  *
2354  *    Function : buildServCellToModList
2355  *
2356  *    Functionality: Builds the serv cell to Mod List
2357  *
2358  * @params[in] Pointer to Served_Cells_To_Modify_List_t *
2359  *
2360  * @return ROK     - success
2361  *         RFAILED - failure
2362  *
2363  *****************************************************************/
2364
2365 uint8_t buildServCellToModList(Served_Cells_To_Modify_List_t *cellsToModify)
2366 {
2367    uint8_t ieListCnt, ieIdx;
2368    Served_Cells_To_Modify_Item_t *modifyItem = NULLP;
2369
2370    ieListCnt = 1;
2371    cellsToModify->list.count = ieListCnt;
2372    cellsToModify->list.size = ieListCnt*sizeof(Served_Cells_To_Modify_ItemIEs_t *);
2373    DU_ALLOC(cellsToModify->list.array,cellsToModify->list.size);
2374    if(cellsToModify->list.array == NULLP)
2375    {
2376       return RFAILED;
2377    }
2378    for(ieIdx=0; ieIdx< ieListCnt; ieIdx++)
2379    {
2380       DU_ALLOC(cellsToModify->list.array[ieIdx],sizeof(Served_Cells_To_Modify_ItemIEs_t));
2381       if(cellsToModify->list.array[ieIdx] == NULLP)
2382       {
2383          return RFAILED;
2384       }
2385    }
2386    cellsToModify->list.array[0]->id = ProtocolIE_ID_id_Served_Cells_To_Modify_Item;
2387    cellsToModify->list.array[0]->criticality = Criticality_reject;
2388    cellsToModify->list.array[0]->value.present =\
2389       Served_Cells_To_Modify_ItemIEs__value_PR_Served_Cells_To_Modify_Item;
2390    modifyItem=&cellsToModify->list.array[0]->value.choice.Served_Cells_To_Modify_Item;
2391
2392    if(fillServCellToModItem(modifyItem))
2393       return RFAILED;
2394    else
2395       return ROK;
2396 }
2397 /*******************************************************************
2398  *
2399  * @brief filling the DeleteItemList
2400  *
2401  * @details
2402  *
2403  *    Function : fillCellToDeleteItem
2404  *
2405  *    Functionality: Filling the DeleteItemIe
2406  *
2407  * @params[in] Pointer to Served_Cells_To_Delete_ItemIEs_t
2408  *
2409  * @return ROK     - success
2410  *         RFAILED - failure
2411  *
2412  *****************************************************************/
2413 uint8_t fillCellToDeleteItem(struct Served_Cells_To_Delete_ItemIEs *deleteItemIe)
2414 {
2415    uint8_t arrIdx;
2416    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
2417
2418    deleteItemIe->id = ProtocolIE_ID_id_Served_Cells_To_Delete_Item;
2419    deleteItemIe->criticality = Criticality_reject;
2420    deleteItemIe->value.present =\
2421    Served_Cells_To_Delete_ItemIEs__value_PR_Served_Cells_To_Delete_Item;
2422    deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
2423
2424    /*pLMN_Identity*/
2425    deleteItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2426    DU_ALLOC(deleteItem->oldNRCGI.pLMN_Identity.buf,deleteItem->oldNRCGI.pLMN_Identity.size);
2427    if(deleteItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2428    {
2429       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2430       return RFAILED;
2431    }
2432    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2433          deleteItem->oldNRCGI.pLMN_Identity.buf);
2434
2435    /*nRCellIdentity*/
2436    deleteItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2437    DU_ALLOC(deleteItem->oldNRCGI.nRCellIdentity.buf,\
2438          deleteItem->oldNRCGI.nRCellIdentity.size);
2439    if(deleteItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2440    {
2441       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2442       return RFAILED;
2443    }
2444    for(arrIdx = 0; arrIdx < deleteItem->oldNRCGI.nRCellIdentity.size-1; arrIdx++)
2445    {
2446       deleteItem->oldNRCGI.nRCellIdentity.buf[arrIdx] = 0;
2447    }
2448    deleteItem->oldNRCGI.nRCellIdentity.buf[4] = 16;
2449    deleteItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
2450    return ROK;
2451 }
2452 /*******************************************************************
2453  *
2454  * @brief Builds ServCellToDeleteList
2455  *
2456  * @details
2457  *
2458  *    Function : buildServCellToDeleteList
2459  *
2460  *    Functionality: Builds the serv cell to delete List
2461  *
2462  * @params[in] Pointer to Served_Cells_To_Delete_List_t *
2463  *
2464  * @return ROK     - success
2465  *         RFAILED - failure
2466  *
2467  *****************************************************************/
2468
2469 uint8_t buildServCellToDeleteList(Served_Cells_To_Delete_List_t *cellsToDelete)
2470 {
2471    uint8_t ieListCnt, arrIdx;
2472
2473    ieListCnt = 1;
2474    cellsToDelete->list.count = ieListCnt;
2475    cellsToDelete->list.size = ieListCnt*sizeof(Served_Cells_To_Delete_ItemIEs_t *);
2476
2477    DU_ALLOC(cellsToDelete->list.array,cellsToDelete->list.size);
2478    if(cellsToDelete->list.array == NULLP)
2479    {
2480       DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2481       return RFAILED;
2482    }
2483
2484    for(arrIdx=0; arrIdx< ieListCnt; arrIdx++)
2485    {
2486       DU_ALLOC(cellsToDelete->list.array[arrIdx],sizeof(Served_Cells_To_Delete_ItemIEs_t));
2487       if(cellsToDelete->list.array[arrIdx] == NULLP)
2488       {
2489          DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2490          return RFAILED;
2491       }
2492    }
2493
2494    arrIdx=0;
2495    if(fillCellToDeleteItem((Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx]) !=ROK)
2496    {
2497       DU_LOG("\nERROR  -->  F1AP: buildServCellToDeleteList(): failed to fill Served_Cells_To_Delete_ItemIEs");
2498       return RFAILED;
2499    }
2500    return ROK;
2501 }
2502
2503 /*******************************************************************
2504  *
2505  * @brief Builds and sends the DUConfigUpdate
2506  *
2507  * @details
2508  *
2509  *    Function : BuildAndSendDUConfigUpdate
2510  *
2511  *    Functionality: Constructs the DU Update message and sends
2512  *                   it to the CU through SCTP.
2513  *
2514  * @params[in] void **buf,Buffer to which encoded pattern is written into
2515  * @params[in] int *size,size of buffer
2516  *
2517  * @return ROK     - success
2518  *         RFAILED - failure
2519  *
2520  * ****************************************************************/
2521 uint8_t BuildAndSendDUConfigUpdate(ServCellAction servCellAction)
2522 {
2523    uint8_t ret =0, ieIdx=0, elementCnt=0;
2524    bool memAlloctionFailure = false;
2525    F1AP_PDU_t                 *f1apDuCfg = NULLP;
2526    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
2527    asn_enc_rval_t encRetVal;     /* Encoder return value */
2528
2529    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2530    ret= RFAILED;
2531
2532    while(true)
2533    {
2534       DU_LOG("\nINFO   -->  F1AP : Building DU config update\n");
2535       /* Allocate the memory for F1DuCfg */
2536       DU_ALLOC(f1apDuCfg, sizeof(F1AP_PDU_t));
2537       if(f1apDuCfg == NULLP)
2538       {
2539          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2540          break;
2541       }
2542
2543       f1apDuCfg->present = F1AP_PDU_PR_initiatingMessage;
2544       DU_ALLOC(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2545       if(f1apDuCfg->choice.initiatingMessage == NULLP)
2546       {
2547          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2548          break;
2549       }
2550
2551       f1apDuCfg->choice.initiatingMessage->procedureCode = \
2552                                                            ProcedureCode_id_gNBDUConfigurationUpdate;
2553       f1apDuCfg->choice.initiatingMessage->criticality = Criticality_reject;
2554       f1apDuCfg->choice.initiatingMessage->value.present = \
2555                                                            InitiatingMessage__value_PR_GNBDUConfigurationUpdate;
2556       duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\
2557                     choice.GNBDUConfigurationUpdate;
2558       elementCnt = 3;
2559       duCfgUpdate->protocolIEs.list.count = elementCnt;
2560       duCfgUpdate->protocolIEs.list.size = \
2561                                            elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t*);
2562
2563       /* Initialize the F1Setup members */
2564       DU_ALLOC(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2565       if(duCfgUpdate->protocolIEs.list.array == NULLP)
2566       {
2567          DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2568          break;
2569       }
2570       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
2571       {
2572          DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx],sizeof(GNBDUConfigurationUpdateIEs_t));
2573          if(duCfgUpdate->protocolIEs.list.array[ieIdx] == NULLP)
2574          {
2575             DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2576             memAlloctionFailure = true;
2577             break;
2578          }
2579       }
2580
2581       if(memAlloctionFailure == true)
2582       {
2583          break;
2584       }
2585       /*TransactionID*/
2586       ieIdx = 0;
2587       duCfgUpdate->protocolIEs.list.array[ieIdx]->id=ProtocolIE_ID_id_TransactionID;
2588       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
2589       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2590       GNBDUConfigurationUpdateIEs__value_PR_TransactionID;
2591       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = TRANS_ID;
2592
2593       ieIdx++;
2594       if(servCellAction == SERV_CELL_TO_MODIFY)
2595       {
2596          /*Served Cell to Modify */
2597          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2598          ProtocolIE_ID_id_Served_Cells_To_Modify_List;
2599          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2600          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2601          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Modify_List;
2602          if(buildServCellToModList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2603                   Served_Cells_To_Modify_List))
2604          {
2605             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToModList");
2606             break;
2607          }
2608       }
2609       else
2610       {
2611          /*Served Cell to Delete */
2612          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2613          ProtocolIE_ID_id_Served_Cells_To_Delete_List;
2614          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2615          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2616          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Delete_List;
2617          if(buildServCellToDeleteList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2618          Served_Cells_To_Delete_List)!=ROK)
2619          {
2620             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToDeleteList");
2621             break;
2622          }
2623
2624       }
2625       // NOTE :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
2626       /*GNB DU ID */
2627       ieIdx++;
2628       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
2629       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
2630       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2631       GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID;
2632       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size = sizeof(uint8_t);
2633       DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2634             duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2635       if(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == NULLP)
2636       {
2637          DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): Memory allocation failed for GNB_DU_ID");
2638          break;
2639       }
2640       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] = duCfgParam.duId;
2641
2642       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
2643
2644       /* Encode the DU Config Update type as APER */
2645       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
2646       encBufSize = 0;
2647       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
2648
2649       /* Checking encode results */
2650       if(encRetVal.encoded == ENCODE_FAIL)
2651       {
2652          DU_LOG("ERROR  -->  F1AP : Could not encode DUConfigUpdate structure (at %s)\n",\
2653                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2654          break;
2655       }
2656       else
2657       {
2658          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DUConfigUpdate\n");
2659          for(ieIdx =0; ieIdx < encBufSize; ieIdx++)
2660          {
2661             printf("%x",encBuf[ieIdx]);
2662          }
2663       }
2664       /* Sending msg */
2665       if(sendF1APMsg() != ROK)
2666       {
2667          DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update failed");
2668          break;
2669       }
2670
2671       ret = ROK;
2672       break;
2673    }
2674
2675    addToReservedF1apPduList(TRANS_ID,f1apDuCfg);
2676    return ret;
2677 }
2678
2679
2680 /*******************************************************************
2681  *
2682  * @brief free the ULRRCMessageTransfer
2683  *
2684  * @details
2685  *
2686  *    Function : FreeULRRCMessageTransfer
2687  *
2688  *    Functionality: Deallocating the memory of variable allocated in
2689  *                      FreeULRRCMessageTransfer
2690  *
2691  * @params[in]
2692  *
2693  * @return ROK     - void
2694  *
2695  ******************************************************************/
2696 void FreeULRRCMessageTransfer( F1AP_PDU_t *f1apMsg)
2697 {
2698    uint8_t idx1;
2699    ULRRCMessageTransfer_t  *ulRRCMsg;
2700
2701    if(f1apMsg != NULLP)
2702    {
2703       if(f1apMsg->choice.initiatingMessage != NULLP)
2704       {
2705          ulRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2706          if(ulRRCMsg->protocolIEs.list.array != NULLP)
2707          {
2708             for(idx1=0;idx1<ulRRCMsg->protocolIEs.list.count;idx1++)
2709             {
2710                if(ulRRCMsg->protocolIEs.list.array[idx1] != NULLP)
2711                {
2712                   if(ulRRCMsg->protocolIEs.list.array[idx1]->value.present ==
2713                         ULRRCMessageTransferIEs__value_PR_RRCContainer)
2714                   {
2715                      DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2716                            ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2717                   }
2718                   DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1],sizeof(ULRRCMessageTransferIEs_t));
2719                }
2720             }
2721             DU_FREE(ulRRCMsg->protocolIEs.list.array,ulRRCMsg->protocolIEs.list.size );
2722          }
2723          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2724       }
2725       DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
2726    }
2727 }
2728 /*******************************************************************
2729  *
2730  * @brief Builds and sends the ULRRCMessageTransfer
2731  *
2732  * @details
2733  *
2734  *    Function : BuildAndSendULRRCMessageTransfer
2735  *
2736  *    Functionality: Constructs the UL RRC Message Transfer and sends
2737  *                   it to the CU through SCTP.
2738  *
2739  * @params[in]
2740  *
2741  * @return ROK     - success
2742  *         RFAILED - failure
2743  *
2744  * ****************************************************************/
2745 uint8_t BuildAndSendULRRCMessageTransfer(DuUeCb  ueCb, uint8_t lcId, \
2746       uint16_t msgLen, uint8_t *rrcMsg)
2747 {
2748    uint8_t   elementCnt =0;
2749    uint8_t   idx1 =0;
2750    uint8_t   idx =0;
2751    F1AP_PDU_t                   *f1apMsg = NULLP;
2752    ULRRCMessageTransfer_t       *ulRRCMsg = NULLP;
2753    asn_enc_rval_t               encRetVal;        /* Encoder return value */
2754    uint8_t ret =RFAILED;
2755
2756    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2757
2758    while(true)
2759    {
2760       DU_LOG("\n INFO   -->  F1AP : Building UL RRC Message Transfer Message\n");
2761
2762       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
2763       if(f1apMsg == NULLP)
2764       {
2765          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2766          break;
2767       }
2768       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
2769       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2770       if(f1apMsg->choice.initiatingMessage == NULLP)
2771       {
2772          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
2773          break;
2774       }
2775       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_ULRRCMessageTransfer;
2776       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
2777       f1apMsg->choice.initiatingMessage->value.present = \
2778                                                          InitiatingMessage__value_PR_ULRRCMessageTransfer;
2779       ulRRCMsg =
2780          &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2781       elementCnt = 4;
2782       ulRRCMsg->protocolIEs.list.count = elementCnt;
2783       ulRRCMsg->protocolIEs.list.size = \
2784                                         elementCnt * sizeof(ULRRCMessageTransferIEs_t *);
2785
2786       /* Initialize the F1Setup members */
2787       DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size);
2788       if(ulRRCMsg->protocolIEs.list.array == NULLP)
2789       {
2790          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
2791          break;
2792       }
2793       for(idx=0; idx<elementCnt; idx++)
2794       {
2795          DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t));
2796          if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP)
2797          {
2798             break;
2799          }
2800       }
2801
2802       idx1 = 0;
2803
2804       /*GNB CU UE F1AP ID*/
2805       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
2806       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2807       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2808                                                               ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
2809       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = ueCb.gnbCuUeF1apId;
2810
2811       /*GNB DU UE F1AP ID*/
2812       idx1++;
2813       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
2814       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2815       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2816                                                               ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
2817       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = ueCb.gnbDuUeF1apId;
2818
2819       /*SRBID*/
2820       idx1++;
2821       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
2822       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2823       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2824                                                               ULRRCMessageTransferIEs__value_PR_SRBID;
2825       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = lcId;
2826
2827       /*RRCContainer*/
2828       idx1++;
2829       ulRRCMsg->protocolIEs.list.array[idx1]->id  = ProtocolIE_ID_id_RRCContainer;
2830       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2831       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2832                                                               ULRRCMessageTransferIEs__value_PR_RRCContainer;
2833       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size = msgLen;
2834       DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2835             ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
2836       if(!ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
2837       {
2838          DU_LOG(" ERROR  -->  F1AP : Memory allocation for BuildAndSendULRRCMessageTransfer failed");
2839          break;
2840       }
2841       memset(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, 0, msgLen);
2842       memcpy(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, \
2843             rrcMsg, ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2844
2845       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2846
2847       /* Encode the F1SetupRequest type as APER */
2848       memset(encBuf, 0, ENC_BUF_MAX_LEN);
2849       encBufSize = 0;
2850       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
2851             encBuf);
2852       /* Encode results */
2853       if(encRetVal.encoded == ENCODE_FAIL)
2854       {
2855          DU_LOG( "\nERROR  -->  F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
2856                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2857          break;
2858       }
2859       else
2860       {
2861          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
2862          for(int i=0; i< encBufSize; i++)
2863          {
2864             printf("%x",encBuf[i]);
2865          }
2866       }
2867
2868       /* Sending  msg  */
2869       if(sendF1APMsg()  !=      ROK)
2870       {
2871          DU_LOG("\nERROR  -->   F1AP : Sending  UL RRC Message Transfer Failed");
2872          break;
2873       }
2874       ret = ROK;
2875       break;
2876    }
2877    FreeULRRCMessageTransfer(f1apMsg);
2878
2879    return ret;
2880 }/* End of BuildAndSendULRRCMessageTransfer*/
2881
2882 /*******************************************************************
2883  *
2884  * @brief Builds tag config
2885  *
2886  * @details
2887  *
2888  *    Function : BuildTagConfig
2889  *
2890  *    Functionality: Builds tag config in MacCellGroupConfig
2891  *
2892  * @params[in] TAG_Config *tag_Config
2893  *
2894  * @return ROK     - success
2895  *         RFAILED - failure
2896  *
2897  * ****************************************************************/
2898 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
2899 {
2900    struct TAG_Config__tag_ToAddModList *tagList;
2901    uint8_t                     idx, elementCnt;
2902
2903    tagConfig->tag_ToReleaseList = NULLP;
2904    tagConfig->tag_ToAddModList = NULLP;
2905    DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
2906    if(!tagConfig->tag_ToAddModList)
2907    {
2908       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2909       return RFAILED;
2910    }
2911
2912    elementCnt = 1; //ODU_VALUE_ONE;
2913    tagList = tagConfig->tag_ToAddModList;
2914    tagList->list.count = elementCnt;
2915    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
2916
2917    tagList->list.array = NULLP;
2918    DU_ALLOC(tagList->list.array, tagList->list.size);
2919    if(!tagList->list.array)
2920    {
2921       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2922       return RFAILED;
2923    }
2924
2925    for(idx=0; idx<tagList->list.count; idx++)
2926    {
2927       tagList->list.array[idx] = NULLP;
2928       DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
2929       if(!tagList->list.array[idx])
2930       {
2931          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2932          return RFAILED;
2933       }
2934    }
2935
2936    idx = 0;
2937    tagList->list.array[idx]->tag_Id = TAG_ID;
2938    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
2939
2940    return ROK;
2941 }
2942
2943 /*******************************************************************
2944  *
2945  * @brief Builds PHR Config
2946  *
2947  * @details
2948  *
2949  *    Function : BuildPhrConfig
2950  *
2951  *    Functionality: Builds phrConfig in MacCellGroupConfig
2952  *
2953  * @params[in] PHR Config *
2954  *
2955  * @return ROK     - success
2956  *         RFAILED - failure
2957  *
2958  * ****************************************************************/
2959 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
2960 {
2961
2962    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
2963    phrConfig->choice.setup = NULLP;
2964    DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
2965    if(!phrConfig->choice.setup)
2966    {
2967       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
2968       return RFAILED;
2969    }
2970
2971    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
2972    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
2973    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
2974    phrConfig->choice.setup->multiplePHR              = false;
2975    phrConfig->choice.setup->dummy                    = false;
2976    phrConfig->choice.setup->phr_Type2OtherCell       = false;
2977    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
2978
2979    return ROK;
2980 }
2981
2982 /*******************************************************************
2983  *
2984  * @brief Builds BSR Config
2985  *
2986  * @details
2987  *
2988  *    Function : BuildBsrConfig
2989  *
2990  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
2991  *
2992  * @params[in] BSR_Config *bsrConfig
2993  *
2994  * @return ROK     - success
2995  *         RFAILED - failure
2996  *
2997  * ****************************************************************/
2998 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
2999 {
3000    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
3001    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
3002    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
3003
3004    return ROK;
3005 }
3006
3007 /*******************************************************************
3008  *
3009  * @brief Builds scheduling request config
3010  *
3011  * @details
3012  *
3013  *    Function : BuildSchedulingReqConfig
3014  *
3015  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
3016  *
3017  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
3018  *
3019  * @return ROK     - success
3020  *         RFAILED - failure
3021  *
3022  * ****************************************************************/
3023 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
3024 {
3025    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
3026    uint8_t                     idx, elementCnt;
3027
3028    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
3029    DU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
3030          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
3031    if(!schedulingRequestConfig->schedulingRequestToAddModList)
3032    {
3033       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3034       return RFAILED;
3035    }
3036
3037    elementCnt = 1; //ODU_VALUE_ONE;
3038    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
3039    schReqList->list.count = elementCnt;
3040    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
3041
3042    schReqList->list.array = NULLP;
3043    DU_ALLOC(schReqList->list.array, schReqList->list.size);
3044    if(!schReqList->list.array)
3045    {
3046       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3047       return RFAILED;
3048    }
3049
3050    for(idx=0;idx<schReqList->list.count; idx++)
3051    {
3052       schReqList->list.array[idx] = NULLP;
3053       DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
3054       if(!schReqList->list.array[idx])
3055       {
3056          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3057          return RFAILED;
3058       }
3059    }
3060
3061    idx = 0;
3062    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
3063
3064    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
3065    DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
3066    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
3067    {
3068       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3069       return RFAILED;
3070    }
3071    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
3072    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
3073    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
3074
3075    return ROK;
3076 }
3077
3078 /*******************************************************************
3079  *
3080  * @brief Builds RLC Config
3081  *
3082  * @details
3083  *
3084  *    Function : BuildRlcConfig
3085  *
3086  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
3087  *
3088  * @params[in] RLC_Config *rlcConfig
3089  *
3090  * @return ROK     - success
3091  *         RFAILED - failure
3092  *
3093  * ****************************************************************/
3094 uint8_t BuildRlcConfig(struct RLC_Config *rlcConfig)
3095 {
3096
3097    rlcConfig->present = RLC_Config_PR_am;
3098
3099    rlcConfig->choice.am = NULLP;
3100    DU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
3101    if(!rlcConfig->choice.am)
3102    {
3103       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3104       return RFAILED;
3105    }
3106
3107    /* UL */
3108    rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
3109    DU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3110    if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
3111    {
3112       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3113       return RFAILED;
3114    }
3115    *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3116    rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
3117    rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
3118    rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
3119    rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
3120
3121    /* DL */
3122    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
3123    DU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3124    if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
3125    {
3126       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3127       return RFAILED;
3128    }
3129    *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3130    rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
3131    rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
3132
3133    return ROK;
3134 }
3135
3136 /*******************************************************************
3137  *
3138  * @brief Builds MAC LC Config
3139  *
3140  * @details
3141  *
3142  *    Function : BuildMacLCConfig
3143  *
3144  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
3145  *
3146  * @params[in] struct LogicalChannelConfig macLcConfig
3147  *
3148  * @return ROK     - success
3149  *         RFAILED - failure
3150  *
3151  * ****************************************************************/
3152 uint8_t BuildMacLCConfig(struct LogicalChannelConfig *macLcConfig)
3153 {
3154
3155    macLcConfig->ul_SpecificParameters = NULLP;
3156    DU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
3157    if(!macLcConfig->ul_SpecificParameters)
3158    {
3159       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3160       return RFAILED;
3161    }
3162
3163    macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
3164    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     PRIORTISIED_BIT_RATE;
3165    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     BUCKET_SIZE_DURATION;
3166    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
3167    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
3168    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
3169    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
3170
3171    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
3172    DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
3173    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
3174    {
3175       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3176       return RFAILED;
3177    }
3178    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
3179
3180    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
3181    DU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
3182    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
3183    {
3184       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3185       return RFAILED;
3186    }
3187    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
3188
3189    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
3190    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
3191    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
3192
3193    return ROK;
3194 }
3195
3196 /*******************************************************************
3197  *
3198  * @brief Builds RLC Bearer to Add/Mod list
3199  *
3200  * @details
3201  *
3202  *    Function :BuildRlcBearerToAddModList
3203  *
3204  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
3205  *
3206  * @params[in] rlc_BearerToAddModList
3207  *
3208  * @return ROK     - success
3209  *         RFAILED - failure
3210  *
3211  * ****************************************************************/
3212 uint8_t BuildRlcBearerToAddModList(struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
3213 {
3214    uint8_t                     idx, elementCnt;
3215
3216    elementCnt = 1;
3217    rlcBearerList->list.count = elementCnt;
3218    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
3219
3220    rlcBearerList->list.array = NULLP;
3221    DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
3222    if(!rlcBearerList->list.array)
3223    {
3224       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3225       return RFAILED;
3226    }
3227
3228    for(idx=0; idx<rlcBearerList->list.count; idx++)
3229    {
3230       rlcBearerList->list.array[idx] = NULLP;
3231       DU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
3232       if(!rlcBearerList->list.array[idx])
3233       {
3234          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3235          return RFAILED;
3236       }
3237    }
3238
3239    idx = 0;
3240    rlcBearerList->list.array[idx]->logicalChannelIdentity = SRB1_LCID;
3241
3242    DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, \
3243       sizeof(struct RLC_BearerConfig__servedRadioBearer));
3244    if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3245    {
3246       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3247       return RFAILED;
3248    }
3249
3250    rlcBearerList->list.array[idx]->servedRadioBearer->present = \
3251       RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
3252    rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = \
3253       SRB1_LCID;
3254
3255    rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3256    rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3257    DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3258    if(!rlcBearerList->list.array[idx]->rlc_Config)
3259    {
3260       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3261       return RFAILED;
3262    }
3263
3264    if(BuildRlcConfig(rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3265    {
3266       DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3267       return RFAILED;
3268    }
3269
3270    rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3271    DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, \
3272       sizeof(struct LogicalChannelConfig));
3273    if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3274    {
3275       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3276       return RFAILED;
3277    }
3278
3279    if(BuildMacLCConfig(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3280    {
3281       DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3282       return RFAILED;
3283    }
3284
3285    return ROK;
3286 }
3287
3288 /*******************************************************************
3289  *
3290  * @brief Build Control resource set to add/modify list
3291  *
3292  * @details
3293  *
3294  *    Function : BuildControlRSetToAddModList
3295  *
3296  *    Functionality: Build Control resource set to add/modify list
3297  *
3298  * @params[in]
3299  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3300  *
3301  * @return ROK     - success
3302  *         RFAILED - failure
3303  *
3304  * ****************************************************************/
3305    uint8_t BuildControlRSetToAddModList
3306 (
3307  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3308  )
3309 {
3310    uint8_t idx;
3311    uint8_t elementCnt;
3312    uint8_t numBytes, bitsUnused;
3313    struct ControlResourceSet *controlRSet;
3314    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3315    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3316
3317
3318    elementCnt = 1;
3319    controlRSetList->list.count = elementCnt;
3320    controlRSetList->list.size = \
3321                                 elementCnt * sizeof(struct ControlResourceSet *);
3322
3323    controlRSetList->list.array = NULLP;
3324    DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3325    if(!controlRSetList->list.array)
3326    {
3327       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3328       return RFAILED;
3329    }
3330
3331    for(idx = 0; idx < elementCnt; idx++)
3332    {
3333       controlRSetList->list.array[idx] = NULLP;
3334       DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3335       if(!controlRSetList->list.array[idx])
3336       {
3337          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3338          return RFAILED;
3339       }
3340    }
3341
3342    idx=0;
3343    controlRSet = controlRSetList->list.array[idx];
3344
3345    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3346
3347    /* size 6 bytes
3348     * 3 LSBs unsued
3349     * Bit string stored ff0000000000
3350     */
3351    numBytes = 6;
3352    bitsUnused = 3;
3353    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3354
3355    controlRSet->frequencyDomainResources.buf = NULLP;
3356    DU_ALLOC(controlRSet->frequencyDomainResources.buf, \
3357          controlRSet->frequencyDomainResources.size);
3358    if(!controlRSet->frequencyDomainResources.buf)
3359    {
3360       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3361       return RFAILED;
3362    }
3363
3364    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3365    coreset0EndPrb = CORESET0_END_PRB;
3366    coreset1StartPrb = coreset0EndPrb + 6;
3367    coreset1NumPrb = CORESET1_NUM_PRB;
3368    /* calculate the PRBs */
3369    freqDomRscAllocType0(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3370    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3371    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3372
3373    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3374    controlRSet->cce_REG_MappingType.present = \
3375                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3376
3377    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3378    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3379    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3380    controlRSet->tci_PresentInDCI = NULLP;
3381 #if 0
3382    uint8_t tciStateIdx;
3383
3384    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3385          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3386    if(!controlRset->tci_StatesPDCCH_ToAddList)
3387    {
3388       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3389       return RFAILED;
3390    }
3391
3392    elementCnt = 1;
3393    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3394    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3395    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3396          controlRset->tci_StatesPDCCH_ToAddList->list.size)
3397       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3398       {
3399          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3400          return RFAILED;
3401       }
3402
3403    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3404    {
3405       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3406       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3407       {
3408          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3409          return RFAILED;
3410       }
3411    }
3412
3413    tciStateIdx = 0;
3414    /* TODO */
3415    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3416
3417    DU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3418    if(!controlRset->tci_PresentInDCI)
3419    {
3420       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3421       return RFAILED;
3422    }
3423    /* TODO */
3424    *(controlRset->tci_PresentInDCI);
3425 #endif
3426
3427    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3428    DU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3429    if(!controlRSet->pdcch_DMRS_ScramblingID)
3430    {
3431       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3432       return RFAILED;
3433    }
3434    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3435
3436    return ROK;
3437 } /* End BuildControlRSetToAddModList */
3438
3439 /*******************************************************************
3440  *
3441  * @brief Build search space to add/modify list
3442  *
3443  * @details
3444  *
3445  *    Function : BuildSearchSpcToAddModList
3446  *
3447  *    Functionality: Build search space to add/modify list
3448  *
3449  * @params[in]
3450  * @return ROK     - success
3451  *         RFAILED - failure
3452  *
3453  * ****************************************************************/
3454    uint8_t BuildSearchSpcToAddModList
3455 (
3456  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
3457  )
3458 {
3459    uint8_t idx;
3460    uint8_t numBytes;
3461    uint8_t byteIdx;
3462    uint8_t bitsUnused;
3463    uint8_t elementCnt;
3464    struct SearchSpace *searchSpc;
3465
3466    elementCnt = 1;
3467    searchSpcList->list.count = elementCnt;
3468    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3469
3470    searchSpcList->list.array = NULLP;
3471    DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3472    if(!searchSpcList->list.array)
3473    {
3474       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3475       return RFAILED;
3476    }
3477
3478    for(idx = 0; idx < elementCnt; idx++)
3479    {
3480       searchSpcList->list.array[idx] = NULLP;
3481       DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3482       if(!searchSpcList->list.array[idx])
3483       {
3484          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3485          return RFAILED;
3486       }
3487    }
3488
3489    idx = 0;
3490    searchSpc = searchSpcList->list.array[idx];
3491
3492    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3493
3494    searchSpc->controlResourceSetId = NULLP;
3495    DU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3496    if(!searchSpc->controlResourceSetId)
3497    {
3498       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3499       return RFAILED;
3500    }
3501    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3502
3503    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3504    DU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
3505          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3506    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3507    {
3508       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3509       return RFAILED;
3510    }
3511    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
3512                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3513
3514    searchSpc->duration = NULLP;
3515    searchSpc->monitoringSymbolsWithinSlot = NULLP;
3516    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3517    if(!searchSpc->monitoringSymbolsWithinSlot)
3518    {
3519       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3520       return RFAILED;
3521    }
3522
3523    /* Values taken from reference logs :
3524     * size 2 bytes
3525     * 2 LSBs unsued
3526     * Bit string stores 8000
3527     */
3528    numBytes = 2;
3529    bitsUnused = 2;
3530
3531    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3532    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3533    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
3534          searchSpc->monitoringSymbolsWithinSlot->size);
3535    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3536    {
3537       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3538       return RFAILED;
3539    }
3540
3541    byteIdx = 0;
3542    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
3543                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3544    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3545    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3546
3547    searchSpc->nrofCandidates = NULLP;
3548    DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3549    if(!searchSpc->nrofCandidates)
3550    {
3551       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3552       return RFAILED;
3553    }
3554
3555    searchSpc->nrofCandidates->aggregationLevel1 = \
3556                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3557    searchSpc->nrofCandidates->aggregationLevel2 = \
3558                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3559    searchSpc->nrofCandidates->aggregationLevel4 = \
3560                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3561    searchSpc->nrofCandidates->aggregationLevel8 = \
3562                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3563    searchSpc->nrofCandidates->aggregationLevel16 = \
3564                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3565
3566    searchSpc->searchSpaceType = NULLP;
3567    DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3568    if(!searchSpc->searchSpaceType)
3569    {
3570       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3571       return RFAILED;
3572    }
3573
3574    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3575
3576    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3577    DU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
3578          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3579    if(!searchSpc->searchSpaceType->choice.ue_Specific)
3580    {
3581       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3582       return RFAILED;
3583    }
3584    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
3585                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3586
3587    return ROK;
3588 }/* End BuildSearchSpcToAddModList */
3589
3590 /*******************************************************************
3591  *
3592  * @brief Builds BWP DL dedicated PDCCH config
3593  *
3594  * @details
3595  *
3596  *    Function : BuildBWPDlDedPdcchCfg
3597  *
3598  *    Functionality: Builds BWP DL dedicated PDCCH config
3599  *
3600  * @params[in] struct PDCCH_Config *pdcchCfg
3601  *
3602  * @return ROK     - success
3603  *         RFAILED - failure
3604  *
3605  * ****************************************************************/
3606 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
3607 {
3608    pdcchCfg->controlResourceSetToAddModList = NULLP;
3609    DU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
3610          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3611    if(!pdcchCfg->controlResourceSetToAddModList)
3612    {
3613       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3614       return RFAILED;
3615    }
3616
3617    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
3618    {
3619       return RFAILED;
3620    }
3621
3622    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3623
3624    pdcchCfg->searchSpacesToAddModList = NULLP;
3625    DU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3626          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3627    if(!pdcchCfg->searchSpacesToAddModList)
3628    {
3629       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3630       return RFAILED;
3631    }
3632
3633    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3634    {
3635       return RFAILED;
3636    }
3637
3638    pdcchCfg->searchSpacesToReleaseList = NULLP;
3639    pdcchCfg->downlinkPreemption = NULLP;
3640    pdcchCfg->tpc_PUSCH = NULLP;
3641    pdcchCfg->tpc_PUCCH = NULLP;
3642    pdcchCfg->tpc_SRS = NULLP;
3643
3644    return ROK;
3645 }
3646
3647 /*******************************************************************
3648  *
3649  * @brief Builds DMRS DL PDSCH Mapping type A
3650  *
3651  * @details
3652  *
3653  *    Function : BuildDMRSDLPdschMapTypeA
3654  *
3655  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3656  *
3657  * @params[in]
3658  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3659  * @return ROK     - success
3660  *         RFAILED - failure
3661  *
3662  * ****************************************************************/
3663    uint8_t BuildDMRSDLPdschMapTypeA
3664 (
3665  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3666  )
3667 {
3668    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3669    dmrsDlCfg->choice.setup = NULLP;
3670    DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3671    if(!dmrsDlCfg->choice.setup)
3672    {
3673       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3674       return RFAILED;
3675    }
3676
3677    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3678    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3679    DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3680    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3681    {
3682       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3683       return RFAILED;
3684    }
3685    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3686
3687    dmrsDlCfg->choice.setup->maxLength = NULLP;
3688    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3689    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3690    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3691
3692    return ROK;
3693 }
3694
3695 /*******************************************************************
3696  *
3697  * @brief Builds TCI states to add/modify list
3698  *
3699  * @details
3700  *
3701  *    Function : BuildTCIStatesToAddModList
3702  *
3703  *    Functionality:Builds TCI states to add/modify list
3704  *
3705  * @params[in]
3706  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3707  *
3708  * @return ROK     - success
3709  *         RFAILED - failure
3710  *
3711  * ****************************************************************/
3712 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3713 {
3714    return ROK;
3715 }
3716
3717 /*******************************************************************
3718  *
3719  * @brief Builds PDSCH time domain allocation list
3720  *
3721  * @details
3722  *
3723  *    Function : BuildPdschTimeDomAllocList
3724  *
3725  *    Functionality: Builds PDSCH time domain allocation list
3726  *
3727  * @params[in]
3728  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3729  *
3730  * @return ROK     - success
3731  *         RFAILED - failure
3732  *
3733  * ****************************************************************/
3734    uint8_t BuildPdschTimeDomAllocList
3735 (
3736  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3737  )
3738 {
3739    uint8_t idx;
3740    uint8_t elementCnt;
3741    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3742
3743    timeDomAllocList->present = \
3744                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3745
3746    timeDomAllocList->choice.setup = NULLP;
3747    DU_ALLOC(timeDomAllocList->choice.setup, \
3748          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3749    if(!timeDomAllocList->choice.setup)
3750    {
3751       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3752       return RFAILED;
3753    }
3754
3755    elementCnt = 2;
3756    timeDomAllocList->choice.setup->list.count = elementCnt;
3757    timeDomAllocList->choice.setup->list.size = \
3758                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3759
3760    timeDomAllocList->choice.setup->list.array = NULLP;
3761    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3762          timeDomAllocList->choice.setup->list.size);
3763    if(!timeDomAllocList->choice.setup->list.array)
3764    {
3765       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3766       return RFAILED;
3767    }
3768
3769    for(idx = 0; idx < elementCnt; idx++)
3770    {
3771       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3772       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3773             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3774       if(!timeDomAllocList->choice.setup->list.array[idx])
3775       {
3776          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3777          return RFAILED;
3778       }
3779    }
3780
3781    idx = 0;
3782    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3783    DU_ALLOC(timeDomAlloc->k0, sizeof(long));
3784    if(!timeDomAlloc->k0)
3785    {
3786       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3787       return RFAILED;
3788    }
3789    *(timeDomAlloc->k0) = 0;
3790    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3791    timeDomAlloc->startSymbolAndLength = \
3792                                         calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
3793
3794    idx++;
3795    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3796    DU_ALLOC(timeDomAlloc->k0, sizeof(long));
3797    if(!timeDomAlloc->k0)
3798    {
3799       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3800       return RFAILED;
3801    }
3802    *(timeDomAlloc->k0) = 1;
3803    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3804    timeDomAlloc->startSymbolAndLength = calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
3805
3806    return ROK;
3807 }
3808
3809 /*******************************************************************
3810  *
3811  * @brief Builds PDSCH PRB Bundling type
3812  *
3813  * @details
3814  *
3815  *    Function : BuildPdschPrbBundlingType
3816  *
3817  *    Functionality: Builds PDSCH PRB Bundling type
3818  *
3819  * @params[in]
3820  * struct PDSCH_Config__prb_BundlingType *prbBndlType
3821  *
3822  * @return ROK     - success
3823  *         RFAILED - failure
3824  *
3825  * ****************************************************************/
3826    uint8_t BuildPdschPrbBundlingType
3827 (
3828  struct PDSCH_Config__prb_BundlingType *prbBndlType
3829  )
3830 {
3831    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
3832
3833    prbBndlType->choice.staticBundling = NULLP;
3834    DU_ALLOC(prbBndlType->choice.staticBundling, \
3835          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
3836    if(!prbBndlType->choice.staticBundling)
3837    {
3838       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
3839       return RFAILED;
3840    }
3841    prbBndlType->choice.staticBundling->bundleSize = NULLP;
3842
3843    return ROK;
3844 }
3845
3846 /*******************************************************************
3847  *
3848  * @brief Builds BWP DL dedicated PDSCH config
3849  *
3850  * @details
3851  *
3852  *    Function : BuildBWPDlDedPdschCfg
3853  *
3854  *    Functionality: Builds BWP DL dedicated PDSCH config
3855  *
3856  * @params[in] struct PDSCH_Config *pdschCfg
3857  *
3858  * @return ROK     - success
3859  *         RFAILED - failure
3860  *
3861  * ****************************************************************/
3862 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
3863 {
3864    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
3865
3866    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
3867    DU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
3868          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
3869    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
3870    {
3871       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3872       return RFAILED;
3873    }
3874
3875    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
3876    {
3877       return RFAILED;
3878    }
3879
3880    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
3881    pdschCfg->tci_StatesToAddModList = NULLP;
3882    pdschCfg->tci_StatesToReleaseList = NULLP;
3883    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
3884 #if 0
3885    DU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
3886    if(!pdschCfg->tci_StatesToAddModList)
3887    {
3888       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3889       return RFAILED;
3890    }
3891    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
3892    {
3893       return RFAILED;
3894    }
3895 #endif
3896
3897    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
3898
3899    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
3900    DU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
3901          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
3902    if(!pdschCfg->pdsch_TimeDomainAllocationList)
3903    {
3904       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3905       return RFAILED;
3906    }
3907
3908    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
3909    {
3910       return RFAILED;
3911    }
3912
3913    pdschCfg->pdsch_AggregationFactor = NULLP;
3914    pdschCfg->rateMatchPatternToAddModList = NULLP;
3915    pdschCfg->rateMatchPatternToReleaseList = NULLP;
3916    pdschCfg->rateMatchPatternGroup1 = NULLP;
3917    pdschCfg->rateMatchPatternGroup2 = NULLP;
3918    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
3919    pdschCfg->mcs_Table = NULLP;
3920
3921    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
3922    DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
3923    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
3924    {
3925       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3926       return RFAILED;
3927    }
3928    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
3929
3930    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
3931    {
3932       return RFAILED;
3933    }
3934
3935    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
3936    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
3937    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3938    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3939    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3940    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3941    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
3942
3943    return ROK;
3944 }
3945
3946 /*******************************************************************
3947  *
3948  * @brief Builds intitial DL BWP
3949  * @details
3950  *
3951  *    Function : BuildInitialDlBWP
3952  *
3953  *    Functionality: Builds intitial DL BWP in spCellCfgDed
3954  *
3955  * @params[in] BWP_DownlinkDedicated_t *dlBwp
3956  *
3957  * @return ROK     - success
3958  *         RFAILED - failure
3959  *
3960  * ****************************************************************/
3961 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
3962 {
3963    dlBwp->pdcch_Config = NULLP;
3964    DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
3965    if(!dlBwp->pdcch_Config)
3966    {
3967       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3968       return RFAILED;
3969    }
3970    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
3971
3972    dlBwp->pdcch_Config->choice.setup = NULLP;
3973    DU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
3974    if(!dlBwp->pdcch_Config->choice.setup)
3975    {
3976       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3977       return RFAILED;
3978    }
3979    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
3980    {
3981       return RFAILED;
3982    }
3983
3984    dlBwp->pdsch_Config = NULLP;
3985    DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
3986    if(!dlBwp->pdsch_Config)
3987    {
3988       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3989       return RFAILED;
3990    }
3991    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
3992
3993    dlBwp->pdsch_Config->choice.setup = NULLP;
3994    DU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
3995    if(!dlBwp->pdsch_Config->choice.setup)
3996    {
3997       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
3998       return RFAILED;
3999    }
4000
4001    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
4002    {
4003       return RFAILED;
4004    }
4005
4006    dlBwp->sps_Config = NULLP;
4007    dlBwp->radioLinkMonitoringConfig = NULLP;
4008    return ROK;
4009 }
4010
4011 /*******************************************************************
4012  *
4013  * @brief Builds DMRS UL Pusch Mapping type A
4014  *
4015  * @details
4016  *
4017  *    Function : BuildDMRSULPuschMapTypeA
4018  *
4019  *    Functionality: Builds DMRS UL Pusch Mapping type A
4020  *
4021  * @params[in]
4022  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4023  * @return ROK     - success
4024  *         RFAILED - failure
4025  *
4026  * ****************************************************************/
4027    uint8_t BuildDMRSULPuschMapTypeA
4028 (
4029  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4030  )
4031 {
4032    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
4033    dmrsUlCfg->choice.setup= NULLP;
4034    DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
4035    if(!dmrsUlCfg->choice.setup)
4036    {
4037       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4038       return RFAILED;
4039    }
4040
4041    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
4042    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
4043    DU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
4044    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4045    {
4046       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4047       return RFAILED;
4048    }
4049    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
4050
4051    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
4052    dmrsUlCfg->choice.setup->maxLength = NULLP;
4053    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
4054    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
4055          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4056    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4057    {
4058       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4059       return RFAILED;
4060    }
4061
4062    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
4063    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4064          sizeof(long));
4065    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
4066    {
4067       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4068       return RFAILED;
4069    }
4070    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
4071
4072    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
4073    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
4074    return ROK;
4075 }
4076
4077 /*******************************************************************
4078  *
4079  * @brief Build PUSCH time domain allocation list
4080  *
4081  * @details
4082  *
4083  *    Function : BuildPuschTimeDomAllocList
4084  *
4085  *    Functionality: Build PUSCH time domain allocation list
4086  *
4087  * @params[in]
4088  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4089  *
4090  * @return ROK     - success
4091  *         RFAILED - failure
4092  *
4093  * ****************************************************************/
4094    uint8_t BuildPuschTimeDomAllocList
4095 (
4096  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4097  )
4098 {
4099    uint8_t idx;
4100    uint8_t elementCnt;
4101    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
4102
4103    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
4104    timeDomAllocList->choice.setup = NULLP;
4105    DU_ALLOC(timeDomAllocList->choice.setup, \
4106          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4107    if(!timeDomAllocList->choice.setup)
4108    {
4109       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4110       return RFAILED;
4111    }
4112
4113    elementCnt = 2;
4114    timeDomAllocList->choice.setup->list.count = elementCnt;
4115    timeDomAllocList->choice.setup->list.size = \
4116                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
4117    timeDomAllocList->choice.setup->list.array = NULLP;
4118    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
4119          timeDomAllocList->choice.setup->list.size);
4120    if(!timeDomAllocList->choice.setup->list.array)
4121    {
4122       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4123       return RFAILED;
4124    }
4125
4126    for(idx = 0; idx < elementCnt; idx++)
4127    {
4128       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4129       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
4130             sizeof(PUSCH_TimeDomainResourceAllocation_t));
4131       if(!timeDomAllocList->choice.setup->list.array[idx])
4132       {
4133          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4134          return RFAILED;
4135       }
4136    }
4137
4138    idx = 0;
4139    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4140    DU_ALLOC(timeDomAlloc->k2, sizeof(long));
4141    if(!timeDomAlloc->k2)
4142    {
4143       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4144       return RFAILED;
4145    }
4146    *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
4147    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4148    timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
4149
4150    idx++;
4151    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4152    DU_ALLOC(timeDomAlloc->k2, sizeof(long));
4153    if(!timeDomAlloc->k2)
4154    {
4155       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4156       return RFAILED;
4157    }
4158    *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
4159    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4160    timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
4161
4162    return ROK;
4163 }
4164
4165 /*******************************************************************
4166  *
4167  * @brief Builds BWP UL dedicated PUSCH Config
4168  *
4169  * @details
4170  *
4171  *    Function : BuildBWPUlDedPuschCfg
4172  *
4173  *    Functionality:
4174  *      Builds BWP UL dedicated PUSCH Config
4175  *
4176  * @params[in] : PUSCH_Config_t *puschCfg
4177  *
4178  * @return ROK     - success
4179  *         RFAILED - failure
4180  *
4181  * ****************************************************************/
4182 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
4183 {
4184    puschCfg->dataScramblingIdentityPUSCH = NULLP;
4185    DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4186    if(!puschCfg->dataScramblingIdentityPUSCH)
4187    {
4188       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4189       return RFAILED;
4190    }
4191    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
4192
4193    puschCfg->txConfig = NULLP;
4194    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4195    DU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4196          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4197    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4198    {
4199       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4200       return RFAILED;
4201    }
4202
4203    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4204    {
4205       return RFAILED;
4206    }
4207
4208    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4209    puschCfg->pusch_PowerControl = NULLP;
4210    puschCfg->frequencyHopping = NULLP;
4211    puschCfg->frequencyHoppingOffsetLists = NULLP;
4212    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4213
4214    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4215    DU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
4216          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4217    if(!puschCfg->pusch_TimeDomainAllocationList)
4218    {
4219       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4220       return RFAILED;
4221    }
4222
4223    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
4224    {
4225       return RFAILED;
4226    }
4227
4228    puschCfg->pusch_AggregationFactor = NULLP;
4229    puschCfg->mcs_Table = NULLP;
4230    puschCfg->mcs_TableTransformPrecoder = NULLP;
4231    puschCfg->transformPrecoder = NULLP;
4232    DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4233    if(!puschCfg->transformPrecoder)
4234    {
4235       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4236       return RFAILED;
4237    }
4238    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4239
4240    puschCfg->codebookSubset = NULLP;
4241    puschCfg->maxRank = NULLP;
4242    puschCfg->rbg_Size = NULLP;
4243    puschCfg->uci_OnPUSCH = NULLP;
4244    puschCfg->tp_pi2BPSK = NULLP;
4245
4246    return ROK;
4247 }
4248
4249 /*******************************************************************
4250  *
4251  * @brief Builds BWP UL dedicated PUCCH Config
4252  *
4253  * @details
4254  *
4255  *    Function : BuildBWPUlDedPucchCfg
4256  *
4257  *    Functionality:
4258  *      Builds BWP UL dedicated PUCCH Config
4259  *
4260  * @params[in] : PUCCH_Config_t *pucchCfg
4261  *
4262  * @return ROK     - success
4263  *         RFAILED - failure
4264  *
4265  * ****************************************************************/
4266 uint8_t BuildBWPUlDedPucchCfg(PUCCH_Config_t *pucchCfg)
4267 {
4268    uint8_t arrIdx, elementCnt;
4269
4270    DU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
4271    if(pucchCfg->dl_DataToUL_ACK == NULLP)
4272    {
4273       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4274       return RFAILED;
4275    }
4276
4277    elementCnt = 2;
4278    pucchCfg->dl_DataToUL_ACK->list.count = elementCnt;
4279    pucchCfg->dl_DataToUL_ACK->list.size = elementCnt * sizeof(long *);
4280    DU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
4281    if(pucchCfg->dl_DataToUL_ACK->list.array == NULLP)
4282    {
4283       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4284       return RFAILED;
4285    }
4286
4287    for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
4288    {
4289       DU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
4290       if(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx] == NULLP)
4291       {
4292           DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4293           return RFAILED;
4294       }
4295    }
4296
4297    arrIdx = 0;
4298    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx++]) = 1;
4299    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx]) = 2;
4300    return ROK;
4301 }
4302
4303 /*******************************************************************
4304  *
4305  * @brief Fills SRS resource to add/modify list
4306  *
4307  * @details
4308  *
4309  *    Function : BuildSrsRsrcAddModList
4310  *
4311  *    Functionality: Fills SRS resource to add/modify list
4312  *
4313  * @params[in]
4314  * @return ROK     - success
4315  *         RFAILED - failure
4316  *
4317  * ****************************************************************/
4318 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
4319 {
4320    uint8_t   elementCnt;
4321    uint8_t   rsrcIdx;
4322
4323    elementCnt = 1;
4324    resourceList->list.count = elementCnt;
4325    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
4326    resourceList->list.array = NULLP;
4327    DU_ALLOC(resourceList->list.array, resourceList->list.size);
4328    if(!resourceList->list.array)
4329    {
4330       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4331       return RFAILED;
4332    }
4333
4334    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4335    {
4336       DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4337       if(!resourceList->list.array[rsrcIdx])
4338       {
4339          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4340          return RFAILED;
4341       }
4342    }
4343
4344    rsrcIdx = 0;
4345    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
4346    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
4347    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
4348
4349    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
4350    DU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
4351          sizeof(struct SRS_Resource__transmissionComb__n2));
4352    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
4353    {
4354       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4355       return RFAILED;
4356    }
4357    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
4358       = SRS_COMB_OFFSET_N2;
4359    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
4360       = SRS_CYCLIC_SHIFT_N2;
4361
4362    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
4363                                                                       PUSCH_START_SYMBOL;
4364    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
4365                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
4366    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
4367                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
4368
4369    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
4370    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
4371    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
4372    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
4373    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
4374    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
4375                                                                SRS_Resource__groupOrSequenceHopping_neither;
4376
4377    /* Setting resource type to aperiodic for intergration purposes */
4378    resourceList->list.array[rsrcIdx]->resourceType.present = \
4379                                                              SRS_Resource__resourceType_PR_aperiodic;
4380    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
4381    DU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
4382          sizeof(struct SRS_Resource__resourceType__aperiodic));
4383    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
4384    {
4385       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4386       return RFAILED;
4387    }
4388    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
4389
4390    return ROK;
4391 }
4392
4393 /*******************************************************************
4394  *
4395  * @brief Build SRS resource set Add/mod list
4396  *
4397  * @details
4398  *
4399  *    Function : BuildSrsRsrcSetAddModList
4400  *
4401  *    Functionality: Build SRS resource set Add/mod list
4402  *
4403  * @params[in]
4404  * @return ROK     - success
4405  *         RFAILED - failure
4406  *
4407  * ****************************************************************/
4408    uint8_t BuildSrsRsrcSetAddModList
4409 (
4410  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
4411  )
4412 {
4413    uint8_t  elementCnt;
4414    uint8_t  rSetIdx;
4415    uint8_t  rsrcIdx;
4416    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
4417
4418    elementCnt = 1;
4419    rsrcSetList->list.count = elementCnt;
4420    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
4421    rsrcSetList->list.array = NULLP;
4422    DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
4423    if(!rsrcSetList->list.array)
4424    {
4425       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4426       return RFAILED;
4427    }
4428
4429    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4430    {
4431       DU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4432       if(!rsrcSetList->list.array[rSetIdx])
4433       {
4434          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4435          return RFAILED;
4436       }
4437    }
4438
4439    rSetIdx = 0;
4440    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
4441
4442    /* Fill Resource Id list in resource set */
4443    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
4444    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4445          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4446    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4447    {
4448       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4449       return RFAILED;
4450    }
4451
4452    elementCnt = 1;
4453    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4454    rsrcIdList->list.count = elementCnt;
4455    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
4456    rsrcIdList->list.array = NULLP;
4457    DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
4458    if(!rsrcIdList->list.array)
4459    {
4460       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4461       return RFAILED;
4462    }
4463
4464    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4465    {
4466       DU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4467       if(!rsrcIdList->list.array[rsrcIdx])
4468       {
4469          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4470          return RFAILED;
4471       }
4472    }
4473
4474    rsrcIdx = 0;
4475    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
4476
4477    /* Fill resource type */
4478    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
4479                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
4480
4481    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
4482    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4483          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4484    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
4485    {
4486       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4487       return RFAILED;
4488    }
4489    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
4490       = APERIODIC_SRS_RESRC_TRIGGER;
4491
4492    /* TODO : Fill values for below IEs as expected by Viavi */
4493    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
4494    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
4495
4496
4497    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
4498    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
4499    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
4500    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
4501    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
4502
4503    return ROK;
4504 }
4505
4506 /*******************************************************************
4507  *
4508  * @brief Builds BWP UL dedicated SRS Config
4509  *
4510  * @details
4511  *
4512  *    Function : BuildBWPUlDedSrsCfg
4513  *
4514  *    Functionality: Builds BWP UL dedicated SRS Config
4515  *
4516  * @params[in] SRS Config
4517  * @return ROK     - success
4518  *         RFAILED - failure
4519  *
4520  * ****************************************************************/
4521 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
4522 {
4523    srsCfg->srs_ResourceSetToReleaseList = NULLP;
4524    srsCfg->srs_ResourceSetToAddModList = NULLP;
4525    DU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
4526          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4527    if(!srsCfg->srs_ResourceSetToAddModList)
4528    {
4529       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4530       return RFAILED;
4531    }
4532    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
4533    {
4534       return RFAILED;
4535    }
4536
4537    srsCfg->srs_ResourceToReleaseList = NULLP;
4538
4539    /* Resource to Add/Modify list */
4540    srsCfg->srs_ResourceToAddModList = NULLP;
4541    DU_ALLOC(srsCfg->srs_ResourceToAddModList, \
4542          sizeof(struct SRS_Config__srs_ResourceToAddModList));
4543    if(!srsCfg->srs_ResourceToAddModList)
4544    {
4545       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4546       return RFAILED;
4547    }
4548
4549    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
4550    {
4551       return RFAILED;
4552    }
4553
4554    srsCfg->tpc_Accumulation = NULLP;
4555
4556    return ROK;
4557 }
4558
4559
4560
4561 /*******************************************************************
4562  *
4563  * @brief Builds Pusch Serving cell Config
4564  *
4565  * @details
4566  *
4567  *    Function : BuildPuschSrvCellCfg
4568  *
4569  *    Functionality: Builds Pusch Serving cell Config
4570  *
4571  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
4572  *
4573  * @return ROK     - success
4574  *         RFAILED - failure
4575  *
4576  * ****************************************************************/
4577 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
4578 {
4579    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
4580    puschCfg->choice.setup = NULLP;
4581    DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4582    if(!puschCfg->choice.setup)
4583    {
4584       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4585       return RFAILED;
4586    }
4587
4588    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4589    puschCfg->choice.setup->rateMatching = NULLP;
4590    puschCfg->choice.setup->xOverhead = NULLP;
4591    puschCfg->choice.setup->ext1 = NULLP;
4592    DU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
4593    if(!puschCfg->choice.setup->ext1)
4594    {
4595       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4596       return RFAILED;
4597    }
4598
4599    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
4600    DU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
4601    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
4602    {
4603       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4604       return RFAILED;
4605    }
4606    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
4607
4608    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
4609    DU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
4610    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
4611    {
4612       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4613       return RFAILED;
4614    }
4615    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
4616    return ROK;
4617 }
4618
4619 /*******************************************************************
4620  *
4621  * @brief Builds inital UL BWP
4622  *
4623  * @details
4624  *
4625  *    Function : BuildInitialUlBWP
4626  *
4627  *    Functionality: Builds initial UL BWP
4628  *
4629  * @params[in] BWP_UplinkDedicated_t *ulBwp
4630  * @return ROK     - success
4631  *         RFAILED - failure
4632  *
4633  * ****************************************************************/
4634 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4635 {
4636    ulBwp->pucch_Config = NULLP;
4637    DU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
4638    if(!ulBwp->pucch_Config)
4639    {
4640       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4641       return RFAILED;
4642    }
4643
4644    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
4645    ulBwp->pucch_Config->choice.setup = NULLP;
4646    DU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
4647    if(!ulBwp->pucch_Config->choice.setup)
4648    {
4649       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4650       return RFAILED;
4651    }
4652
4653    if(BuildBWPUlDedPucchCfg(ulBwp->pucch_Config->choice.setup) != ROK)
4654    {
4655       return RFAILED;
4656    }
4657
4658    /* Fill BWP UL dedicated PUSCH config */
4659    ulBwp->pusch_Config = NULLP;
4660    DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4661    if(!ulBwp->pusch_Config)
4662    {
4663       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4664       return RFAILED;
4665    }
4666
4667    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
4668    ulBwp->pusch_Config->choice.setup = NULLP;
4669    DU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4670    if(!ulBwp->pusch_Config->choice.setup)
4671    {
4672       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4673       return RFAILED;
4674    }
4675
4676    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
4677    {
4678       return RFAILED;
4679    }
4680
4681    ulBwp->configuredGrantConfig = NULLP;
4682
4683    /* Fill BPW UL dedicated SRS config */
4684    ulBwp->srs_Config = NULLP;
4685    DU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4686    if(!ulBwp->srs_Config)
4687    {
4688       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4689       return RFAILED;
4690    }
4691
4692    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
4693    ulBwp->srs_Config->choice.setup = NULLP;
4694    DU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4695    if(!ulBwp->srs_Config->choice.setup)
4696    {
4697       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4698       return RFAILED;
4699    }
4700
4701    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
4702    {
4703       return RFAILED;
4704    }
4705
4706    ulBwp->beamFailureRecoveryConfig = NULLP;
4707
4708    return ROK;
4709 }
4710
4711 /*******************************************************************
4712  *
4713  * @brief Builds UL config
4714  * @details
4715  *
4716  *    Function : BuildUlCfg
4717  *
4718  *    Functionality: Builds UL config in spCellCfgDed
4719  *
4720  * @params[in] UplinkConfig_t *ulCfg
4721  *
4722  * @return ROK     - success
4723  *         RFAILED - failure
4724  *
4725  * ****************************************************************/
4726 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
4727 {
4728    ulCfg->initialUplinkBWP = NULLP;
4729    DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4730    if(!ulCfg->initialUplinkBWP)
4731    {
4732       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4733       return RFAILED;
4734    }
4735
4736    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
4737    {
4738       return RFAILED;
4739    }
4740
4741    ulCfg->uplinkBWP_ToReleaseList = NULLP;
4742    ulCfg->uplinkBWP_ToAddModList = NULLP;
4743    ulCfg->firstActiveUplinkBWP_Id = NULLP;
4744    DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4745    if(!ulCfg->firstActiveUplinkBWP_Id)
4746    {
4747       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4748       return RFAILED;
4749    }
4750    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
4751
4752    ulCfg->pusch_ServingCellConfig = NULLP;
4753    DU_ALLOC(ulCfg->pusch_ServingCellConfig, \
4754          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4755    if(!ulCfg->pusch_ServingCellConfig)
4756    {
4757       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4758       return RFAILED;
4759    }
4760
4761    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
4762    {
4763       return RFAILED;
4764    }
4765
4766    ulCfg->carrierSwitching = NULLP;
4767    ulCfg->ext1 = NULLP;
4768    return ROK;
4769 }
4770
4771 /*******************************************************************
4772  *
4773  * @brief Builds PDSCH serving cell config
4774  * @details
4775  *
4776  *    Function : BuildPdschSrvCellCfg
4777  *
4778  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
4779  *
4780  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
4781  *
4782  * @return ROK     - success
4783  *         RFAILED - failure
4784  *
4785  * ****************************************************************/
4786 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
4787 {
4788    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
4789    pdschCfg->choice.setup = NULLP;
4790    DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
4791    if(!pdschCfg->choice.setup)
4792    {
4793       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4794       return RFAILED;
4795    }
4796
4797    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4798    pdschCfg->choice.setup->xOverhead = NULLP;
4799    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
4800    DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
4801    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
4802    {
4803       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4804       return RFAILED;
4805    }
4806    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
4807    pdschCfg->choice.setup->pucch_Cell = NULLP;
4808    pdschCfg->choice.setup->ext1 = NULLP;
4809
4810    return ROK;
4811 }
4812
4813 /*******************************************************************
4814  *
4815  * @brief Builds CSI Meas config
4816  * @details
4817  *
4818  *    Function : BuildCsiMeasCfg
4819  *
4820  *    Functionality: Builds CSI Meas config in spCellCfgDed
4821  *
4822  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
4823  *
4824  * @return ROK     - success
4825  *         RFAILED - failure
4826  *
4827  * ****************************************************************/
4828 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
4829 {
4830
4831    return ROK;
4832 }
4833
4834 /*******************************************************************
4835  *
4836  * @brief Builds Spcell config dedicated
4837  * @details
4838  *
4839  *    Function : BuildSpCellCfgDed
4840  *
4841  *    Functionality: Builds sp cell config dedicated in spCellCfg
4842  *
4843  * @params[in] ServingCellConfig_t srvCellCfg
4844  *
4845  * @return ROK     - success
4846  *         RFAILED - failure
4847  *
4848  * ****************************************************************/
4849 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
4850 {
4851    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
4852    DU_ALLOC(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
4853    if(!srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
4854    {
4855       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4856       return RFAILED;
4857    }
4858
4859    srvCellCfg->initialDownlinkBWP = NULLP;
4860    DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
4861    if(!srvCellCfg->initialDownlinkBWP)
4862    {
4863       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4864       return RFAILED;
4865    }
4866
4867    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
4868    {
4869       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
4870       return RFAILED;
4871    }
4872    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
4873    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
4874
4875    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
4876    DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
4877    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
4878    {
4879       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4880       return RFAILED;
4881    }
4882    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4883
4884    srvCellCfg->bwp_InactivityTimer = NULLP;
4885
4886    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
4887    DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
4888    if(!srvCellCfg->defaultDownlinkBWP_Id)
4889    {
4890       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4891       return RFAILED;
4892    }
4893    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4894
4895    srvCellCfg->uplinkConfig = NULLP;
4896    DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
4897    if(!srvCellCfg->uplinkConfig)
4898    {
4899       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4900       return RFAILED;
4901    }
4902
4903    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
4904    {
4905       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
4906       return RFAILED;
4907    }
4908    srvCellCfg->supplementaryUplink = NULLP;
4909    srvCellCfg->pdcch_ServingCellConfig = NULLP;
4910
4911    srvCellCfg->pdsch_ServingCellConfig = NULLP;
4912    DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
4913    if(!srvCellCfg->pdsch_ServingCellConfig)
4914    {
4915       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4916       return RFAILED;
4917    }
4918
4919    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
4920    {
4921       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
4922       return RFAILED;
4923    }
4924
4925    srvCellCfg->csi_MeasConfig = NULLP;
4926 #if 0
4927    DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
4928       if(!srvCellCfg->csi_MeasConfig)
4929       {
4930          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4931          return RFAILED;
4932       }
4933
4934    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
4935    {
4936       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
4937       return RFAILED;
4938    }
4939 #endif
4940    srvCellCfg->sCellDeactivationTimer = NULLP;
4941    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
4942    srvCellCfg->tag_Id = TAG_ID;
4943    srvCellCfg->dummy = NULLP;
4944    srvCellCfg->pathlossReferenceLinking = NULLP;
4945    srvCellCfg->servingCellMO = NULLP;
4946    srvCellCfg->ext1 = NULLP;
4947
4948    return ROK;
4949 }
4950 /*******************************************************************
4951  *
4952  * @brief Builds Spcell config
4953  *
4954  * @details
4955  *
4956  *    Function : BuildSpCellCfg
4957  *
4958  *    Functionality: Builds sp cell config in DuToCuRrcContainer
4959  *
4960  * @params[in] SpCellConfig_t spCellCfg
4961  *
4962  * @return ROK     - success
4963  *         RFAILED - failure
4964  *
4965  * ****************************************************************/
4966 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
4967 {
4968
4969    spCellCfg->servCellIndex = NULLP;
4970    DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
4971    if(!spCellCfg->servCellIndex)
4972    {
4973       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4974       return RFAILED;
4975    }
4976    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
4977
4978    spCellCfg->reconfigurationWithSync = NULLP;
4979    spCellCfg->rlf_TimersAndConstants = NULLP;
4980    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
4981    DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
4982    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
4983    {
4984       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4985       return RFAILED;
4986    }
4987    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
4988
4989    spCellCfg->spCellConfigDedicated = NULLP;
4990    DU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
4991    if(!spCellCfg->spCellConfigDedicated)
4992    {
4993       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
4994       return RFAILED;
4995    }
4996    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
4997    {
4998       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
4999       return RFAILED;
5000    }
5001    return ROK;
5002 }
5003 /*******************************************************************
5004  *
5005  * @brief Builds Phy cell group config
5006  *
5007  * @details
5008  *
5009  *    Function : BuildPhyCellGrpCfg
5010  *
5011  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
5012  *
5013  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
5014  *
5015  * @return ROK     - success
5016  *         RFAILED - failure
5017  *
5018  * ****************************************************************/
5019 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
5020 {
5021    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
5022    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
5023
5024    phyCellGrpCfg->p_NR_FR1 = NULLP;
5025    DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5026    if(!phyCellGrpCfg->p_NR_FR1)
5027    {
5028       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
5029       return RFAILED;
5030    }
5031    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
5032    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
5033    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
5034    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
5035    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
5036    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
5037    phyCellGrpCfg->cs_RNTI = NULLP;
5038    phyCellGrpCfg->ext1 = NULLP;
5039    phyCellGrpCfg->ext2 = NULLP;
5040
5041    return ROK;
5042 }
5043 /*******************************************************************
5044  *
5045  * @brief Builds Mac cell group config
5046  *
5047  * @details
5048  *
5049  *    Function : BuildMacCellGrpCfg
5050  *
5051  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
5052  *
5053  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
5054  *
5055  * @return ROK     - success
5056  *         RFAILED - failure
5057  *
5058  * ****************************************************************/
5059 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
5060 {
5061    macCellGrpCfg->drx_Config = NULLP;
5062    macCellGrpCfg->schedulingRequestConfig = NULLP;
5063    DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5064    if(!macCellGrpCfg->schedulingRequestConfig)
5065    {
5066       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5067       return RFAILED;
5068    }
5069
5070    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
5071    {
5072       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
5073       return RFAILED;
5074    }
5075
5076    macCellGrpCfg->bsr_Config = NULLP;
5077    DU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5078    if(!macCellGrpCfg->bsr_Config)
5079    {
5080       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5081       return RFAILED;
5082    }
5083
5084    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
5085    {
5086       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
5087       return RFAILED;
5088    }
5089
5090    macCellGrpCfg->tag_Config = NULLP;
5091    DU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
5092    if(!macCellGrpCfg->tag_Config)
5093    {
5094       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5095       return RFAILED;
5096    }
5097
5098    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
5099    {
5100       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
5101       return RFAILED;
5102    }
5103
5104    macCellGrpCfg->phr_Config = NULLP;
5105    DU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
5106    if(!macCellGrpCfg->phr_Config)
5107    {
5108       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5109       return RFAILED;
5110    }
5111
5112    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
5113    {
5114       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
5115       return RFAILED;
5116    }
5117
5118    macCellGrpCfg->skipUplinkTxDynamic = false;
5119    macCellGrpCfg->ext1 = NULLP;
5120
5121    return ROK;
5122 }
5123 /*******************************************************************
5124  *
5125  * @brief Frees memeory allocated for SearchSpcToAddModList
5126  *
5127  * @details
5128  *
5129  *    Function : FreeSearchSpcToAddModList
5130  *
5131  *    Functionality: Deallocating memory of SearchSpcToAddModList
5132  *
5133  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
5134  *
5135  * @return void
5136  *
5137  4221 * ****************************************************************/
5138 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
5139 {
5140    uint8_t idx1=0;
5141    uint8_t idx2=0;
5142    struct  SearchSpace *searchSpc=NULLP;
5143
5144    if(searchSpcList->list.array)
5145    {
5146       if(searchSpcList->list.array[idx2])
5147       {
5148          searchSpc = searchSpcList->list.array[idx2];
5149          if(searchSpc->controlResourceSetId)
5150          {
5151             if(searchSpc->monitoringSlotPeriodicityAndOffset)
5152             {
5153                if(searchSpc->monitoringSymbolsWithinSlot)
5154                {
5155                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
5156                   {
5157                      if(searchSpc->nrofCandidates)
5158                      {
5159                         if(searchSpc->searchSpaceType)
5160                         {
5161                            DU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
5162                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
5163                            DU_FREE(searchSpc->searchSpaceType, sizeof(struct
5164                                     SearchSpace__searchSpaceType));
5165                         }
5166                         DU_FREE(searchSpc->nrofCandidates,
5167                               sizeof(struct SearchSpace__nrofCandidates));
5168                      }
5169                      DU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
5170                            searchSpc->monitoringSymbolsWithinSlot->size);
5171                   }
5172                   DU_FREE(searchSpc->monitoringSymbolsWithinSlot,
5173                         sizeof(BIT_STRING_t));
5174                }
5175                DU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
5176                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
5177             }
5178             DU_FREE(searchSpc->controlResourceSetId,
5179                   sizeof(ControlResourceSetId_t));
5180          }
5181       }
5182       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
5183       {
5184          DU_FREE(searchSpcList->list.array[idx1],
5185                sizeof(struct SearchSpace));
5186       }
5187       DU_FREE(searchSpcList->list.array,searchSpcList->list.size);
5188    }
5189 }
5190 /*******************************************************************
5191  *
5192  * @brief Frees memory allocated for PdschTimeDomAllocList
5193  *
5194  * @details
5195  *
5196  *    Function : FreePdschTimeDomAllocList
5197  *
5198  *    Functionality: Deallocating memory of PdschTimeDomAllocList
5199  *
5200  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
5201  *
5202  * @return void
5203  *
5204  * ****************************************************************/
5205 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
5206 {
5207    uint8_t idx1=0;
5208
5209    if(timeDomAllocList->choice.setup)
5210    {
5211       if(timeDomAllocList->choice.setup->list.array)
5212       {
5213          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
5214          {
5215             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1]->k0, sizeof(long));
5216             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
5217                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
5218          }
5219          DU_FREE(timeDomAllocList->choice.setup->list.array, \
5220                timeDomAllocList->choice.setup->list.size);
5221       }
5222       DU_FREE(timeDomAllocList->choice.setup,\
5223             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
5224    }
5225 }
5226 /*******************************************************************
5227  *
5228  * @brief Frees memory allocated for PuschTimeDomAllocList
5229  *
5230  *@details
5231  *
5232  *    Function : FreePuschTimeDomAllocList
5233  *
5234  *    Functionality: Deallocating memory of PuschTimeDomAllocList
5235  *
5236  * @params[in] PUSCH_Config_t *puschCfg
5237  *
5238  * @return void
5239  *
5240  * ****************************************************************/
5241 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
5242 {
5243    uint8_t rsrcListIdx=0;
5244    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
5245
5246    if(puschCfg->pusch_TimeDomainAllocationList)
5247    {
5248       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
5249       if(timeDomAllocList_t->choice.setup)
5250       {
5251          if(timeDomAllocList_t->choice.setup->list.array)
5252          {
5253             for(rsrcListIdx = 0; rsrcListIdx<timeDomAllocList_t->choice.setup->list.count; rsrcListIdx++)
5254             {
5255                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx]->k2, sizeof(long));
5256                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx],\
5257                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
5258             }
5259             DU_FREE(timeDomAllocList_t->choice.setup->list.array, \
5260                   timeDomAllocList_t->choice.setup->list.size);
5261          }
5262          DU_FREE(timeDomAllocList_t->choice.setup, \
5263                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
5264       }
5265       DU_FREE(puschCfg->transformPrecoder, sizeof(long));
5266       DU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
5267             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
5268    }
5269
5270 }
5271 /*******************************************************************
5272  *
5273  * @brief Frees memory allocated for InitialUlBWP
5274  *
5275  * @details
5276  *
5277  *    Function : FreeInitialUlBWP
5278  *
5279  *    Functionality: Deallocating memory of InitialUlBWP
5280  *
5281  * @params[in] BWP_UplinkDedicated_t *ulBwp
5282  *
5283  * @return void
5284  *
5285  * ****************************************************************/
5286 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5287 {
5288    uint8_t  rSetIdx, rsrcIdx, k1Idx;
5289    SRS_Config_t   *srsCfg = NULLP;
5290    PUSCH_Config_t *puschCfg = NULLP;
5291    PUCCH_Config_t *pucchCfg = NULLP;
5292    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
5293    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
5294    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
5295    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
5296
5297    if(ulBwp->pucch_Config)
5298    {
5299       if(ulBwp->pucch_Config->choice.setup)
5300       {
5301           pucchCfg = ulBwp->pucch_Config->choice.setup;
5302           if(pucchCfg->dl_DataToUL_ACK)
5303           {
5304              if(pucchCfg->dl_DataToUL_ACK->list.array)
5305              {
5306                 for(k1Idx = 0; k1Idx < pucchCfg->dl_DataToUL_ACK->list.count; k1Idx++)
5307                 {
5308                    DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[k1Idx], sizeof(long));
5309                 }
5310                 DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
5311              }
5312              DU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
5313           }
5314           DU_FREE(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
5315       }
5316       DU_FREE(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
5317    }
5318
5319    if(ulBwp->pusch_Config)
5320    {
5321       if(ulBwp->pusch_Config->choice.setup)
5322       {
5323          puschCfg=ulBwp->pusch_Config->choice.setup;
5324          if(puschCfg->dataScramblingIdentityPUSCH)
5325          {
5326             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
5327             {
5328                FreePuschTimeDomAllocList(puschCfg);
5329                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
5330                if(dmrsUlCfg->choice.setup)
5331                {
5332                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
5333                   {
5334                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
5335                      {
5336                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
5337                               sizeof(long));
5338                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
5339                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
5340                      }
5341                      DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
5342                            sizeof(long));
5343                   }
5344                   DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
5345                }
5346                DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
5347                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
5348             }
5349             DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
5350          }
5351          DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5352       }
5353       DU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5354
5355       /* Free SRS-Config */
5356       if(ulBwp->srs_Config)
5357       {
5358          if(ulBwp->srs_Config->choice.setup)
5359          {
5360             srsCfg = ulBwp->srs_Config->choice.setup;
5361
5362             /* Free Resource Set to add/mod list */
5363             if(srsCfg->srs_ResourceSetToAddModList)
5364             {
5365                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
5366                if(rsrcSetList->list.array)
5367                {
5368                   rSetIdx = 0;
5369
5370                   /* Free SRS resource Id list in this SRS resource set */
5371                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5372                   {
5373                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5374
5375                      if(rsrcIdList->list.array)
5376                      {
5377                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5378                         {
5379                            DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5380                         }
5381                         DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
5382                      }
5383                      DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5384                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5385                   }
5386
5387                   /* Free resource type info for this SRS resource set */
5388                   DU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5389                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5390
5391                   /* Free memory for each resource set */
5392                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5393                   {
5394                      DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5395                   }
5396                   DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
5397                }
5398                DU_FREE(srsCfg->srs_ResourceSetToAddModList, \
5399                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5400             }
5401
5402             /* Free resource to add/modd list */
5403             if(srsCfg->srs_ResourceToAddModList)
5404             {
5405                resourceList = srsCfg->srs_ResourceToAddModList;
5406                if(resourceList->list.array)
5407                {
5408                   rsrcIdx = 0;
5409                   DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
5410                         sizeof(struct SRS_Resource__transmissionComb__n2));
5411                   DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
5412                         sizeof(struct SRS_Resource__resourceType__aperiodic));
5413
5414                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5415                   {
5416                      DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5417                   }
5418                   DU_FREE(resourceList->list.array, resourceList->list.size);
5419                }
5420                DU_FREE(srsCfg->srs_ResourceToAddModList, \
5421                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
5422             }
5423
5424             DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5425          }
5426          DU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5427       }
5428    }
5429 }
5430 /*******************************************************************
5431  *
5432  * @brief Frees memory allocated for initialUplinkBWP
5433  *
5434  * @details
5435  *
5436  *    Function : FreeinitialUplinkBWP
5437  *
5438  *    Functionality: Deallocating memory of initialUplinkBWP
5439  *
5440  * @params[in] UplinkConfig_t *ulCfg
5441  *
5442  * @return void
5443  *
5444  *
5445  * ****************************************************************/
5446 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
5447 {
5448    BWP_UplinkDedicated_t *ulBwp=NULLP;
5449    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
5450
5451    if(ulCfg->initialUplinkBWP)
5452    {
5453       ulBwp=ulCfg->initialUplinkBWP;
5454       if(ulCfg->firstActiveUplinkBWP_Id)
5455       {
5456          if(ulCfg->pusch_ServingCellConfig)
5457          {
5458             puschCfg=ulCfg->pusch_ServingCellConfig;
5459             if(puschCfg->choice.setup)
5460             {
5461                if(puschCfg->choice.setup->ext1)
5462                {
5463                   DU_FREE(puschCfg->choice.setup->ext1->\
5464                         processingType2Enabled,sizeof(BOOLEAN_t));
5465                   DU_FREE(puschCfg->choice.setup->ext1->\
5466                         maxMIMO_Layers,sizeof(long));
5467                   DU_FREE(puschCfg->choice.setup->ext1, \
5468                         sizeof(struct PUSCH_ServingCellConfig__ext1));
5469                }
5470                DU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5471             }
5472             DU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5473          }
5474          DU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5475       }
5476       FreeInitialUlBWP(ulBwp);
5477       DU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5478    }
5479 }
5480 /*******************************************************************
5481  *
5482  * @brief Frees emmory allocated for BWPDlDedPdschCfg
5483  *
5484  * @details
5485  *
5486  *    Function : FreeBWPDlDedPdschCfg
5487  *
5488  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
5489  *
5490  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5491  *
5492  * @return void
5493  *
5494  *
5495  * ****************************************************************/
5496 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
5497 {
5498    struct PDSCH_Config *pdschCfg=NULLP;
5499    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
5500    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
5501    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
5502
5503    if(dlBwp->pdsch_Config->choice.setup)
5504    {
5505       pdschCfg=dlBwp->pdsch_Config->choice.setup;
5506       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
5507       {
5508          if(pdschCfg->pdsch_TimeDomainAllocationList)
5509          {
5510             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
5511             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
5512             {
5513                prbBndlType=&pdschCfg->prb_BundlingType;
5514                DU_FREE(prbBndlType->choice.staticBundling,\
5515                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
5516                DU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
5517             }
5518             FreePdschTimeDomAllocList(timeDomAllocList);
5519             DU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
5520                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
5521          }
5522          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
5523          if(dmrsDlCfg->choice.setup)
5524          {
5525             DU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
5526                   sizeof(long));
5527             DU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
5528          }
5529          DU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
5530                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
5531       }
5532       DU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
5533    }
5534 }
5535 /*******************************************************************
5536  *
5537  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
5538  *
5539  * @details
5540  *
5541  *    Function : FreeBWPDlDedPdcchCfg
5542  *
5543  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
5544  *
5545  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5546  *
5547  * @return void
5548  *
5549  *
5550  * ****************************************************************/
5551 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
5552 {
5553    uint8_t idx1=0;
5554    uint8_t idx2=0;
5555    struct PDCCH_Config *pdcchCfg=NULLP;
5556    struct ControlResourceSet *controlRSet=NULLP;
5557    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
5558
5559    if(dlBwp->pdcch_Config->choice.setup)
5560    {
5561       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
5562       if(pdcchCfg->controlResourceSetToAddModList)
5563       {
5564          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
5565          if(controlRSetList->list.array)
5566          {
5567             controlRSet = controlRSetList->list.array[idx2];
5568             if(controlRSet)
5569             {
5570                if(controlRSet->frequencyDomainResources.buf)
5571                {
5572                   if(controlRSet->pdcch_DMRS_ScramblingID)
5573                   {
5574                      if(pdcchCfg->searchSpacesToAddModList)
5575                      {
5576                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
5577                         DU_FREE(pdcchCfg->searchSpacesToAddModList, \
5578                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
5579                      }
5580                      DU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
5581                   }
5582                   DU_FREE(controlRSet->frequencyDomainResources.buf, \
5583                         controlRSet->frequencyDomainResources.size);
5584                }
5585             }
5586             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
5587             {
5588                DU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
5589             }
5590             DU_FREE(controlRSetList->list.array, controlRSetList->list.size);
5591          }
5592          DU_FREE(pdcchCfg->controlResourceSetToAddModList, \
5593                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
5594       }
5595       DU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
5596    }
5597 }
5598
5599 /*******************************************************************
5600  *
5601  * @brief Frees emmory allocated for DUToCURRCContainer
5602  *
5603  * @details
5604  *
5605  *    Function : FreeMemDuToCuRrcCont
5606  *
5607  *    Functionality: Deallocating memory of DuToCuRrcContainer
5608  *
5609  * @params[in] DuToCuRRCContainer, DuToCuRRCContainer
5610  *
5611  * @return ROK     - success
5612  *         RFAILED - failure
5613  *
5614  * ****************************************************************/
5615 uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg)
5616 {
5617    uint8_t idx=0;
5618    SpCellConfig_t *spCellCfg=NULLP;
5619    ServingCellConfig_t *srvCellCfg=NULLP;
5620    BWP_DownlinkDedicated_t *dlBwp=NULLP;
5621    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
5622    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
5623    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
5624    struct RLC_Config *rlcConfig=NULLP;
5625    struct LogicalChannelConfig *macLcConfig=NULLP;
5626    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
5627    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
5628    struct TAG_Config *tagConfig=NULLP;
5629    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
5630    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
5631    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
5632
5633    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
5634    if(rlcBearerList)
5635    {
5636       if(rlcBearerList->list.array)
5637       {
5638          for(idx=0; idx<rlcBearerList->list.count; idx++)
5639          {
5640             if(rlcBearerList->list.array[idx])
5641             {
5642                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
5643                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
5644                if(rlcConfig)
5645                {
5646                   if(rlcConfig->choice.am)
5647                   {
5648                      DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5649                      DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5650                      DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
5651                   }
5652                   DU_FREE(rlcConfig, sizeof(struct RLC_Config));
5653                }
5654                DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
5655                if(macLcConfig)
5656                {
5657                   if(macLcConfig->ul_SpecificParameters)
5658                   {
5659                      DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
5660                      DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
5661                      DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
5662                   }
5663                   DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
5664                }
5665                DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
5666             }
5667          }
5668          DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
5669       }
5670       DU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5671    }
5672
5673    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
5674    if(macCellGrpCfg)
5675    {
5676       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
5677       if(schedulingRequestConfig)
5678       {
5679          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
5680          if(schReqList)
5681          {
5682             if(schReqList->list.array)
5683             {
5684                for(idx=0;idx<schReqList->list.count; idx++)
5685                {
5686                   if(schReqList->list.array[idx])
5687                   {
5688                      DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
5689                      DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
5690                   }
5691                }
5692                DU_FREE(schReqList->list.array, schReqList->list.size);
5693             }
5694             DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
5695                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
5696             DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5697       }
5698       if(macCellGrpCfg->bsr_Config)
5699       {
5700          DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5701       }
5702       tagConfig = macCellGrpCfg->tag_Config;
5703       if(tagConfig)
5704       {
5705          tagList = tagConfig->tag_ToAddModList;
5706          if(tagList)
5707          {
5708             if(tagList->list.array)
5709             {
5710                for(idx=0; idx<tagList->list.count; idx++)
5711                {
5712                   DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
5713                }
5714                DU_FREE(tagList->list.array, tagList->list.size);
5715             }
5716             DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
5717          }
5718          DU_FREE(tagConfig, sizeof(struct TAG_Config));
5719       }
5720
5721       phrConfig = macCellGrpCfg->phr_Config;
5722       if(phrConfig)
5723       {
5724          DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
5725          DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
5726       }
5727
5728       DU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
5729    }
5730
5731    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
5732    if(phyCellGrpCfg)
5733    {
5734       DU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5735       DU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
5736    }
5737
5738    spCellCfg = cellGrpCfg->spCellConfig;
5739    if(spCellCfg)
5740    {
5741       if(spCellCfg->servCellIndex)
5742       {
5743          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
5744          {
5745             if(spCellCfg->spCellConfigDedicated)
5746             {
5747                srvCellCfg = spCellCfg->spCellConfigDedicated;
5748                if(srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
5749                {
5750                   if(srvCellCfg->initialDownlinkBWP)
5751                   {
5752                      dlBwp = srvCellCfg->initialDownlinkBWP;
5753                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
5754                      {
5755                         if(srvCellCfg->defaultDownlinkBWP_Id)
5756                         {
5757                            if(srvCellCfg->uplinkConfig)
5758                            {
5759                               if(srvCellCfg->pdsch_ServingCellConfig)
5760                               {
5761                                  pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
5762                                  if(pdschCfg->choice.setup)
5763                                  {
5764                                     DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
5765                                     DU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5766                                  }
5767                                  DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
5768                                           ServingCellConfig__pdsch_ServingCellConfig));
5769                               }
5770                               FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
5771                               DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
5772                            }
5773                            DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
5774                         }
5775                         DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
5776                      }
5777                      if(dlBwp->pdcch_Config)
5778                      {
5779                         if(dlBwp->pdsch_Config)
5780                         {
5781                            FreeBWPDlDedPdschCfg(dlBwp);
5782                            DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
5783                         }
5784                         FreeBWPDlDedPdcchCfg(dlBwp);
5785                         DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
5786                      }
5787                      DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
5788                   }
5789                   DU_FREE(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
5790                }
5791                DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5792             }
5793             DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5794          }
5795          DU_FREE(spCellCfg->servCellIndex, sizeof(long));
5796       }
5797       DU_FREE(spCellCfg,sizeof(SpCellConfig_t));
5798    }
5799    return ROK;
5800 }
5801 /*******************************************************************
5802  *
5803  * @brief Builds DU To CU RRC Container
5804  *
5805  * @details
5806  *
5807  *    Function : BuildDuToCuRrcContainer
5808  *
5809  *    Functionality: Builds DuToCuRrcContainer
5810  *
5811  * @params[in] idx, index in F1AP msg
5812  *             DuToCuRRCContainer, DuToCuRRCContainer
5813  *
5814  * @return ROK     - success
5815  *         RFAILED - failure
5816  *
5817  * ****************************************************************/
5818 uint8_t BuildDuToCuRrcContainer(DUtoCURRCContainer_t *duToCuRrcContainer)
5819 {
5820    uint8_t  ret = ROK;
5821    CellGroupConfigRrc_t  cellGrpCfg;
5822    asn_enc_rval_t        encRetVal;
5823    memset(&cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
5824    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
5825
5826    while(true)
5827    {
5828       cellGrpCfg.cellGroupId = CELL_GRP_ID;
5829
5830       cellGrpCfg.rlc_BearerToAddModList = NULLP;
5831       DU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5832       if(!cellGrpCfg.rlc_BearerToAddModList)
5833       {
5834          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5835          ret = RFAILED;
5836          break;
5837       }
5838       if(BuildRlcBearerToAddModList(cellGrpCfg.rlc_BearerToAddModList) != ROK)
5839       {
5840          DU_LOG("\nERROR  -->  F1AP : BuildRlcBearerToAddModList failed");
5841          ret = RFAILED;
5842          break;
5843       }
5844
5845       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
5846       cellGrpCfg.mac_CellGroupConfig = NULLP;
5847       DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
5848       if(!cellGrpCfg.mac_CellGroupConfig)
5849       {
5850          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5851          ret = RFAILED;
5852          break;
5853       }
5854       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
5855       {
5856          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
5857          ret = RFAILED;
5858          break;
5859       }
5860
5861       cellGrpCfg.physicalCellGroupConfig = NULLP;
5862       DU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
5863       if(!cellGrpCfg.physicalCellGroupConfig)
5864       {
5865          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5866          ret = RFAILED;
5867          break;
5868       }
5869       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
5870       {
5871          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
5872          ret = RFAILED;
5873          break;
5874       }
5875
5876       cellGrpCfg.spCellConfig = NULLP;
5877       DU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
5878       if(!cellGrpCfg.spCellConfig)
5879       {
5880          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5881          ret = RFAILED;
5882          break;
5883       }
5884       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
5885       {
5886          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
5887          ret = RFAILED;
5888          break;
5889       }
5890
5891       cellGrpCfg.sCellToAddModList = NULLP;
5892       cellGrpCfg.sCellToReleaseList = NULLP;
5893       cellGrpCfg.ext1 = NULLP;
5894
5895       /* encode cellGrpCfg into duToCuRrcContainer */
5896       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
5897       memset(encBuf, 0, ENC_BUF_MAX_LEN);
5898       encBufSize = 0;
5899       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
5900       /* Encode results */
5901       if(encRetVal.encoded == ENCODE_FAIL)
5902       {
5903          DU_LOG( "\nERROR  --> F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
5904                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5905          ret = RFAILED;
5906          break;
5907       }
5908       else
5909       {
5910          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
5911          for(int i=0; i< encBufSize; i++)
5912          {
5913             printf("%x",encBuf[i]);
5914          }
5915       }
5916
5917       duToCuRrcContainer->size = encBufSize;
5918       DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
5919       if(!duToCuRrcContainer->buf)
5920       {
5921          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
5922          ret = RFAILED;
5923          break;
5924       }
5925       if(ret == ROK)
5926       {
5927          memcpy(duToCuRrcContainer->buf, encBuf, duToCuRrcContainer->size);
5928       }
5929       break;
5930    }
5931    FreeMemDuToCuRrcCont(&cellGrpCfg);
5932    return ret;
5933 }
5934
5935 /*******************************************************************
5936  *
5937  * @brief Free memory allocated in InitialULRRCMessage
5938  *
5939  * @details
5940  *
5941  *    Function : freeInitUlRrcMsgTransfer
5942  *
5943  *    Functionality: Free memory allocated in InitialULRRCMessage
5944  *
5945  * @params[in]F1AP_PDU_t  *f1apMsg)
5946  *
5947  * @return ROK     - success
5948  *         RFAILED - failure
5949  *
5950  * ****************************************************************/
5951
5952 uint8_t freeInitUlRrcMsgTransfer(F1AP_PDU_t  *f1apMsg)
5953 {
5954    uint8_t ieIdx, arrIdx;
5955    InitialULRRCMessageTransfer_t *initULRRCMsg=NULLP;
5956
5957    if(f1apMsg)
5958    {
5959       if(f1apMsg->choice.initiatingMessage)
5960       {
5961          initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.\
5962             choice.InitialULRRCMessageTransfer;
5963          if(initULRRCMsg->protocolIEs.list.array)
5964          {
5965             for(ieIdx = 0; ieIdx < initULRRCMsg->protocolIEs.list.count; ieIdx++)
5966             {
5967                switch(initULRRCMsg->protocolIEs.list.array[ieIdx]->id)
5968                {
5969                   case ProtocolIE_ID_id_NRCGI:
5970                   {
5971                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf)
5972                      {
5973                         if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf)
5974                         {
5975                            DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf,\
5976                            initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.size);
5977                         }
5978                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf,\
5979                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.size);
5980                      }
5981                      break;
5982                   }
5983                   case ProtocolIE_ID_id_RRCContainer:
5984                   {
5985                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
5986                      {
5987                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,\
5988                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
5989                      }
5990                      break;
5991                   }
5992                   case ProtocolIE_ID_id_DUtoCURRCContainer:
5993                   {
5994                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf)
5995                      {
5996                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf,
5997                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.size);
5998                      }
5999                      break;
6000                   }
6001                   default:
6002                      break;
6003                }
6004              }
6005              for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
6006              {
6007                 if(initULRRCMsg->protocolIEs.list.array[arrIdx])
6008                 {
6009                    DU_FREE(initULRRCMsg->protocolIEs.list.array[arrIdx],\
6010                       sizeof(InitialULRRCMessageTransferIEs_t));
6011                 }
6012              }
6013              DU_FREE(initULRRCMsg->protocolIEs.list.array, initULRRCMsg->protocolIEs.list.size);
6014           }
6015          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
6016       }
6017       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
6018    }
6019    else
6020    {
6021       DU_LOG("\nERROR  -->  DU_APP : Recevied F1ap Pdu is null at freeInitUlRrcMsgTransfer()");
6022       return RFAILED;
6023    }
6024    return ROK;
6025 }
6026
6027 /*******************************************************************
6028  *
6029  * @brief Builds and sends the InitialULRRCMessage
6030  *
6031  * @details
6032  *
6033  *    Function : BuildAndSendInitialRrcMsgTransfer
6034  *
6035  *    Functionality: Constructs the Initial UL RRC Message Transfer and sends
6036  *                   it to the CU through SCTP.
6037  *
6038  * @params[in]
6039  *
6040  * @return ROK     - success
6041  *         RFAILED - failure
6042  *
6043  * ****************************************************************/
6044 uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti,
6045       uint16_t rrcContSize, uint8_t *rrcContainer)
6046 {
6047    uint8_t   ret;
6048    uint8_t   elementCnt;
6049    uint8_t   ieIdx;
6050    asn_enc_rval_t  encRetVal;
6051    F1AP_PDU_t  *f1apMsg = NULLP;
6052    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
6053    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
6054
6055    while(true)
6056    {
6057       DU_LOG("\n INFO   -->  F1AP : Building RRC Setup Request\n");
6058       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
6059       if(f1apMsg == NULLP)
6060       {
6061          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
6062          break;
6063       }
6064       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
6065       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
6066       if(f1apMsg->choice.initiatingMessage == NULLP)
6067       {
6068          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
6069          break;
6070       }
6071       f1apMsg->choice.initiatingMessage->procedureCode =\
6072                                                         ProcedureCode_id_InitialULRRCMessageTransfer;
6073       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
6074       f1apMsg->choice.initiatingMessage->value.present = \
6075                                                          InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
6076       initULRRCMsg =\
6077                     &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
6078       elementCnt = 5;
6079       initULRRCMsg->protocolIEs.list.count = elementCnt;
6080       initULRRCMsg->protocolIEs.list.size = \
6081                                             elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *);
6082       /* Initialize the F1Setup members */
6083       DU_ALLOC(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
6084       if(initULRRCMsg->protocolIEs.list.array == NULLP)
6085       {
6086          DU_LOG(" ERROR  -->  F1AP : Memory allocation for\
6087                RRCSetupRequestMessageTransferIEs failed");
6088          break;
6089       }
6090       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
6091       {
6092          DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx],\
6093                sizeof(InitialULRRCMessageTransferIEs_t));
6094          if(initULRRCMsg->protocolIEs.list.array[ieIdx] == NULLP)
6095          {
6096             break;
6097          }
6098       }
6099       ieIdx = 0;
6100       /*GNB DU UE F1AP ID*/
6101       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6102                                                         ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
6103       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  = Criticality_reject;
6104       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
6105                                                                   InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
6106       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
6107
6108
6109       /*NRCGI*/
6110       ieIdx++;
6111       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6112                                                         ProtocolIE_ID_id_NRCGI;
6113       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  =Criticality_reject;
6114       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
6115                                                                   InitialULRRCMessageTransferIEs__value_PR_NRCGI;
6116
6117       ret =\
6118            BuildNrcgi(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
6119       if(ret!=ROK)
6120       {
6121          break;
6122       }
6123
6124       /*CRNTI*/
6125       ieIdx++;
6126       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6127                                                         ProtocolIE_ID_id_C_RNTI;
6128       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6129       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6130                                                                  InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
6131       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.C_RNTI = crnti;
6132
6133       /*RRCContainer*/
6134       ieIdx++;
6135       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6136                                                         ProtocolIE_ID_id_RRCContainer;
6137       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6138       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6139                                                                  InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
6140
6141       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = rrcContSize;
6142       DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
6143             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size)
6144       if(!initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
6145       {
6146          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
6147          break;
6148
6149       }
6150       memcpy(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, rrcContainer,
6151             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
6152
6153
6154       /*DUtoCURRCContainer*/
6155       ieIdx++;
6156       initULRRCMsg->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCContainer;
6157       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6158       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6159                                                                  InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
6160
6161       ret = BuildDuToCuRrcContainer(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer);
6162       if(ret != ROK)
6163       {
6164          break;
6165       }
6166
6167       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
6168
6169       /* Encode the F1SetupRequest type as APER */
6170       memset(encBuf, 0, ENC_BUF_MAX_LEN);
6171       encBufSize = 0;
6172       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
6173       /* Encode results */
6174       if(encRetVal.encoded == ENCODE_FAIL)
6175       {
6176          DU_LOG( "\nERROR  --> F1AP : Could not encode Initial UL RRC Message Transfer\
6177                structure (at %s)\n",encRetVal.failed_type ? \
6178                encRetVal.failed_type->name : "unknown");
6179          ret = RFAILED;
6180          break;
6181       }
6182       else
6183       {
6184
6185          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for Initial UL RRC\
6186                Message transfer\n");
6187          for(int i=0; i< encBufSize; i++)
6188          {
6189             printf("%x",encBuf[i]);
6190          }
6191       }
6192       /* Sending  msg  */
6193       if(sendF1APMsg() != ROK)
6194       {
6195          DU_LOG("\nERROR  -->  F1AP : Sending Initial UL RRC Message Transfer Failed");
6196          ret = RFAILED;
6197          break;
6198       }
6199       break;
6200    }
6201    freeInitUlRrcMsgTransfer(f1apMsg);
6202    return ret;
6203 }/* End of BuildAndSendInitialRrcMsgTransfer*/
6204
6205 /*****  UE SETUP REQUEST *****/
6206
6207 /*******************************************************************
6208  *
6209  * @brief Free Qos And Snssai Drb Info
6210  *
6211  * @details
6212  *
6213  *    Function : freeDrbQosAndSnssaiInfo
6214  *
6215  *    Functionality: Free Qos And Snssai Drb Info
6216  *
6217  * @params[in] LcCfg *lcCfg,
6218  * @return void
6219  *
6220  * ****************************************************************/
6221 void freeDrbQosAndSnssaiInfo(LcCfg *lcCfg)
6222 {
6223    if(lcCfg->snssai)
6224    {
6225       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6226    }
6227    if(lcCfg->drbQos)
6228    {
6229       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
6230    }
6231 }
6232
6233 /******************************************************************
6234 *
6235 * @brief Function to delete the RLC Lc cfg from UE APP DB
6236 *
6237 * @details
6238 *
6239 *  Function : freeRlcLcCfg
6240 *
6241 *  Functionality: Function to delete the RLC Lc cfg from UE APP DB
6242 *
6243 *
6244  *****************************************************************/
6245
6246 void freeRlcLcCfg(RlcBearerCfg *lcCfg)
6247 {
6248    switch(lcCfg->rlcMode)
6249    {
6250       case RLC_AM :
6251          {
6252             if(lcCfg->u.amCfg)
6253             {
6254                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.amCfg, sizeof(AmBearerCfg));
6255             }
6256             break;
6257          }
6258       case RLC_UM_BI_DIRECTIONAL :
6259          {
6260             if(lcCfg->u.umBiDirCfg)
6261             {
6262                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
6263             }
6264             break;
6265          }
6266       case RLC_UM_UNI_DIRECTIONAL_UL :
6267          {
6268             if(lcCfg->u.umUniDirUlCfg)
6269             {
6270                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
6271             }
6272             break;
6273
6274          }
6275       case RLC_UM_UNI_DIRECTIONAL_DL :
6276          {
6277             if(lcCfg->u.umUniDirDlCfg)
6278             {
6279                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
6280             }
6281             break;
6282          }
6283       default:
6284          DU_LOG("\nERROR  -->  DU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
6285          break;
6286    }
6287 }
6288
6289 /*******************************************************************
6290  *
6291  * @brief Function to free MacLcCfg
6292  *
6293  * @details
6294  *
6295  *    Function : freeMacLcCfg
6296  *
6297  *    Functionality: Function to free MacLcCfg
6298  *
6299  * @params[in] LcCfg *lcCfg,
6300  * @return void
6301  *
6302  * ****************************************************************/
6303
6304 void  freeMacLcCfg(LcCfg *lcCfg)
6305 {
6306     /* Deleting DRBQOS */
6307    if(lcCfg->drbQos)
6308    {
6309       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
6310    }
6311    /* Deleting SNSSAI */
6312    if(lcCfg->snssai)
6313    {
6314       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6315    }
6316 }
6317 /*******************************************************************
6318  *
6319  * @brief Free UE NR Capability received in UE Context setup request
6320  *
6321  * @details
6322  *
6323  *    Function : freeAperDecodeUeNrCapability
6324  *
6325  *    Functionality:
6326  *       Free UE NR Capability received in UE Context setup request
6327  *
6328  * @params[in]
6329  * @return ROK     - success
6330  *         RFAILED - failure
6331  *
6332  * ****************************************************************/
6333 void freeAperDecodeUeNrCapability(void *ueNrCapability)
6334 {
6335    uint8_t arrIdx =0;
6336    FeatureSets_t *featureSets =NULLP;
6337    UE_NR_Capability_t *ueNrCap = (UE_NR_Capability_t *)ueNrCapability;
6338
6339    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
6340    {
6341       for(arrIdx = 0; arrIdx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; arrIdx++)
6342       {
6343          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx])
6344             free(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx]);
6345       }
6346       free(ueNrCap->rf_Parameters.supportedBandListNR.list.array);
6347    }
6348
6349    if(ueNrCap->featureSets)
6350    {
6351       featureSets = ueNrCap->featureSets;
6352       if(featureSets->featureSetsDownlinkPerCC)
6353       {
6354          if(featureSets->featureSetsDownlinkPerCC->list.array)
6355          {
6356             for(arrIdx = 0; arrIdx < featureSets->featureSetsDownlinkPerCC->list.count; arrIdx++)
6357             {
6358                if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx])
6359                {
6360                   if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL)
6361                      free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL);
6362                   free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]);
6363                }
6364             }
6365             free(featureSets->featureSetsDownlinkPerCC->list.array);
6366          }
6367          free(featureSets->featureSetsDownlinkPerCC);
6368       }
6369       if(featureSets->featureSetsUplinkPerCC)
6370       {
6371          if(featureSets->featureSetsUplinkPerCC->list.array)
6372          {
6373             for(arrIdx = 0; arrIdx < featureSets->featureSetsUplinkPerCC->list.count; arrIdx++)
6374             {
6375                if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx])
6376                {
6377                   if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL)
6378                      free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL);
6379                   free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]);
6380                }
6381             }
6382             free(featureSets->featureSetsUplinkPerCC->list.array);
6383          }
6384          free(featureSets->featureSetsUplinkPerCC);
6385       }
6386       free(ueNrCap->featureSets);
6387    }
6388 }
6389
6390 /*******************************************************************
6391 *
6392 * @brief Function to free PdcchSearchSpcToAddModList
6393          where memory allocated by aper_decoder
6394 *
6395 * @details
6396 *
6397 *    Function : freeAperDecodePdcchSearchSpcToAddModList
6398 *
6399 *    Functionality: Function to free PdcchSearchSpcToAddModList
6400 *
6401 * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
6402 * @return void
6403 *
6404 * ****************************************************************/
6405
6406 void freeAperDecodePdcchSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
6407 {
6408    uint8_t searchSpcArrIdx=0;
6409    uint8_t searchSpcArrIdx1=0;
6410    struct  SearchSpace *searchSpc=NULLP;
6411
6412
6413    if(searchSpcList->list.array)
6414    {
6415       if(searchSpcList->list.array[searchSpcArrIdx1])
6416       {
6417          searchSpc = searchSpcList->list.array[searchSpcArrIdx1];
6418          if(searchSpc->controlResourceSetId)
6419          {
6420             if(searchSpc->monitoringSlotPeriodicityAndOffset)
6421             {
6422                if(searchSpc->monitoringSymbolsWithinSlot)
6423                {
6424                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
6425                   {
6426                      if(searchSpc->nrofCandidates)
6427                      {
6428                         if(searchSpc->searchSpaceType)
6429                         {
6430                            free(searchSpc->searchSpaceType->choice.ue_Specific);
6431                            free(searchSpc->searchSpaceType);
6432                         }
6433                         free(searchSpc->nrofCandidates);
6434                      }
6435                      free(searchSpc->monitoringSymbolsWithinSlot->buf);
6436                   }
6437                   free(searchSpc->monitoringSymbolsWithinSlot);
6438                }
6439                free(searchSpc->monitoringSlotPeriodicityAndOffset);
6440             }
6441             free(searchSpc->controlResourceSetId);
6442          }
6443       }
6444       for(searchSpcArrIdx = 0; searchSpcArrIdx < searchSpcList->list.count; searchSpcArrIdx++)
6445       {
6446          free(searchSpcList->list.array[searchSpcArrIdx]);
6447       }
6448       free(searchSpcList->list.array);
6449    }
6450 }
6451 /*******************************************************************
6452 *
6453 * @brief Function for free part for the memory allocated by aper_decoder
6454 *
6455 * @details
6456 *
6457 *    Function : freeAperDecodeBWPDlDedPdcchConfig
6458 *
6459 *    Functionality: Function to free BWPDlDedPdcchConfig
6460 *
6461 * @params[in]
6462 * @return void
6463 *
6464 * ****************************************************************/
6465
6466
6467 void freeAperDecodeBWPDlDedPdcchConfig(BWP_DownlinkDedicated_t *dlBwp)
6468 {
6469    uint8_t arrIdx1=0;
6470    uint8_t arrIdx2=0;
6471    struct PDCCH_Config *pdcchCfg=NULLP;
6472    struct ControlResourceSet *controlRSet=NULLP;
6473    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
6474
6475    if(dlBwp->pdcch_Config->choice.setup)
6476    {
6477       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
6478       if(pdcchCfg->controlResourceSetToAddModList)
6479       {
6480          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
6481          if(controlRSetList->list.array)
6482          {
6483             controlRSet = controlRSetList->list.array[arrIdx2];
6484             if(controlRSet)
6485             {
6486                if(controlRSet->frequencyDomainResources.buf)
6487                {
6488                   if(controlRSet->pdcch_DMRS_ScramblingID)
6489                   {
6490                      if(pdcchCfg->searchSpacesToAddModList)
6491                      {
6492                         freeAperDecodePdcchSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
6493                         free(pdcchCfg->searchSpacesToAddModList);
6494                      }
6495                      free(controlRSet->pdcch_DMRS_ScramblingID);
6496                   }
6497                   free(controlRSet->frequencyDomainResources.buf);
6498                }
6499             }
6500             for(arrIdx1 = 0; arrIdx1 <controlRSetList->list.count; arrIdx1++)
6501             {
6502                free(controlRSetList->list.array[arrIdx1]);
6503             }
6504             free(controlRSetList->list.array);
6505          }
6506          free(pdcchCfg->controlResourceSetToAddModList);
6507       }
6508       free(dlBwp->pdcch_Config->choice.setup);
6509    }
6510 }
6511 /*******************************************************************
6512 *
6513 * @brief Function to free PdschTimeDomAllocationList
6514 *     where the memory allocated by aper_decoder
6515 *
6516 * @details
6517 *
6518 *    Function : freeAperDecodePdschTimeDomAllocationList
6519 *
6520 *    Functionality: Function to free PdschTimeDomAllocationList
6521 *
6522 * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
6523 * @return void
6524 *
6525 * ****************************************************************/
6526
6527
6528 void freeAperDecodePdschTimeDomAllocationList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
6529 {
6530    uint8_t arrIdx=0;
6531
6532    if(timeDomAllocList->choice.setup)
6533    {
6534       if(timeDomAllocList->choice.setup->list.array)
6535       {
6536          for(arrIdx = 0; arrIdx <timeDomAllocList->choice.setup->list.count ; arrIdx++)
6537          {
6538             free(timeDomAllocList->choice.setup->list.array[arrIdx]);
6539          }
6540          free(timeDomAllocList->choice.setup->list.array);
6541       }
6542       free(timeDomAllocList->choice.setup);
6543    }
6544 }
6545
6546 /*******************************************************************
6547 *
6548 * @brief Function to free BWPDlDedPdschConfig
6549 *        where the memory allocated by aper_decoder
6550 *
6551 * @details
6552 *
6553 *    Function : freeAperDecodeBWPDlDedPdschConfig
6554 *
6555 *    Functionality: Function to free BWPDlDedPdschConfig
6556 *
6557 * @params[in] BWP_DownlinkDedicated_t *dlBwp
6558 * @return void
6559 *
6560 * ****************************************************************/
6561
6562
6563 void freeAperDecodeBWPDlDedPdschConfig(BWP_DownlinkDedicated_t *dlBwp)
6564 {
6565    struct PDSCH_Config *pdschCfg=NULLP;
6566    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
6567    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
6568    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
6569
6570    if(dlBwp->pdsch_Config->choice.setup)
6571    {
6572       pdschCfg=dlBwp->pdsch_Config->choice.setup;
6573       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
6574       {
6575          if(pdschCfg->pdsch_TimeDomainAllocationList)
6576          {
6577             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
6578             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
6579             {
6580                prbBndlType=&pdschCfg->prb_BundlingType;
6581                free(prbBndlType->choice.staticBundling);
6582                free(pdschCfg->maxNrofCodeWordsScheduledByDCI);
6583             }
6584             freeAperDecodePdschTimeDomAllocationList(timeDomAllocList);
6585             free(pdschCfg->pdsch_TimeDomainAllocationList);
6586          }
6587          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
6588          if(dmrsDlCfg->choice.setup)
6589          {
6590             free(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition);
6591             free(dmrsDlCfg->choice.setup);
6592          }
6593          free(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA);
6594       }
6595       free(dlBwp->pdsch_Config->choice.setup);
6596    }
6597 }
6598 /*******************************************************************
6599 *
6600 * @brief Function to free PuschTimeDomAllocListCfg
6601                  where the memory allocated by aper_decoder
6602 *
6603 * @details
6604 *
6605 *    Function : freeAperDecodePuschTimeDomAllocListCfg
6606 *
6607 *    Functionality: Function to free PuschTimeDomAllocListCfg
6608 *
6609 * @params[in] PUSCH_Config_t *puschCfg
6610 * @return void
6611 *
6612 * ****************************************************************/
6613
6614
6615 void freeAperDecodePuschTimeDomAllocListCfg(PUSCH_Config_t *puschCfg)
6616 {
6617    uint8_t arrIdx=0;
6618    uint8_t arrIdx1=0;
6619    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
6620
6621    if(puschCfg->pusch_TimeDomainAllocationList)
6622    {
6623       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
6624       if(timeDomAllocList_t->choice.setup)
6625       {
6626          if(timeDomAllocList_t->choice.setup->list.array)
6627          {
6628             free(timeDomAllocList_t->choice.setup->list.array[arrIdx1]->k2);
6629             for(arrIdx = 0; arrIdx<timeDomAllocList_t->choice.setup->list.count; arrIdx++)
6630             {
6631                free(timeDomAllocList_t->choice.setup->list.array[arrIdx]);
6632             }
6633             free(timeDomAllocList_t->choice.setup->list.array);
6634          }
6635          free(timeDomAllocList_t->choice.setup);
6636       }
6637       free(puschCfg->transformPrecoder);
6638       free(puschCfg->pusch_TimeDomainAllocationList);
6639    }
6640 }
6641 /*******************************************************************
6642 *
6643 * @brief Function to free InitialUlBWPConfig where memory allocated by aper_decoder
6644 *
6645 * @details
6646 *
6647 *    Function : freeAperDecodeInitialUlBWPConfig
6648 *
6649 *    Functionality: Function to free InitialUlBWPConfig
6650 *
6651 * @params[in]  BWP_UplinkDedicated_t *ulBwp
6652 * @return void
6653 *
6654 * ****************************************************************/
6655
6656
6657 void freeAperDecodeInitialUlBWPConfig(BWP_UplinkDedicated_t *ulBwp)
6658 {
6659    uint8_t  rSetIdx =0;
6660    uint8_t  rsrcIdx =0;
6661    SRS_Config_t   *srsCfg = NULLP;
6662    PUSCH_Config_t *puschCfg = NULLP;
6663    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
6664    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
6665    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
6666    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
6667
6668    if(ulBwp->pusch_Config)
6669    {
6670       if(ulBwp->pusch_Config->choice.setup)
6671       {
6672          puschCfg=ulBwp->pusch_Config->choice.setup;
6673          if(puschCfg->dataScramblingIdentityPUSCH)
6674          {
6675             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
6676             {
6677                freeAperDecodePuschTimeDomAllocListCfg(puschCfg);
6678                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
6679                if(dmrsUlCfg->choice.setup)
6680                {
6681                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
6682                   {
6683                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
6684                      {
6685                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0);
6686                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled);
6687                      }
6688                      free(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition);
6689                   }
6690                   free(dmrsUlCfg->choice.setup);
6691                }
6692                free(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA);
6693             }
6694             free(puschCfg->dataScramblingIdentityPUSCH);
6695          }
6696          free(ulBwp->pusch_Config->choice.setup);
6697       }
6698       free(ulBwp->pusch_Config);
6699
6700       /* Free SRS-Config */
6701       if(ulBwp->srs_Config)
6702       {
6703          if(ulBwp->srs_Config->choice.setup)
6704          {
6705             srsCfg = ulBwp->srs_Config->choice.setup;
6706
6707             /* Free Resource Set to add/mod list */
6708             if(srsCfg->srs_ResourceSetToAddModList)
6709             {
6710                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
6711                if(rsrcSetList->list.array)
6712                {
6713                   rSetIdx = 0;
6714
6715                   /* Free SRS resource Id list in this SRS resource set */
6716                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
6717                   {
6718                      rsrcIdList =
6719                         rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
6720
6721                      if(rsrcIdList->list.array)
6722                      {
6723                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count;
6724                               rsrcIdx++)
6725                         {
6726                            free(rsrcIdList->list.array[rsrcIdx]);
6727                         }
6728                         free(rsrcIdList->list.array);
6729                      }
6730                      free(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList);
6731                   }
6732
6733                   /* Free resource type info for this SRS resource set */
6734
6735                   free(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic);
6736
6737                   /* Free memory for each resource set */
6738                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
6739                   {
6740                      free(rsrcSetList->list.array[rSetIdx]);
6741                   }
6742                   free(rsrcSetList->list.array);
6743                }
6744                free(srsCfg->srs_ResourceSetToAddModList);
6745             }
6746
6747             /* Free resource to add/modd list */
6748             if(srsCfg->srs_ResourceToAddModList)
6749             {
6750                resourceList = srsCfg->srs_ResourceToAddModList;
6751                if(resourceList->list.array)
6752                {
6753                   rsrcIdx = 0;
6754
6755                   free(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2);
6756                   free(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic);
6757
6758                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
6759                   {
6760                      free(resourceList->list.array[rsrcIdx]);
6761                   }
6762                   free(resourceList->list.array);
6763                }
6764                free(srsCfg->srs_ResourceToAddModList);
6765             }
6766
6767             free(ulBwp->srs_Config->choice.setup);
6768          }
6769          free(ulBwp->srs_Config);
6770       }
6771    }
6772 }
6773 /*******************************************************************
6774 *
6775 * @brief Function to free initialUplinkBWPConfig where memory allocated by aper_decoder
6776 *
6777 * @details
6778 *
6779 *    Function : freeAperDecodeinitialUplinkBWPConfig
6780 *
6781 *    Functionality: Function to free initialUplinkBWPConfig
6782 *
6783 * @params[in] UplinkConfig_t *ulCfg
6784 * @return void
6785 *
6786 * ****************************************************************/
6787
6788
6789 void freeAperDecodeinitialUplinkBWPConfig(UplinkConfig_t *ulCfg)
6790 {
6791    BWP_UplinkDedicated_t *ulBwp=NULLP;
6792    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
6793
6794    if(ulCfg->initialUplinkBWP)
6795    {
6796       ulBwp=ulCfg->initialUplinkBWP;
6797       if(ulCfg->firstActiveUplinkBWP_Id)
6798       {
6799          if(ulCfg->pusch_ServingCellConfig)
6800          {
6801             puschCfg=ulCfg->pusch_ServingCellConfig;
6802             if(puschCfg->choice.setup)
6803             {
6804                if(puschCfg->choice.setup->ext1)
6805                {
6806                   free(puschCfg->choice.setup->ext1->processingType2Enabled);
6807                   free(puschCfg->choice.setup->ext1->maxMIMO_Layers);
6808                   free(puschCfg->choice.setup->ext1);
6809                }
6810                free(puschCfg->choice.setup);
6811             }
6812             free(ulCfg->pusch_ServingCellConfig);
6813          }
6814          free(ulCfg->firstActiveUplinkBWP_Id);
6815       }
6816       freeAperDecodeInitialUlBWPConfig(ulBwp);
6817       free(ulCfg->initialUplinkBWP);
6818    }
6819 }
6820
6821 /*******************************************************************
6822  *
6823  * @brief Function to free DuUeCfg
6824  *
6825  * @details
6826  *
6827  *    Function : freeDuUeCfg
6828  *
6829  *    Functionality: Function to free DuUeCfg
6830  *
6831  * @params[in] DuUeCfg *ueCfg
6832  * @return void
6833  *
6834  * ****************************************************************/
6835 void freeDuUeCfg(DuUeCfg *ueCfg)
6836 {
6837    uint8_t lcIdx = 0;
6838    uint8_t arrIdx = 0;
6839    SpCellConfig_t *spCellCfg = NULLP;
6840    ServingCellConfig_t *srvCellCfg = NULLP;
6841    BWP_DownlinkDedicated_t *dlBwp = NULLP;
6842    MAC_CellGroupConfig_t *macCellGrpCfg = NULLP;
6843    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
6844    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList = NULLP;
6845    struct RLC_Config *rlcConfig = NULLP;
6846    struct LogicalChannelConfig *macLcConfig = NULLP;
6847    struct SchedulingRequestConfig *schedulingRequestConfig = NULLP;
6848    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList = NULLP;
6849    struct TAG_Config *tagConfig = NULLP;
6850    struct TAG_Config__tag_ToAddModList *tagList = NULLP;
6851    struct MAC_CellGroupConfig__phr_Config *phrConfig = NULLP;
6852    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg = NULLP;
6853    CellGroupConfigRrc_t *cellGrpCfg = ueCfg->cellGrpCfg;
6854
6855    if(ueCfg->ueNrCapability)
6856    {
6857       freeAperDecodeUeNrCapability(ueCfg->ueNrCapability);
6858       DU_FREE(ueCfg->ueNrCapability, sizeof(UE_NR_Capability_t));
6859       ueCfg->ueNrCapability = NULLP;
6860    }
6861
6862    if(ueCfg->cellGrpCfg)
6863    {
6864
6865       rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6866       if(rlcBearerList)
6867       {
6868          if(rlcBearerList->list.array)
6869          {
6870             for(arrIdx=0; arrIdx<rlcBearerList->list.count; arrIdx++)
6871             {
6872                if(rlcBearerList->list.array[arrIdx])
6873                {
6874                   rlcConfig   = rlcBearerList->list.array[arrIdx]->rlc_Config;
6875                   macLcConfig = rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig;
6876
6877                   if(rlcBearerList->list.array[arrIdx]->servedRadioBearer)
6878                   {
6879                      free(rlcBearerList->list.array[arrIdx]->servedRadioBearer);
6880                   }
6881                   if(rlcConfig)
6882                   {
6883                      if(rlcConfig->choice.am)
6884                      {
6885                         free(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength);
6886                         free(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength);
6887                         free(rlcConfig->choice.am);
6888                      }
6889                      free(rlcBearerList->list.array[arrIdx]->rlc_Config);
6890                   }
6891                   if(macLcConfig)
6892                   {
6893                      if(macLcConfig->ul_SpecificParameters)
6894                      {
6895                         free(macLcConfig->ul_SpecificParameters->schedulingRequestID);
6896                         free(macLcConfig->ul_SpecificParameters->logicalChannelGroup);
6897                         free(macLcConfig->ul_SpecificParameters);
6898                      }
6899                      free(rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig);
6900                   }
6901                   free(rlcBearerList->list.array[arrIdx]);
6902                }
6903             }
6904             free(rlcBearerList->list.array);
6905          }
6906          free(cellGrpCfg->rlc_BearerToAddModList);
6907       }
6908
6909       macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
6910       if(macCellGrpCfg)
6911       {
6912          schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
6913          if(schedulingRequestConfig)
6914          {
6915             schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
6916             if(schReqList)
6917             {
6918                if(schReqList->list.array)
6919                {
6920                   for(arrIdx=0;arrIdx<schReqList->list.count; arrIdx++)
6921                   {
6922                      if(schReqList->list.array[arrIdx])
6923                      {
6924                         free(schReqList->list.array[arrIdx]->sr_ProhibitTimer);
6925                         free(schReqList->list.array[arrIdx]);
6926                      }
6927                   }
6928                   free(schReqList->list.array);
6929                }
6930                free(schedulingRequestConfig->schedulingRequestToAddModList);
6931             }
6932             free(macCellGrpCfg->schedulingRequestConfig);
6933          }
6934          if(macCellGrpCfg->bsr_Config)
6935          {
6936             free(macCellGrpCfg->bsr_Config);
6937          }
6938          tagConfig = macCellGrpCfg->tag_Config;
6939          if(tagConfig)
6940          {
6941             tagList = tagConfig->tag_ToAddModList;
6942             if(tagList)
6943             {
6944                if(tagList->list.array)
6945                {
6946                   for(arrIdx=0; arrIdx<tagList->list.count; arrIdx++)
6947                   {
6948                      free(tagList->list.array[arrIdx]);
6949                   }
6950                   free(tagList->list.array);
6951                }
6952                free(tagConfig->tag_ToAddModList);
6953             }
6954             free(tagConfig);
6955          }
6956
6957          phrConfig = macCellGrpCfg->phr_Config;
6958          if(phrConfig)
6959          {
6960             free(phrConfig->choice.setup);
6961             free(phrConfig);
6962          }
6963
6964          free(macCellGrpCfg);
6965       }
6966
6967       phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
6968       if(phyCellGrpCfg)
6969       {
6970          free(phyCellGrpCfg->p_NR_FR1);
6971          free(phyCellGrpCfg);
6972       }
6973
6974       spCellCfg = cellGrpCfg->spCellConfig;
6975       if(spCellCfg)
6976       {
6977          if(spCellCfg->servCellIndex)
6978          {
6979             if(spCellCfg->rlmInSyncOutOfSyncThreshold)
6980             {
6981                if(spCellCfg->spCellConfigDedicated)
6982                {
6983                   srvCellCfg = spCellCfg->spCellConfigDedicated;
6984                   if(srvCellCfg->initialDownlinkBWP)
6985                   {
6986                      dlBwp = srvCellCfg->initialDownlinkBWP;
6987                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
6988                      {
6989                         if(srvCellCfg->defaultDownlinkBWP_Id)
6990                         {
6991                            if(srvCellCfg->uplinkConfig)
6992                            {
6993
6994                               if(srvCellCfg->pdsch_ServingCellConfig)
6995                               {
6996                                  pdschCfg=
6997                                     srvCellCfg->pdsch_ServingCellConfig;
6998                                  if(pdschCfg->choice.setup)
6999                                  {
7000
7001                                     free(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH);
7002                                     free(pdschCfg->choice.setup);
7003                                  }
7004
7005                                  free(srvCellCfg->pdsch_ServingCellConfig);
7006                               }
7007
7008                               freeAperDecodeinitialUplinkBWPConfig(srvCellCfg->uplinkConfig);
7009                               free(srvCellCfg->uplinkConfig);
7010                            }
7011                            free(srvCellCfg->defaultDownlinkBWP_Id);
7012                         }
7013
7014                         free(srvCellCfg->firstActiveDownlinkBWP_Id);
7015                      }
7016                      if(dlBwp->pdcch_Config)
7017                      {
7018                         if(dlBwp->pdsch_Config)
7019                         {
7020                            freeAperDecodeBWPDlDedPdschConfig(dlBwp);
7021                            free(dlBwp->pdsch_Config);
7022                         }
7023                         freeAperDecodeBWPDlDedPdcchConfig(dlBwp);
7024                         free(dlBwp->pdcch_Config);
7025                      }
7026                      free(srvCellCfg->initialDownlinkBWP);
7027                   }
7028
7029                   free(spCellCfg->spCellConfigDedicated);
7030                }
7031                free(spCellCfg->rlmInSyncOutOfSyncThreshold);
7032             }
7033             free(spCellCfg->servCellIndex);
7034          }
7035          free(spCellCfg);
7036       }
7037       DU_FREE(ueCfg->cellGrpCfg, sizeof(CellGroupConfigRrc_t));
7038       ueCfg->cellGrpCfg = NULLP;
7039    }
7040    if(ueCfg->ambrCfg)
7041    {
7042       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->ambrCfg, sizeof(AmbrCfg));
7043    }
7044    for(lcIdx = 0; lcIdx < ueCfg->numRlcLcs; lcIdx++)
7045    {
7046       freeRlcLcCfg(&ueCfg->rlcLcCfg[lcIdx]);
7047    }
7048    for(lcIdx = 0; lcIdx < ueCfg->numMacLcs; lcIdx++)
7049    {
7050       freeMacLcCfg(&ueCfg->macLcCfg[lcIdx]);
7051    }
7052    for(lcIdx = 0; lcIdx < ueCfg->numDrb; lcIdx++)
7053    {
7054       DU_FREE(ueCfg->upTnlInfo[lcIdx].tnlCfg1, sizeof(GtpTnlCfg));
7055    }
7056 }
7057
7058 /*******************************************************************
7059  *
7060  * @brief Function to free UecontextSetupDb
7061  *
7062  * @details
7063  *
7064  *    Function : freeF1UeDb
7065  *
7066  *    Functionality: Function to free UecontextSetupDb
7067  *
7068  * @params[in] UecontextSetupDb *
7069  * @return void
7070  *
7071  * ****************************************************************/
7072
7073 void freeF1UeDb(F1UeContextSetupDb *f1UeDb)
7074 {
7075
7076    if(f1UeDb->dlRrcMsg)
7077    {
7078       if(f1UeDb->dlRrcMsg->rrcMsgPdu)
7079       {
7080         //DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,\
7081                f1UeDb->dlRrcMsg->rrcMsgPdu, f1UeDb->dlRrcMsg->rrcMsgSize);
7082       }
7083       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
7084    }
7085    freeDuUeCfg(&f1UeDb->duUeCfg);
7086    memset(f1UeDb, 0, sizeof(F1UeContextSetupDb));
7087    DU_FREE(f1UeDb, sizeof(F1UeContextSetupDb));
7088 }
7089
7090 /*******************************************************************
7091  *
7092  * @brief Function to build Am cfg Info
7093  *
7094  * @details
7095  *
7096  *    Function : extractRlcAmCfg
7097  *
7098  *    Functionality: Function to build Am cfg Info
7099  *
7100  * @params[in] AmBearerCfg *
7101  *             void *
7102  *
7103  * @return ROK/RFAILED
7104  *
7105  * ****************************************************************/
7106
7107 void extractRlcAmCfg(AmBearerCfg *amCfgToSet, struct RLC_Config__am *rlcAmCfg)
7108 {
7109    if(rlcAmCfg)
7110    {
7111       /* UL AM */
7112       if(rlcAmCfg->dl_AM_RLC.sn_FieldLength)
7113       {
7114          amCfgToSet->ulAmCfg.snLenUl = *(rlcAmCfg->dl_AM_RLC.sn_FieldLength);
7115          /*TODO: Check the timer value when sent by real CU */
7116          amCfgToSet->ulAmCfg.reAssemTmr = rlcAmCfg->dl_AM_RLC.t_Reassembly;
7117          amCfgToSet->ulAmCfg.statProhTmr = rlcAmCfg->dl_AM_RLC.t_StatusProhibit;
7118       }
7119
7120       /* DL AM */
7121       if(rlcAmCfg->ul_AM_RLC.sn_FieldLength)
7122       {
7123          amCfgToSet->dlAmCfg.snLenDl = *(rlcAmCfg->ul_AM_RLC.sn_FieldLength);
7124          amCfgToSet->dlAmCfg.pollRetxTmr = rlcAmCfg->ul_AM_RLC.t_PollRetransmit;
7125          amCfgToSet->dlAmCfg.pollPdu   = rlcAmCfg->ul_AM_RLC.pollPDU;
7126          amCfgToSet->dlAmCfg.pollByte  = rlcAmCfg->ul_AM_RLC.pollByte;
7127          amCfgToSet->dlAmCfg.maxRetxTh = rlcAmCfg->ul_AM_RLC.maxRetxThreshold;
7128       }
7129    }
7130 }
7131
7132 /*******************************************************************
7133  *
7134  * @brief Function to build Um Bi Info
7135  *
7136  * @details
7137  *
7138  *    Function : extractRlcUmBiCfg
7139  *
7140  *    Functionality: Function to build Um Bi Info
7141  *
7142  * @params[in] UmBiDirBearerCfg *
7143  *             void *
7144  *
7145  * @return ROK/RFAILED
7146  *
7147  * ****************************************************************/
7148
7149 void extractRlcUmBiCfg(UmBiDirBearerCfg *umBiCfgToSet, struct RLC_Config__um_Bi_Directional *rlcBiCfg)
7150 {
7151    if(rlcBiCfg)
7152    {
7153       /* UL UM BI DIR Cfg */
7154       if(rlcBiCfg->dl_UM_RLC.sn_FieldLength)
7155       {
7156          umBiCfgToSet->ulUmCfg.snLenUlUm  = *(rlcBiCfg->dl_UM_RLC.sn_FieldLength);
7157          umBiCfgToSet->ulUmCfg.reAssemTmr = rlcBiCfg->dl_UM_RLC.t_Reassembly;
7158       }
7159
7160       /* DL UM BI DIR Cfg */
7161       if(rlcBiCfg->ul_UM_RLC.sn_FieldLength)
7162          umBiCfgToSet->dlUmCfg.snLenDlUm  = *(rlcBiCfg->ul_UM_RLC.sn_FieldLength);
7163    }
7164 }
7165
7166 /*******************************************************************
7167  *
7168  * @brief Function to build Um Ul Info
7169  *
7170  * @details
7171  *
7172  *    Function : extractRlcUmUlCfg
7173  *
7174  *    Functionality: Function to build Um Ul Info
7175  *
7176  * @params[in] UmUniDirUlBearerCfg *
7177  *             void *
7178  *
7179  * @return ROK/RFAILED
7180  *
7181  * ****************************************************************/
7182
7183 void extractRlcUmUlCfg(UmUniDirUlBearerCfg *umUlCfgToSet, struct RLC_Config__um_Uni_Directional_DL *umUlCfg)
7184 {
7185    if(umUlCfg)
7186    {
7187       if(umUlCfg->dl_UM_RLC.sn_FieldLength)
7188       {
7189          umUlCfgToSet->ulUmCfg.snLenUlUm  = *(umUlCfg->dl_UM_RLC.sn_FieldLength);
7190          umUlCfgToSet->ulUmCfg.reAssemTmr = umUlCfg->dl_UM_RLC.t_Reassembly;
7191       }
7192    }
7193 }
7194
7195 /*******************************************************************
7196  *
7197  * @brief Function to build Um Uni Dl Info
7198  *
7199  * @details
7200  *
7201  *    Function : extractRlcUmDlCfg
7202  *
7203  *    Functionality: Function to build Um Uni Dl Info
7204  *
7205  * @params[in] UmUniDirDlBearerCfg *
7206  *             void *
7207  *
7208  * @return ROK/RFAILED
7209  *
7210  * ****************************************************************/
7211 void extractRlcUmDlCfg(UmUniDirDlBearerCfg *umDlCfgToSet, struct RLC_Config__um_Uni_Directional_UL *umDlCfg)
7212 {
7213    if(umDlCfg)
7214    {
7215       if(umDlCfg->ul_UM_RLC.sn_FieldLength)
7216          umDlCfgToSet->dlUmCfg.snLenDlUm  = *(umDlCfg->ul_UM_RLC.sn_FieldLength);
7217    }
7218 }
7219
7220 /*******************************************************************
7221  *
7222  * @brief Function to extractRlcModeCfg
7223  *
7224  * @details
7225  *
7226  *    Function : extractRlcModeCfg
7227  *
7228  *    Functionality: Function to extractRlcModeCfg
7229  *
7230  * @params[in] RLC_Config_t *
7231  *             RlcBearerCfg *
7232  *             void  *
7233  * @return ROK/RFAILED
7234  *
7235  * ****************************************************************/
7236 void extractRlcModeCfg(uint8_t rlcMode, RlcBearerCfg *rlcDbCfg, RLC_Config_t *lcCfg)
7237 {
7238    if(lcCfg)
7239    {
7240       switch(rlcMode)
7241       {
7242          case RLC_AM :
7243             {
7244                if(lcCfg->choice.am)
7245                {
7246                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.amCfg, sizeof(AmBearerCfg));
7247                   if(rlcDbCfg->u.amCfg)
7248                      extractRlcAmCfg(rlcDbCfg->u.amCfg, lcCfg->choice.am);
7249                }
7250                break;
7251             }
7252          case RLC_UM_BI_DIRECTIONAL :
7253             {
7254                if(lcCfg->choice.um_Bi_Directional)
7255                {
7256                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
7257                   if(rlcDbCfg->u.umBiDirCfg)
7258                      extractRlcUmBiCfg(rlcDbCfg->u.umBiDirCfg, lcCfg->choice.um_Bi_Directional);
7259                }
7260                break;
7261             }
7262          case RLC_UM_UNI_DIRECTIONAL_UL :
7263             {
7264                if(lcCfg->choice.um_Uni_Directional_DL)
7265                {
7266                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
7267                   if(rlcDbCfg->u.umUniDirUlCfg)
7268                      extractRlcUmUlCfg(rlcDbCfg->u.umUniDirUlCfg, lcCfg->choice.um_Uni_Directional_DL);
7269                }
7270                break;
7271             }
7272          case RLC_UM_UNI_DIRECTIONAL_DL :
7273             {
7274                if(lcCfg->choice.um_Uni_Directional_UL)
7275                {
7276                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
7277                   if(rlcDbCfg->u.umUniDirDlCfg)
7278                      extractRlcUmDlCfg(rlcDbCfg->u.umUniDirDlCfg, lcCfg->choice.um_Uni_Directional_UL);
7279                }
7280                break;
7281             }
7282          default:
7283             DU_LOG("\nERROR  -->  DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
7284             break;
7285       }
7286    }
7287 }
7288
7289 /*******************************************************************
7290  *
7291  * @brief Function to extract extractUlLcCfg
7292  *
7293  * @details
7294  *
7295  *    Function : extractUlLcCfg
7296  *
7297  *    Functionality: Function to extract extractUlLcCfg
7298  *
7299  * @params[in] UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg
7300  * @return void
7301  *
7302  * ****************************************************************/
7303
7304 void extractUlLcCfg(UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg)
7305 {
7306    if(ulLcCfg)
7307    {
7308       if(ulLcCfg->ul_SpecificParameters)
7309       {
7310          f1UlLcCfg->priority = \
7311             ulLcCfg->ul_SpecificParameters->priority;
7312       if(ulLcCfg->ul_SpecificParameters->logicalChannelGroup)
7313       {
7314          f1UlLcCfg->lcGroup = \
7315            *(ulLcCfg->ul_SpecificParameters->logicalChannelGroup);
7316       }
7317       if(ulLcCfg->ul_SpecificParameters->schedulingRequestID)
7318       {
7319          f1UlLcCfg->schReqId = \
7320            *(ulLcCfg->ul_SpecificParameters->schedulingRequestID);
7321       }
7322       f1UlLcCfg->pbr = \
7323          ulLcCfg->ul_SpecificParameters->prioritisedBitRate;
7324       f1UlLcCfg->bsd = \
7325          ulLcCfg->ul_SpecificParameters->bucketSizeDuration;
7326       }
7327    }
7328 }
7329
7330 /*******************************************************************
7331  *
7332  * @brief Function to procRlcLcCfg
7333  *
7334  * @details
7335  *
7336  *    Function : procRlcLcCfg
7337  *
7338  *    Functionality: Function to procRlcLcCfg
7339  *
7340  * @params[in] rbId, lcId, rbType, rlcMod
7341  *             RLC_Config_t *, RlcBearerCfg * ,
7342  * @return void
7343  *
7344  * ****************************************************************/
7345
7346 void procRlcLcCfg(uint8_t rbId, uint8_t lcId, uint8_t rbType, uint8_t rlcMode,\
7347    uint8_t configType, RLC_Config_t *f1RlcCfg, RlcBearerCfg *lcCfg)
7348 {
7349
7350    lcCfg->rbId   = rbId;
7351    lcCfg->configType = configType;
7352
7353    if(rbType == RB_TYPE_SRB)
7354    {
7355       lcCfg->rbType = RB_TYPE_SRB;
7356       lcCfg->lcId   = rbId;
7357       lcCfg->lcType = LCH_DCCH;
7358       lcCfg->rlcMode = RLC_AM;
7359    }
7360    else if(rbType == RB_TYPE_DRB)
7361    {
7362       lcCfg->rbType = RB_TYPE_DRB;
7363       lcCfg->lcId   = lcId;
7364       lcCfg->lcType = LCH_DTCH;
7365       lcCfg->rlcMode = rlcMode;
7366    }
7367    if(f1RlcCfg) /* rlc mode config recived */
7368    {
7369       extractRlcModeCfg(lcCfg->rlcMode, lcCfg, f1RlcCfg);
7370    }
7371 }
7372
7373
7374
7375 /*******************************************************************
7376  *
7377  * @brief Fills DrbQos Info received by CU
7378  *
7379  * @details
7380  *
7381  *    Function : extractQosInfo
7382  *
7383  *    Functionality: Fills DrbQos Info received  by CU
7384  *
7385  * @params[in] DrbQosInfo *qosToAdd,
7386  *             QoSFlowLevelQoSParameters_t *qosFlowCfg
7387  * @return void
7388  *
7389  * ****************************************************************/
7390
7391 void extractQosInfo(DrbQosInfo *qosToAdd, QoSFlowLevelQoSParameters_t *qosFlowCfg)
7392 {
7393    qosToAdd->fiveQiType = qosFlowCfg->qoS_Characteristics.present;
7394    qosToAdd->u.nonDyn5Qi.fiveQi     =\
7395          qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
7396    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow)
7397    {
7398       qosToAdd->u.nonDyn5Qi.avgWindow = \
7399         *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
7400    }
7401    qosToAdd->u.nonDyn5Qi.maxDataBurstVol = \
7402       *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
7403    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel)
7404    {
7405       qosToAdd->u.nonDyn5Qi.priorLevel = \
7406          *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel);
7407    }
7408    qosToAdd->ngRanRetPri.priorityLevel = \
7409       qosFlowCfg->nGRANallocationRetentionPriority.priorityLevel;
7410    qosToAdd->ngRanRetPri.preEmptionCap = \
7411       qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionCapability;
7412    qosToAdd->ngRanRetPri.preEmptionVul = \
7413       qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionVulnerability;
7414    if(qosFlowCfg->gBR_QoS_Flow_Information)
7415    {
7416       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateDl, \
7417          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.buf, \
7418          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.size);
7419       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateUl, \
7420          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.buf, \
7421          qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.size);
7422       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateDl,\
7423          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.buf, \
7424          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.size);
7425       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateUl,\
7426          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.buf, \
7427          qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.size);
7428    }
7429    qosToAdd->pduSessionId = 0;
7430    qosToAdd->ulPduSessAggMaxBitRate = 0;
7431 }
7432
7433 /*******************************************************************
7434  *
7435  * @brief Function to extract GTP Tunnel Info from CU
7436  *
7437  * @details
7438  *
7439  *    Function : extractUpTnlInfo
7440  *
7441  *    Functionality: Function to extract GTP Tunnel Info from CU
7442  *
7443  * @params[in] F1AP message
7444  * @return ROK/RFAILED
7445  *
7446  * ****************************************************************/
7447
7448 uint8_t extractUpTnlInfo(uint8_t drbId, uint8_t configType,\
7449    ULUPTNLInformation_ToBeSetup_List_t *tnlInfo, UpTnlCfg *upTnlInfo)
7450 {
7451    uint8_t tnlIdx;
7452    uint32_t ipv4_du = 0;
7453    GTPTunnel_t *gtpTunnel = NULLP;
7454
7455    upTnlInfo->drbId = drbId;
7456    upTnlInfo->configType = configType;
7457 #ifdef O1_ENABLE
7458    cmInetAddr((S8*)g_cfg.DU_IPV4_Addr, &ipv4_du);
7459 #else
7460    cmInetAddr((char *)DU_IP_V4_ADDR, &ipv4_du);
7461 #endif
7462
7463    for(tnlIdx=0; tnlIdx < tnlInfo->list.count; tnlIdx++)
7464    {
7465       if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
7466       {
7467          if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel)
7468          {
7469             gtpTunnel = tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel;
7470             DU_ALLOC(upTnlInfo->tnlCfg1, sizeof(GtpTnlCfg));
7471             if(upTnlInfo->tnlCfg1 == NULLP)
7472             {
7473                DU_LOG("\nERROR  -->  F1AP : extractUpTnlInfo: Failed to allocate mmeory for tunnel cfg 1");
7474                return RFAILED;
7475             }
7476             bitStringToInt(&gtpTunnel->transportLayerAddress, &upTnlInfo->tnlCfg1->ulTnlAddress);
7477             upTnlInfo->tnlCfg1->dlTnlAddress = ipv4_du;
7478             if(gtpTunnel->gTP_TEID.size > 0)
7479             {
7480                teIdStringToInt(gtpTunnel->gTP_TEID.buf, &upTnlInfo->tnlCfg1->teId);
7481             }
7482          }
7483          break;
7484       }
7485    }
7486    return ROK;
7487 }
7488 /*******************************************************************
7489 *
7490 * @brief Function to extract Drb Qos Cfg Info from CU
7491 *
7492 * @details
7493 *
7494 *    Function : extractDrbQosCfg
7495 *
7496 *    Functionality: Function to extract Drb Qos Cfg Info from CU
7497 *
7498 * @params[in] DRB_Information_t *drbInfo, LcCfg *macLcToAdd
7499 * @return ROK/RFAILED
7500 *
7501 * ****************************************************************/
7502
7503 uint8_t extractDrbQosCfg(DRB_Information_t *drbInfo, LcCfg *macLcToAdd )
7504 {
7505    if(!macLcToAdd->drbQos)
7506    {
7507       DU_ALLOC_SHRABL_BUF(macLcToAdd->drbQos, sizeof(DrbQosInfo));
7508       if(macLcToAdd->drbQos == NULLP)
7509       {
7510          DU_LOG("\nERROR  -->  DUAPP:Memory failed at allocating DrbQos at extractDrbCfg()");
7511          return RFAILED;
7512       }
7513
7514    }
7515    if(drbInfo->dRB_QoS.qoS_Characteristics.present == QoS_Characteristics_PR_non_Dynamic_5QI)
7516    {
7517       extractQosInfo(macLcToAdd->drbQos, &drbInfo->dRB_QoS);
7518       macLcToAdd->dlLcCfg.lcp = macLcToAdd->drbQos->ngRanRetPri.priorityLevel;
7519    }
7520    if(!macLcToAdd->snssai)
7521    {
7522       DU_ALLOC_SHRABL_BUF(macLcToAdd->snssai, sizeof(Snssai));
7523       if(macLcToAdd->snssai == NULLP)
7524       {
7525          DU_LOG("\nERROR  -->  DUAPP : Memory failed at allocating SNSSAI at extractDrbCfg()");
7526          return RFAILED;
7527       }
7528    }
7529    memcpy(&macLcToAdd->snssai->sst, drbInfo->sNSSAI.sST.buf, \
7530          drbInfo->sNSSAI.sST.size);
7531    if(drbInfo->sNSSAI.sD)
7532    {
7533       memcpy(macLcToAdd->snssai->sd, drbInfo->sNSSAI.sD->buf, \
7534             drbInfo->sNSSAI.sD->size);
7535    }
7536    return ROK;
7537 }
7538 /*******************************************************************
7539  *
7540  * @brief Function to extract DRB info received from CU
7541  *
7542  * @details
7543  *
7544  *    Function : extractDrbCfg
7545  *
7546  *    Functionality: Function to extract DRB info received from CU
7547  *
7548  * @params[in] F1AP message
7549  * @return void
7550  *
7551  * ****************************************************************/
7552 uint8_t extractDrbCfg(DRBs_ToBeSetup_Item_t *drbItem,DRBs_ToBeSetupMod_Item_t *drbSetupModItem,\
7553 LcCfg *macLcToAdd, UpTnlCfg *upTnlInfo)
7554 {
7555    DRB_Information_t *drbInfo = NULLP;
7556
7557    if(drbItem != NULLP)
7558    {
7559       if(extractUpTnlInfo(drbItem->dRBID, CONFIG_ADD, &drbItem->uLUPTNLInformation_ToBeSetup_List, upTnlInfo) != ROK)
7560       {
7561          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7562          return RFAILED;
7563       }
7564       if(drbItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7565       {
7566          if(drbItem->qoSInformation.choice.choice_extension->value.present == QoSInformation_ExtIEs__value_PR_DRB_Information)
7567          {
7568             drbInfo = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7569             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7570             {
7571                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7572                return RFAILED;
7573             }
7574          }
7575       }
7576    }
7577    else if(drbSetupModItem != NULLP)
7578    {
7579       if(extractUpTnlInfo(drbSetupModItem->dRBID, CONFIG_ADD, &drbSetupModItem->uLUPTNLInformation_ToBeSetup_List,\
7580       upTnlInfo) != ROK)
7581       {
7582          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7583          return RFAILED;
7584       }
7585       if(drbSetupModItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7586       {
7587          if(drbSetupModItem->qoSInformation.choice.choice_extension->value.present ==\
7588          QoSInformation_ExtIEs__value_PR_DRB_Information)
7589          {
7590             drbInfo = &drbSetupModItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7591             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7592             {
7593                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7594                return RFAILED;
7595             }
7596
7597          }
7598       }
7599    }
7600
7601    return ROK;
7602 }
7603
7604 /*******************************************************************
7605  *
7606  * @brief Function to extract RB info received from CU
7607  *
7608  * @details
7609  *
7610  *    Function : extractMacRbCfg
7611  *
7612  *    Functionality: Function to extract RB info received from CU
7613  *
7614  * @params[in] F1AP message
7615  * @return ROK/RFAILED
7616  *
7617  * ****************************************************************/
7618
7619 uint8_t extractMacRbCfg(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbCfg,\
7620 DRBs_ToBeSetupMod_Item_t *drbSetupModCfg,  LogicalChannelConfig_t *ulLcCfg, LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7621 {
7622    if(drbCfg != NULLP)
7623    {
7624       if(extractDrbCfg(drbCfg, NULL, lcCfg, upTnlInfo) != ROK)
7625       {
7626          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7627          return RFAILED;
7628       }
7629    }
7630    else if(drbSetupModCfg != NULLP)
7631    {
7632       if(extractDrbCfg(NULL, drbSetupModCfg, lcCfg, upTnlInfo) != ROK)
7633       {
7634          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7635          return RFAILED;
7636       }
7637    }
7638    else
7639    {
7640       lcCfg->drbQos = NULLP;
7641       lcCfg->snssai = NULLP;
7642       if(lcCfg->lcId == SRB2_LCID)
7643          lcCfg->dlLcCfg.lcp = LC_PRIORITY_3;
7644       else
7645          lcCfg->dlLcCfg.lcp = LC_PRIORITY_1;
7646    }
7647    if(ulLcCfg)
7648    {
7649       lcCfg->ulLcCfgPres = true;
7650       extractUlLcCfg(&lcCfg->ulLcCfg, ulLcCfg);
7651    }
7652    else
7653       lcCfg->ulLcCfgPres = false;
7654    return ROK;
7655 }
7656
7657 /*******************************************************************
7658  *
7659  * @brief Function processing LC config info received from CU
7660  *
7661  * @details
7662  *
7663  *    Function : procMacLcCfg
7664  *
7665  *    Functionality: Function processing LC config info received from CU
7666  *
7667  * @params[in] F1AP message
7668  * @return ROK/RFAILED
7669  *
7670  * ****************************************************************/
7671
7672 uint8_t procMacLcCfg(uint8_t lcId, uint8_t rbType, uint8_t configType,\
7673 DRBs_ToBeSetup_Item_t *drbItem, DRBs_ToBeSetupMod_Item_t *drbSetupModItem, LogicalChannelConfig_t *ulLcCfg,\
7674 LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7675 {
7676    uint8_t ret = ROK;
7677
7678    lcCfg->lcId = lcId;
7679    lcCfg->configType = configType;
7680    if(rbType == RB_TYPE_SRB)
7681    {
7682       ret = extractMacRbCfg(lcId, NULL,NULL, ulLcCfg, lcCfg, NULL);
7683    }
7684    else if(rbType == RB_TYPE_DRB)
7685    {
7686       if(drbItem != NULL)
7687         ret = extractMacRbCfg(lcId, drbItem, NULL, ulLcCfg, lcCfg, upTnlInfo);
7688       else if(drbSetupModItem != NULL)
7689         ret = extractMacRbCfg(lcId, NULL, drbSetupModItem, ulLcCfg, lcCfg, upTnlInfo);
7690    }
7691    return ret;
7692 }
7693
7694 /*******************************************************************
7695  *
7696  * @brief Function to extract Rlc cfg To Add/Mod in CellGrp Info
7697  *
7698  * @details
7699  *
7700  *    Function : extractRlcCfgToAddMod
7701  *
7702  *    Functionality: Function to extract Rlc cfg To Add/Mod in CellGrp Info
7703  *
7704  * @params[in] CellGroupConfigRrc__rlc_BearerTo pointer
7705  *             DuUeCfg Pointer
7706  * @return ROK/RFAILED
7707  *
7708  * ****************************************************************/
7709
7710 uint8_t extractRlcCfgToAddMod(struct CellGroupConfigRrc__rlc_BearerToAddModList *lcCfg, DuUeCfg *ueCfgDb)
7711 {
7712   uint8_t idx, rbId, lcId, rlcMode, rbType;
7713   RLC_Config_t *f1RlcCfg = NULLP;
7714   LogicalChannelConfig_t *macUlLcCfg = NULLP;
7715
7716   for(idx = 0; idx < lcCfg->list.count; idx++)
7717   {
7718      lcId = lcCfg->list.array[idx]->logicalChannelIdentity;
7719      if(lcCfg->list.array[idx]->servedRadioBearer)
7720      {
7721         /* RadioBearer for SRB/DRB */
7722         if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7723         RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
7724         {
7725            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.srb_Identity;
7726            rbType = RB_TYPE_SRB;
7727         }
7728         else if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7729         RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
7730         {
7731            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.drb_Identity;
7732            rbType = RB_TYPE_DRB;
7733         }
7734         else
7735         {
7736            DU_LOG("\nERROR  -->  No components present in Bearer config to ADD/MOD");
7737            return RFAILED;
7738         }
7739         /* MAC UL LC Config */
7740         if(lcCfg->list.array[idx]->mac_LogicalChannelConfig)
7741         {
7742            macUlLcCfg = lcCfg->list.array[idx]->mac_LogicalChannelConfig;
7743         }
7744      }
7745      else
7746      {
7747         DU_LOG("\nERROR  -->  DUAPP: Received RadioBearer config is NULL");
7748         return RFAILED;
7749      }
7750      /* RLC Mode Config */
7751      if(lcCfg->list.array[idx]->rlc_Config)
7752      {
7753         rlcMode  = lcCfg->list.array[idx]->rlc_Config->present;
7754         f1RlcCfg = lcCfg->list.array[idx]->rlc_Config;
7755      }
7756
7757      /* Filling RLC/MAC Config*/
7758      memset(&ueCfgDb->macLcCfg[idx], 0, sizeof(LcCfg));
7759      memset(&ueCfgDb->rlcLcCfg[idx], 0, sizeof(RlcBearerCfg));
7760      procRlcLcCfg(rbId, lcId, rbType, rlcMode, CONFIG_UNKNOWN, f1RlcCfg, &(ueCfgDb->rlcLcCfg[idx]));
7761      if(procMacLcCfg(lcId, rbType, CONFIG_UNKNOWN, NULL, NULL, macUlLcCfg, &ueCfgDb->macLcCfg[idx], NULL) != ROK)
7762      {
7763         DU_LOG("\nERROR  -->  DU APP : Failed while filling MAC LC config at extractRlcCfgToAddMod()");
7764         return RFAILED;
7765      }
7766      (ueCfgDb->numRlcLcs)++;
7767      (ueCfgDb->numMacLcs)++;
7768          DU_LOG("\nDEBUG  -> DUAPP: extractRlcCfgToAddMod:RBType:%d, DrbID: %d,lcId:%d, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
7769                             rbType, rbId, lcId, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
7770   }
7771   //TODO: To send the failure cause in UeContextSetupRsp
7772   return ROK;
7773 }
7774
7775 /*******************************************************************
7776  *
7777  * @brief DeAlloc pdsch serv cell config info
7778  *
7779  * @details
7780  *
7781  *    Function : freeMacPdschServCellInfo
7782  *
7783  *    Functionality: DeAlloc pdsch serv cell config info
7784  *
7785  * @params[in] PdschServCellCfg pointer
7786  * @return void
7787  *
7788  * ****************************************************************/
7789
7790 void freeMacPdschServCellInfo(PdschServCellCfg *pdsch)
7791 {
7792    if(pdsch->xOverhead)
7793    {
7794       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->xOverhead, sizeof(PdschXOverhead));
7795    }
7796    if(pdsch->codeBlkGrpFlushInd)
7797    {
7798       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->codeBlkGrpFlushInd, sizeof(bool));
7799    }
7800    if(pdsch->maxCodeBlkGrpPerTb)
7801    {
7802       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
7803    }
7804    if(pdsch->maxMimoLayers)
7805    {
7806       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxMimoLayers, sizeof(uint8_t));
7807    }
7808 }
7809
7810 /*******************************************************************
7811  *
7812  * @brief Free Serving cell Info
7813  *
7814  * @details
7815  *
7816  *    Function : freeMacServingCellInfo
7817  *
7818  *    Functionality: Free Serving cell Info
7819  *
7820  * @params[in] ServCellCfgInfo *srvCellCfg
7821  * @return void
7822  *
7823  * ****************************************************************/
7824 void freeMacServingCellInfo(ServCellCfgInfo *srvCellCfg)
7825 {
7826    uint8_t timeDomRsrcIdx;
7827
7828    if(srvCellCfg->initDlBwp.pdschPresent)
7829    {
7830       for(timeDomRsrcIdx = 0; timeDomRsrcIdx < srvCellCfg->initDlBwp.pdschCfg.numTimeDomRsrcAlloc; timeDomRsrcIdx++)
7831       {
7832          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, \
7833             srvCellCfg->initDlBwp.pdschCfg.timeDomRsrcAllociList[timeDomRsrcIdx].k0, sizeof(uint8_t));
7834       }
7835    }
7836
7837    freeMacPdschServCellInfo(&srvCellCfg->pdschServCellCfg);
7838    if(srvCellCfg->bwpInactivityTmr)
7839    {
7840       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
7841    }
7842
7843    if(srvCellCfg->initUlBwp.pucchPresent)
7844    {
7845       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->initUlBwp.pucchCfg.dlDataToUlAck, sizeof(PucchDlDataToUlAck));
7846    }
7847 }
7848
7849 /*******************************************************************
7850  *
7851  * @brief Free cell Grp Cfg Info
7852  *
7853  * @details
7854  *
7855  *    Function : freeUeReCfgCellGrpInfo
7856  *
7857  *    Functionality: Free cell Grp Cfg Info
7858  *
7859  * @params[in] MacUeCfg*  duUeCfg
7860  * @return void
7861  *
7862  * ****************************************************************/
7863
7864 void freeUeReCfgCellGrpInfo(MacUeCfg *macUeCfg)
7865 {
7866    freeMacServingCellInfo(&macUeCfg->spCellCfg.servCellCfg);
7867 }
7868
7869 /*******************************************************************
7870  *
7871  * @brief Fills Reconfig SchReqReConfig
7872  *
7873  * @details
7874  *
7875  *    Function : extractSchReqReConfig
7876  *
7877  *    Functionality: Fills Reconfig SchReqReConfig
7878  *
7879  * @params[in] SchedulingRequestConfig_t *cuSchedReq
7880  *             SchedReqCfg*  macSchedReq
7881  * @return void
7882  *
7883  * ****************************************************************/
7884 void extractSchReqReConfig(SchedulingRequestConfig_t *cuSchedReq, SchedReqCfg *macSchedReq)
7885 {
7886    uint8_t schReqIdx = 0;
7887    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqListToAdd = NULLP;
7888    struct SchedulingRequestConfig__schedulingRequestToReleaseList *schReqListToRel = NULLP;
7889
7890    if(cuSchedReq->schedulingRequestToAddModList)
7891    {
7892       schReqListToAdd = cuSchedReq->schedulingRequestToAddModList;
7893       if(schReqListToAdd->list.count)
7894       {
7895          macSchedReq->addModListCount = schReqListToAdd->list.count;
7896          for(schReqIdx = 0; schReqIdx < schReqListToAdd->list.count; schReqIdx++)
7897          {
7898             macSchedReq->addModList[schReqIdx].schedReqId = \
7899                schReqListToAdd->list.array[schReqIdx]->schedulingRequestId;
7900             macSchedReq->addModList[schReqIdx].srProhibitTmr = \
7901                *(schReqListToAdd->list.array[schReqIdx]->sr_ProhibitTimer);
7902             macSchedReq->addModList[schReqIdx].srTransMax    =\
7903                schReqListToAdd->list.array[schReqIdx]->sr_TransMax;
7904          }
7905       }
7906    }
7907    /* Scheduling Req To release */
7908    if(cuSchedReq->schedulingRequestToReleaseList)
7909    {
7910       schReqListToRel = cuSchedReq->schedulingRequestToReleaseList;
7911       if(schReqListToRel->list.count)
7912       {
7913          macSchedReq->relListCount = schReqListToRel->list.count;
7914          for(schReqIdx = 0; schReqIdx < schReqListToRel->list.count; schReqIdx++)
7915          {
7916             macSchedReq->relList[schReqIdx] = \
7917                *schReqListToRel->list.array[schReqIdx];
7918          }
7919       }
7920    }
7921 }
7922
7923 /*******************************************************************
7924  *
7925  * @brief Fills TagReconfig
7926  *
7927  * @details
7928  *
7929  *    Function : extractTagReconfig
7930  *
7931  *    Functionality: Fills extractTagReconfig
7932  *
7933  * @params[in] TAG_Config_t *cuTagCfg
7934  *             TagCfg *macTagCfg
7935  * @return void
7936  *
7937  * ****************************************************************/
7938
7939 void extractTagReconfig(TAG_Config_t *cuTagCfg, TagCfg *macTagCfg)
7940 {
7941   uint8_t tagIdx = 0;
7942   struct TAG_Config__tag_ToAddModList  *tagListToAddMod = NULLP;
7943   struct TAG_Config__tag_ToReleaseList *tagListToRel = NULLP;
7944
7945   /* Tag config to AddMod */
7946   if(cuTagCfg->tag_ToAddModList)
7947   {
7948      tagListToAddMod = cuTagCfg->tag_ToAddModList;
7949      if(tagListToAddMod->list.count)
7950      {
7951         macTagCfg->addModListCount = tagListToAddMod->list.count;
7952         for(tagIdx = 0; tagIdx < tagListToAddMod->list.count; tagIdx++)
7953         {
7954            macTagCfg->addModList[tagIdx].tagId =\
7955               tagListToAddMod->list.array[tagIdx]->tag_Id;
7956            macTagCfg->addModList[tagIdx].timeAlignTimer = \
7957
7958               tagListToAddMod->list.array[tagIdx]->timeAlignmentTimer;
7959         }
7960      }
7961   }
7962   /* Tag config to release */
7963   if(cuTagCfg->tag_ToReleaseList)
7964   {
7965      tagListToRel = cuTagCfg->tag_ToReleaseList;
7966      if(tagListToRel->list.count)
7967      {
7968         macTagCfg->relListCount = tagListToRel->list.count;
7969         for(tagIdx = 0; tagIdx < tagListToRel->list.count; tagIdx++)
7970         {
7971            macTagCfg->relList[tagIdx] = *tagListToRel->list.array[tagIdx];
7972         }
7973      }
7974   }
7975 }
7976
7977 /*******************************************************************
7978  *
7979  * @brief Fills PdcchCfg received by CU
7980  *
7981  * @details
7982  *
7983  *    Function : extractPdcchCfg
7984  *
7985  *    Functionality: Fills PdcchCfg received  by CU
7986  *
7987  * @params[in] PDCCH_Config_t *cuPdcchCfg,
7988  *             PdcchConfig *duPdcchCfg
7989  * @return void
7990  *
7991  * ****************************************************************/
7992
7993 void extractPdcchCfg(PDCCH_Config_t *cuPdcchCfg, PdcchConfig *macPdcchCfg)
7994 {
7995    uint8_t cRsetIdx = 0;
7996    uint8_t srchSpcIdx = 0;
7997
7998    struct PDCCH_Config__controlResourceSetToAddModList *cRsetToAddModList = NULLP;
7999    struct PDCCH_Config__controlResourceSetToReleaseList *cRsetToRelList = NULLP;
8000    struct PDCCH_Config__searchSpacesToAddModList *srchSpcToAddModList = NULLP;
8001    struct PDCCH_Config__searchSpacesToReleaseList *srchSpcToRelList = NULLP;
8002
8003
8004    /* Control Resource Set To Add/Mod List */
8005    if(cuPdcchCfg->controlResourceSetToAddModList)
8006    {
8007       cRsetToAddModList = cuPdcchCfg->controlResourceSetToAddModList;
8008       if(cRsetToAddModList->list.count)
8009       {
8010          macPdcchCfg->numCRsetToAddMod = cRsetToAddModList->list.count;
8011          for(cRsetIdx = 0; cRsetIdx < cRsetToAddModList->list.count; cRsetIdx++)
8012          {
8013             macPdcchCfg->cRSetToAddModList[cRsetIdx].cRSetId = \
8014               cRsetToAddModList->list.array[cRsetIdx]->controlResourceSetId;
8015             bitStringToInt(&cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources,\
8016                macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc);
8017             macPdcchCfg->cRSetToAddModList[cRsetIdx].duration = \
8018               cRsetToAddModList->list.array[cRsetIdx]->duration;
8019
8020             macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType = \
8021               cRsetToAddModList->list.array[cRsetIdx]->cce_REG_MappingType.present;
8022             if(macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType == CCE_REG_MAPPINGTYPE_PR_INTERLEAVED)
8023             {
8024                //TODO: handle the case for Interleaved
8025             }
8026             macPdcchCfg->cRSetToAddModList[cRsetIdx].precoderGranularity = \
8027               cRsetToAddModList->list.array[cRsetIdx]->precoderGranularity;
8028             if(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID)
8029             {
8030                macPdcchCfg->cRSetToAddModList[cRsetIdx].dmrsScramblingId= \
8031                   *(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID);
8032             }
8033          }
8034       }
8035
8036    }
8037    /* Control Resource Set To Release List */
8038    if(cuPdcchCfg->controlResourceSetToReleaseList)
8039    {
8040       cRsetToRelList = cuPdcchCfg->controlResourceSetToReleaseList;
8041       if(cRsetToRelList->list.count)
8042       {
8043          macPdcchCfg->numCRsetToRel = cRsetToRelList->list.count;
8044          for(cRsetIdx = 0; cRsetIdx < cRsetToRelList->list.count; cRsetIdx++)
8045          {
8046             macPdcchCfg->cRSetToRelList[cRsetIdx] = *(cRsetToRelList->list.array[cRsetIdx]);
8047          }
8048       }
8049    }
8050
8051    /* Search space To Add/Mod List */
8052    if(cuPdcchCfg->searchSpacesToAddModList)
8053    {
8054       srchSpcToAddModList = cuPdcchCfg->searchSpacesToAddModList;
8055       if(srchSpcToAddModList->list.count)
8056       {
8057          macPdcchCfg->numSearchSpcToAddMod = srchSpcToAddModList->list.count;
8058          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToAddModList->list.count; srchSpcIdx++)
8059          {
8060             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceId =\
8061                srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceId;
8062             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].cRSetId =\
8063                *(srchSpcToAddModList->list.array[srchSpcIdx]->controlResourceSetId);
8064             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset)
8065             {
8066                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset =\
8067                   srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset->present;
8068             }
8069             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot)
8070             {
8071                bitStringToInt(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot,\
8072                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSymbolsWithinSlot);
8073             }
8074             if(srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates)
8075             {
8076               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel1 = \
8077                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel1;
8078               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel2 = \
8079                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel2;
8080               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel4 = \
8081                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel4;
8082
8083               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel8 = \
8084                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel8;
8085
8086               macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel16 = \
8087                   srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel16;
8088             }
8089             if(srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType)
8090             {
8091                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType =\
8092                   srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->present;
8093                if(macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType == SEARCHSPACETYPE_PR_UE_SPECIFIC)
8094                {
8095                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].ueSpecificDciFormat =\
8096                      srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->choice.ue_Specific->dci_Formats;
8097                }
8098
8099             }
8100          }
8101       }
8102    }
8103    /* Search space To Rel List */
8104    if(cuPdcchCfg->searchSpacesToReleaseList)
8105    {
8106       srchSpcToRelList = cuPdcchCfg->searchSpacesToReleaseList;
8107       if(srchSpcToRelList->list.count)
8108       {
8109          macPdcchCfg->numSearchSpcToRel = srchSpcToRelList->list.count;
8110          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToRelList->list.count; srchSpcIdx++)
8111          {
8112             macPdcchCfg->searchSpcToRelList[srchSpcIdx] =\
8113                *(srchSpcToRelList->list.array[srchSpcIdx]);
8114          }
8115       }
8116    }
8117 }
8118
8119 /*******************************************************************
8120  *
8121  * @brief Fills PdschCfg received by CU
8122  *
8123  * @details
8124  *
8125  *    Function : extractPdschCfg
8126  *
8127  *    Functionality: Fills PdschCfg received  by CU
8128  *
8129  * @params[in] PDSCH_Config_t *cuPdschCfg = Information which is send by CU,
8130  *                   which we have stored in F1UeContextSetupDb,
8131  *             PdschConfig *macPdschCfg = Used to Store the information which
8132  *                   needs to send in other layer, as well as this can be the variable
8133  *                   which stores the information in DuCb,
8134  *             PdschConfig *storedPdschCfg =  Null in case of sending the
8135  *                   information to other layer else it will have stored pdsch
8136  *                   configuration in copyOfmacUeCfg.
8137  * @return void
8138  *
8139  * ****************************************************************/
8140
8141 void extractPdschCfg(PDSCH_Config_t *cuPdschCfg, PdschConfig *macPdschCfg, PdschConfig *storedPdschCfg)
8142 {
8143    uint8_t timeDomIdx;
8144    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAlloc = NULLP;
8145
8146    if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
8147    {
8148       if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->present == \
8149             PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup)
8150       {
8151          if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup)
8152          {
8153             macPdschCfg->dmrsDlCfgForPdschMapTypeA.addPos = \
8154                *(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_AdditionalPosition);
8155          }
8156       }
8157    }
8158    macPdschCfg->resourceAllocType = cuPdschCfg->resourceAllocation;
8159    if(cuPdschCfg->pdsch_TimeDomainAllocationList)
8160    {
8161       timeDomAlloc = cuPdschCfg->pdsch_TimeDomainAllocationList;
8162       if(timeDomAlloc->present ==\
8163             PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup)
8164       {
8165          if(timeDomAlloc->choice.setup)
8166          {
8167             macPdschCfg->numTimeDomRsrcAlloc  = timeDomAlloc->choice.setup->list.count;
8168             for(timeDomIdx = 0; timeDomIdx < timeDomAlloc->choice.setup->list.count; timeDomIdx++)
8169             {
8170                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 = NULLP;
8171                if(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0)
8172                {
8173                   if(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 == NULL)
8174                   {
8175                      if(storedPdschCfg)
8176                      {
8177                         if(storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
8178                         {
8179                            macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 =\
8180                            storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0;
8181                         }
8182                         else
8183                         {
8184                            DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
8185                         }
8186                      }
8187                      else
8188                      {
8189                         DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
8190                      }
8191                      if(!macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
8192                      {
8193                         DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for k0 at extractPdschCfg()");
8194                         return RFAILED;
8195                      }
8196                   }
8197                   *(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0) = \
8198                   *(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0);
8199                }
8200                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
8201                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
8202                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
8203                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8204             }
8205          }
8206       }
8207    }
8208    macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
8209    if(cuPdschCfg->maxNrofCodeWordsScheduledByDCI)
8210       macPdschCfg->numCodeWordsSchByDci = *(cuPdschCfg->maxNrofCodeWordsScheduledByDCI);
8211    if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_staticBundling)
8212    {
8213       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
8214       if(cuPdschCfg->prb_BundlingType.choice.staticBundling)
8215       {
8216          if(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize)
8217          {
8218             macPdschCfg->bundlingInfo.StaticBundling.size = \
8219                *(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize);
8220          }
8221       }
8222    }
8223    else if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_dynamicBundling)
8224    {
8225       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
8226    }
8227
8228 }
8229
8230 /*******************************************************************
8231  *
8232  * @brief Fills PdschServingCellCfg received by CU
8233  *
8234  * @details
8235  *
8236  *    Function : extractPdschServingCellCfg
8237  *
8238  *    Functionality: Fills PdschCfg received  by CU
8239  *
8240  * @params[in] PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg,
8241  *             PdschServCellCfg *macUePdschSrvCellCfg
8242  * @return ROK/RFAILED
8243  *
8244  * ****************************************************************/
8245
8246 uint8_t extractPdschServingCellCfg(PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg, PdschServCellCfg *macUePdschSrvCellCfg)
8247 {
8248    if(cuPdschSrvCellCfg->codeBlockGroupTransmission)
8249    {
8250       if(cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup)
8251       {
8252          if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
8253          {
8254             *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
8255                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
8256          }
8257          else
8258          {
8259             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
8260             if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
8261             {
8262                *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
8263                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
8264             }
8265             else
8266             {
8267                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
8268                return RFAILED;
8269             }
8270          }
8271          if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
8272          {
8273             *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
8274                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
8275          }
8276          else
8277          {
8278             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->codeBlkGrpFlushInd , sizeof(bool));
8279             if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
8280             {
8281                *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
8282                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
8283             }
8284             else
8285             {
8286                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
8287                return RFAILED;
8288             }
8289          }
8290       }
8291    }
8292    if(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH)
8293    {
8294       macUePdschSrvCellCfg->numHarqProcForPdsch = *(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH);
8295    }
8296    if(cuPdschSrvCellCfg->ext1)
8297    {
8298       if(cuPdschSrvCellCfg->ext1->maxMIMO_Layers)
8299       {
8300         if(macUePdschSrvCellCfg->maxMimoLayers)
8301         {
8302            *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
8303         }
8304         else
8305         {
8306            DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxMimoLayers, sizeof(uint8_t));
8307            if(macUePdschSrvCellCfg->maxMimoLayers)
8308            {
8309               *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
8310            }
8311            else
8312            {
8313               DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
8314               return RFAILED;
8315            }
8316         }
8317       }
8318    }
8319    if(cuPdschSrvCellCfg->xOverhead)
8320    {
8321       if(macUePdschSrvCellCfg->xOverhead)
8322       {
8323          *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
8324       }
8325       else
8326       {
8327          DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->xOverhead, sizeof(PdschXOverhead));
8328          if(macUePdschSrvCellCfg->xOverhead)
8329          {
8330             *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
8331          }
8332          else
8333          {
8334             DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
8335             return RFAILED;
8336          }
8337       }
8338    }
8339    return ROK;
8340 }
8341
8342 /*******************************************************************
8343  *
8344  * @brief Fills PuschCfg received by CU
8345  *
8346  * @details
8347  *
8348  *    Function : extractPuschCfg
8349  *
8350  *    Functionality: Fills PuschCfg received  by CU
8351  *
8352  * @params[in] BWP_UplinkDedicated__pusch_Config *cuPuschCfg,
8353  *             PuschCfg *macPuschCfg
8354  * @return void
8355  *
8356  * ****************************************************************/
8357
8358 void extractPuschCfg(struct BWP_UplinkDedicated__pusch_Config *cuPuschCfg, PuschCfg *macPuschCfg)
8359 {
8360    uint8_t timeDomIdx = 0;
8361    DMRS_UplinkConfig_t *dmrsUlCfg = NULLP;
8362    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList = NULLP;
8363
8364    if(cuPuschCfg->present == BWP_UplinkDedicated__pusch_Config_PR_setup)
8365    {
8366       if(cuPuschCfg->choice.setup)
8367       {
8368          if(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH)
8369          {
8370              macPuschCfg->dataScramblingId = \
8371                 *(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH);
8372          }
8373          if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA)
8374          {
8375             if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->present == PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup)
8376             {
8377                if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup)
8378                {
8379                   dmrsUlCfg = (cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup);
8380                   if(dmrsUlCfg->dmrs_AdditionalPosition)
8381                   {
8382                      macPuschCfg->dmrsUlCfgForPuschMapTypeA.addPos =\
8383                         *(dmrsUlCfg->dmrs_AdditionalPosition);
8384                   }
8385                   if(dmrsUlCfg->transformPrecodingDisabled)
8386                   {
8387                      if(dmrsUlCfg->transformPrecodingDisabled->scramblingID0)
8388                      {
8389                         macPuschCfg->dmrsUlCfgForPuschMapTypeA.transPrecodDisabled.scramblingId0 = \
8390                            *(dmrsUlCfg->transformPrecodingDisabled->scramblingID0);
8391                      }
8392                   }
8393                }
8394             }
8395          }
8396          /*Res Alloc Type for UL */
8397          if(cuPuschCfg->choice.setup->resourceAllocation)
8398          {
8399             macPuschCfg->resourceAllocType = \
8400                cuPuschCfg->choice.setup->resourceAllocation;
8401          }
8402          if(cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList)
8403          {
8404             timeDomAllocList = cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList;
8405             if(timeDomAllocList->present == PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup)
8406             {
8407                if(timeDomAllocList->choice.setup)
8408                {
8409                   macPuschCfg->numTimeDomRsrcAlloc = timeDomAllocList->choice.setup->list.count;
8410                   for(timeDomIdx = 0; timeDomIdx <timeDomAllocList->choice.setup->list.count; timeDomIdx++)
8411                   {
8412                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].k2 = \
8413                         *(timeDomAllocList->choice.setup->list.array[timeDomIdx]->k2);
8414                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].mappingType = \
8415                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->mappingType;
8416                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbolAndLength = \
8417                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8418                   }
8419                }
8420             }
8421          }
8422          if(cuPuschCfg->choice.setup->transformPrecoder)
8423             macPuschCfg->transformPrecoder = *(cuPuschCfg->choice.setup->transformPrecoder);
8424       }
8425    }
8426 }
8427
8428 /*******************************************************************
8429  *
8430  * @brief Function to fill pucch Power Control
8431  *
8432  * @details
8433  *
8434  *    Function : extractPucchPowerControl
8435  *
8436  *    Functionality: Function to fill pucch Power Control
8437  *
8438  * @params[in] PucchPowerControl *pwrCtrl,
8439  *             struct PUCCH_PowerControl *cuPwrCtrlCfg
8440  * @return void
8441  *
8442  * ****************************************************************/
8443
8444 void extractPucchPowerControl(PucchPowerControl *pwrCtrl, struct PUCCH_PowerControl *cuPwrCtrlCfg)
8445 {
8446    uint8_t arrIdx;
8447
8448    if(cuPwrCtrlCfg->deltaF_PUCCH_f0)
8449       pwrCtrl->deltaF_Format0 = *cuPwrCtrlCfg->deltaF_PUCCH_f0;
8450    if(cuPwrCtrlCfg->deltaF_PUCCH_f1)
8451       pwrCtrl->deltaF_Format1 = *cuPwrCtrlCfg->deltaF_PUCCH_f1;
8452    if(cuPwrCtrlCfg->deltaF_PUCCH_f2)
8453       pwrCtrl->deltaF_Format2 = *cuPwrCtrlCfg->deltaF_PUCCH_f2;
8454    if(cuPwrCtrlCfg->deltaF_PUCCH_f3)
8455       pwrCtrl->deltaF_Format3 = *cuPwrCtrlCfg->deltaF_PUCCH_f3;
8456    if(cuPwrCtrlCfg->deltaF_PUCCH_f4)
8457       pwrCtrl->deltaF_Format4 = *cuPwrCtrlCfg->deltaF_PUCCH_f4;
8458    if(cuPwrCtrlCfg->p0_Set)
8459    {
8460       pwrCtrl->p0SetCount = cuPwrCtrlCfg->p0_Set->list.count;
8461       for(arrIdx=0; arrIdx < pwrCtrl->p0SetCount; arrIdx++)
8462       {
8463          pwrCtrl->p0Set[arrIdx].p0PucchId =\
8464             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Id;
8465          pwrCtrl->p0Set[arrIdx].p0PucchVal =\
8466             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Value;
8467       }
8468    }
8469    if(cuPwrCtrlCfg->pathlossReferenceRSs)
8470    {
8471       pwrCtrl->pathLossRefRSListCount = cuPwrCtrlCfg->pathlossReferenceRSs->list.count;
8472       for(arrIdx = 0; arrIdx < pwrCtrl->pathLossRefRSListCount; arrIdx++)
8473       {
8474          pwrCtrl->pathLossRefRSList[arrIdx].pathLossRefRSId =\
8475             cuPwrCtrlCfg->pathlossReferenceRSs->list.array[arrIdx]->pucch_PathlossReferenceRS_Id;
8476       }
8477    }
8478 }
8479
8480  /*******************************************************************
8481  *
8482  * @brief Function to extractResrcSetToAddModList sent by CU
8483  *
8484  * @details
8485  *
8486  *    Function : extractResrcSetToAddModList
8487  *
8488  *    Functionality: Fucntion to extractResrcSetToAddModList
8489  *
8490  * @params[in] PucchResrcSetCfg pointer,
8491  *             struct PUCCH_Config__resourceSetToAddModList pointer
8492  * @return void
8493  *
8494  * ****************************************************************/
8495
8496 void extractResrcSetToAddModList(PucchResrcSetCfg *macRsrcSetList, struct PUCCH_Config__resourceSetToAddModList *cuRsrcSetList)
8497 {
8498    uint8_t arrIdx, rsrcListIdx;
8499
8500    macRsrcSetList->resrcSetToAddModListCount = cuRsrcSetList->list.count;
8501    for(arrIdx = 0; arrIdx < macRsrcSetList->resrcSetToAddModListCount; arrIdx++)
8502    {
8503       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcSetId     =\
8504          cuRsrcSetList->list.array[arrIdx]->pucch_ResourceSetId;
8505       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount =\
8506          cuRsrcSetList->list.array[arrIdx]->resourceList.list.count;
8507       for(rsrcListIdx = 0; rsrcListIdx < macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount; rsrcListIdx++)
8508       {
8509          macRsrcSetList->resrcSetToAddModList[arrIdx].resrcList[rsrcListIdx] =\
8510             *cuRsrcSetList->list.array[arrIdx]->resourceList.list.array[rsrcListIdx];
8511       }
8512       macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize =\
8513          *cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1;
8514    }
8515 }/* End of extractResrcSetToAddModList */
8516
8517 /*******************************************************************
8518  *
8519  * @brief Fills extractResrcToAddModList sent by CU
8520  *
8521  * @details
8522  *
8523  *    Function : extractResrcToAddModList
8524  *
8525  *    Functionality: Fills extractResrcToAddModList
8526  *
8527  * @params[in] PucchResrcCfg pointer,
8528  *             struct PUCCH_Config__resourceToAddModList pointer
8529  * @return ROk/RFAILED
8530  *
8531  * ****************************************************************/
8532
8533 uint8_t extractResrcToAddModList(PucchResrcCfg *macResrcList, struct PUCCH_Config__resourceToAddModList *cuResrcList)
8534 {
8535    uint8_t arrIdx;
8536
8537    macResrcList->resrcToAddModListCount = cuResrcList->list.count;
8538    for(arrIdx = 0; arrIdx < macResrcList->resrcToAddModListCount; arrIdx++)
8539    {
8540       macResrcList->resrcToAddModList[arrIdx].resrcId      =\
8541         cuResrcList->list.array[arrIdx]->pucch_ResourceId;
8542       macResrcList->resrcToAddModList[arrIdx].startPrb     =\
8543         cuResrcList->list.array[arrIdx]->startingPRB;
8544       if(cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping)
8545       {
8546          macResrcList->resrcToAddModList[arrIdx].intraFreqHop =\
8547            *cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping;
8548       }
8549       if(cuResrcList->list.array[arrIdx]->secondHopPRB)
8550       {
8551          macResrcList->resrcToAddModList[arrIdx].secondPrbHop =\
8552            *cuResrcList->list.array[arrIdx]->secondHopPRB;
8553       }
8554       /* PUCCH RSRC FORMAT */
8555       if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format0)
8556       {
8557          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_0;
8558          if(cuResrcList->list.array[arrIdx]->format.choice.format0)
8559          {
8560             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0, sizeof(PucchFormat0));
8561             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0 == NULLP)
8562             {
8563                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
8564                return RFAILED;
8565             }
8566             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->initialCyclicShift =\
8567                cuResrcList->list.array[arrIdx]->format.choice.format0->initialCyclicShift;
8568             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->numSymbols =\
8569                cuResrcList->list.array[arrIdx]->format.choice.format0->nrofSymbols;
8570             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->startSymbolIdx =\
8571                cuResrcList->list.array[arrIdx]->format.choice.format0->startingSymbolIndex;
8572          }
8573       }
8574       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format1)
8575       {
8576          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_1;
8577          if(cuResrcList->list.array[arrIdx]->format.choice.format1)
8578          {
8579             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1, sizeof(PucchFormat1));
8580             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1 == NULLP)
8581             {
8582                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
8583                return RFAILED;
8584             }
8585             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->initialCyclicShift =\
8586                 cuResrcList->list.array[arrIdx]->format.choice.format1->initialCyclicShift;
8587             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->numSymbols =\
8588                 cuResrcList->list.array[arrIdx]->format.choice.format1->nrofSymbols;
8589             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->startSymbolIdx =\
8590                 cuResrcList->list.array[arrIdx]->format.choice.format1->startingSymbolIndex;
8591             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->timeDomOCC =\
8592                 cuResrcList->list.array[arrIdx]->format.choice.format1->timeDomainOCC;
8593          }
8594       }
8595       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format2)
8596       {
8597          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_2;
8598          if(cuResrcList->list.array[arrIdx]->format.choice.format2)
8599          {
8600             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
8601             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2 == NULLP)
8602             {
8603                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
8604                return RFAILED;
8605             }
8606             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numPrbs =\
8607                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofPRBs;
8608             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numSymbols =\
8609                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofSymbols;
8610             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->startSymbolIdx =\
8611                 cuResrcList->list.array[arrIdx]->format.choice.format2->startingSymbolIndex;
8612          }
8613       }
8614       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format3)
8615       {
8616          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_3;
8617          if(cuResrcList->list.array[arrIdx]->format.choice.format3)
8618          {
8619             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
8620             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3 == NULLP)
8621             {
8622                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
8623                return RFAILED;
8624             }
8625             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numPrbs =\
8626                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofPRBs;
8627             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numSymbols =\
8628                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofSymbols;
8629             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->startSymbolIdx =\
8630                 cuResrcList->list.array[arrIdx]->format.choice.format3->startingSymbolIndex;
8631          }
8632       }
8633       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format4)
8634       {
8635          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_4;
8636          if(cuResrcList->list.array[arrIdx]->format.choice.format4)
8637          {
8638             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4, sizeof(PucchFormat4));
8639             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4 == NULLP)
8640             {
8641                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
8642                return RFAILED;
8643             }
8644             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->numSymbols =\
8645                 cuResrcList->list.array[arrIdx]->format.choice.format4->nrofSymbols;
8646             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occLen =\
8647                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Length;
8648             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occIdx =\
8649                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Index;
8650             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->startSymbolIdx =\
8651                 cuResrcList->list.array[arrIdx]->format.choice.format4->startingSymbolIndex;
8652          }
8653       }
8654    }
8655    return ROK;
8656
8657 }/* End of extractResrcToAddModList */
8658
8659 /*******************************************************************
8660  *
8661  * @brief Fills fillPucchSchedReqPeriodAndOffset sent by CU
8662  *
8663  * @details
8664  *
8665  *    Function : fillPucchSchedReqPeriodAndOffset
8666  *
8667  *    Functionality: To fillPucchSchedReqPeriodAndOffset
8668  *
8669  * @params[in] macPeriodicty,
8670  *     SchedulingRequestResourceConfig__periodicityAndOffset pointer
8671  * @return void
8672  *
8673  * ****************************************************************/
8674
8675 void fillPucchSchedReqPeriodAndOffset(uint8_t macPeriodicty, uint16_t  macOffset,\
8676    struct SchedulingRequestResourceConfig__periodicityAndOffset *cuPeriodicty)
8677 {
8678    macPeriodicty = cuPeriodicty->present;
8679    switch(macPeriodicty)
8680    {
8681       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
8682          {
8683             macOffset     = cuPeriodicty->choice.sym2;
8684             break;
8685          }
8686       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
8687          {
8688             macOffset     = cuPeriodicty->choice.sym6or7;
8689             break;
8690          }
8691       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
8692          {
8693             macOffset     = cuPeriodicty->choice.sl1;
8694             break;
8695          }
8696       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
8697          {
8698             macOffset = cuPeriodicty->choice.sl2;
8699             break;
8700          }
8701       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
8702          {
8703             macOffset = cuPeriodicty->choice.sl4;
8704             break;
8705          }
8706       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
8707          {
8708             macOffset = cuPeriodicty->choice.sl5;
8709             break;
8710          }
8711       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
8712          {
8713             macOffset = cuPeriodicty->choice.sl8;
8714             break;
8715          }
8716       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
8717          {
8718             macOffset = cuPeriodicty->choice.sl10;
8719             break;
8720          }
8721       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
8722          {
8723             macOffset = cuPeriodicty->choice.sl16;
8724             break;
8725          }
8726       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
8727          {
8728             macOffset = cuPeriodicty->choice.sl20;
8729             break;
8730          }
8731       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
8732          {
8733             macOffset = cuPeriodicty->choice.sl40;
8734             break;
8735          }
8736       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
8737          {
8738             macOffset = cuPeriodicty->choice.sl80;
8739             break;
8740          }
8741       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
8742          {
8743             macOffset = cuPeriodicty->choice.sl160;
8744             break;
8745          }
8746       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
8747          {
8748             macOffset = cuPeriodicty->choice.sl320;
8749             break;
8750          }
8751       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
8752          {
8753             macOffset = cuPeriodicty->choice.sl640;
8754             break;
8755          }
8756       default :
8757          DU_LOG("\nERROR  -->  F1AP : Invalid periodicity %d", macPeriodicty);
8758    }
8759 }
8760
8761 /*******************************************************************
8762  *
8763  * @brief Function to extractPucchFormatCfg sent by CU
8764  *
8765  * @details
8766  *
8767  *    Function : extractPucchFormatCfg
8768  *
8769  *    Functionality: Function to extractPucchFormatCfg
8770  *
8771  * @params[in] PucchFormatCfg pointer,
8772  *             PUCCH_FormatConfig_t pointer
8773  * @return void
8774  *
8775  * ****************************************************************/
8776
8777 void extractPucchFormatCfg(PucchFormatCfg *macFormatCfg, PUCCH_FormatConfig_t *cuFormatCfg)
8778  {
8779     if(cuFormatCfg->interslotFrequencyHopping)
8780        macFormatCfg->interSlotFreqHop = *cuFormatCfg->interslotFrequencyHopping;
8781     if(cuFormatCfg->additionalDMRS)
8782        macFormatCfg->addDmrs = *cuFormatCfg->additionalDMRS;
8783     if(cuFormatCfg->maxCodeRate)
8784        macFormatCfg->maxCodeRate = *cuFormatCfg->maxCodeRate;
8785     if(cuFormatCfg->nrofSlots)
8786        macFormatCfg->numSlots = *cuFormatCfg->nrofSlots;
8787     if(cuFormatCfg->pi2BPSK)
8788        macFormatCfg->pi2BPSK = *cuFormatCfg->pi2BPSK;
8789     if(cuFormatCfg->simultaneousHARQ_ACK_CSI)
8790        macFormatCfg->harqAckCSI = *cuFormatCfg->simultaneousHARQ_ACK_CSI;
8791  }/* End of extractPucchFormatCfg */
8792
8793 /*******************************************************************
8794  *
8795  * @brief Function to extractSchedReqCfgToAddMod sent by CU
8796  *
8797  * @details
8798  *
8799  *    Function : extractSchedReqCfgToAddMod
8800  *
8801  *    Functionality: Function to extractSchedReqCfgToAddMod
8802  *
8803  * @params[in] PucchSchedReqCfg pointer,
8804  *      PUCCH_Config__schedulingRequestResourceToAddModList pointer
8805  * @return void
8806  *
8807  * ****************************************************************/
8808
8809 void extractSchedReqCfgToAddMod(PucchSchedReqCfg *macSchedReqCfg, struct PUCCH_Config__schedulingRequestResourceToAddModList *cuSchedReqList)
8810 {
8811    uint8_t arrIdx;
8812
8813    macSchedReqCfg->schedAddModListCount = cuSchedReqList->list.count;
8814    for(arrIdx = 0; arrIdx <  macSchedReqCfg->schedAddModListCount; arrIdx++)
8815    {
8816       macSchedReqCfg->schedAddModList[arrIdx].resrcId =\
8817          cuSchedReqList->list.array[arrIdx]->schedulingRequestResourceId;
8818       macSchedReqCfg->schedAddModList[arrIdx].requestId =\
8819          cuSchedReqList->list.array[arrIdx]->schedulingRequestID;
8820       if(cuSchedReqList->list.array[arrIdx]->periodicityAndOffset)
8821       {
8822          fillPucchSchedReqPeriodAndOffset(macSchedReqCfg->schedAddModList[arrIdx].periodicity,\
8823             macSchedReqCfg->schedAddModList[arrIdx].offset, cuSchedReqList->list.array[arrIdx]->periodicityAndOffset);
8824       }
8825       if(cuSchedReqList->list.array[arrIdx]->resource)
8826       {
8827          macSchedReqCfg->schedAddModList[arrIdx].resrc =\
8828             *cuSchedReqList->list.array[arrIdx]->resource;
8829       }
8830    }
8831
8832 }/* End of extractSchedReqCfgToAddMod */
8833
8834  /*******************************************************************
8835  *
8836  * @brief Fills PucchCfg received by CU
8837  *
8838  * @details
8839  *
8840  *    Function : extractPucchCfg
8841  *
8842  *    Functionality: Fills PucchCfg received  by CU
8843  *
8844  * @params[in] BWP_UplinkDedicated__pucch_Config *cuPucchCfg = Information which
8845  *                is send by CU, which we have stored in F1UeContextSetupDb,
8846  *             PucchCfg *macPucchCfg = Used to Store the information which
8847  *                needs to send in other layer, as well as this can be the variable
8848  *                which stores the information in DuCb,
8849  *             PucchCfg *storedPucchCfg = Null in case of sending the
8850  *                information to other layer else it will have Pucch Cfg which
8851  *                we have stored in copyOfmacUeCfg.
8852  * @return ROK/RFAILED
8853  *
8854  * ****************************************************************/
8855
8856 uint8_t extractPucchCfg(struct BWP_UplinkDedicated__pucch_Config *cuPucchCfg, PucchCfg *macPucchCfg,\
8857 PucchCfg *storedPucchCfg)
8858 {
8859    uint8_t arrIdx;
8860
8861    if(cuPucchCfg->present == BWP_UplinkDedicated__pucch_Config_PR_setup)
8862    {
8863       if(cuPucchCfg->choice.setup)
8864       {
8865          /* Resource Set Cfg */
8866          if(cuPucchCfg->choice.setup->resourceSetToAddModList)
8867          {
8868             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrcSet, sizeof(PucchResrcSetCfg));
8869             if(macPucchCfg->resrcSet == NULLP)
8870             {
8871                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
8872                return RFAILED;
8873             }
8874             memset(macPucchCfg->resrcSet, 0, sizeof(PucchResrcSetCfg));
8875             extractResrcSetToAddModList(macPucchCfg->resrcSet, cuPucchCfg->choice.setup->resourceSetToAddModList);
8876          }
8877
8878          /* Resource Cfg */
8879          if(cuPucchCfg->choice.setup->resourceToAddModList)
8880          {
8881             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrc, sizeof(PucchResrcCfg));
8882             if(macPucchCfg->resrc == NULLP)
8883             {
8884                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
8885                return RFAILED;
8886             }
8887             memset(macPucchCfg->resrc, 0, sizeof(PucchResrcCfg));
8888             extractResrcToAddModList(macPucchCfg->resrc, cuPucchCfg->choice.setup->resourceToAddModList);
8889          }
8890
8891          /* Format 1 Cfg */
8892          if(cuPucchCfg->choice.setup->format1)
8893          {
8894             DU_ALLOC_SHRABL_BUF(macPucchCfg->format1, sizeof(PucchFormatCfg));
8895             if(macPucchCfg->format1 == NULLP)
8896             {
8897                DU_LOG("\nERROR --> F1AP : Failed to extract format 1 Cfg in  extractPucchCfg()");
8898                return RFAILED;
8899             }
8900             memset(macPucchCfg->format1, 0, sizeof(PucchFormatCfg));
8901             extractPucchFormatCfg(macPucchCfg->format1,\
8902                cuPucchCfg->choice.setup->format1->choice.setup);
8903          }
8904
8905          /* Format 2 Cfg */
8906          if(cuPucchCfg->choice.setup->format2)
8907          {
8908             DU_ALLOC_SHRABL_BUF(macPucchCfg->format2, sizeof(PucchFormatCfg));
8909             if(macPucchCfg->format2 == NULLP)
8910             {
8911                DU_LOG("\nERROR --> F1AP : Failed to extract format 2 Cfg in  extractPucchCfg()");
8912                return RFAILED;
8913             }
8914             memset(macPucchCfg->format2, 0, sizeof(PucchFormatCfg));
8915             extractPucchFormatCfg(macPucchCfg->format2,\
8916                cuPucchCfg->choice.setup->format2->choice.setup);
8917          }
8918
8919          /* Format 3 Cfg */
8920          if(cuPucchCfg->choice.setup->format3)
8921          {
8922             DU_ALLOC_SHRABL_BUF(macPucchCfg->format3, sizeof(PucchFormatCfg));
8923             if(macPucchCfg->format3 == NULLP)
8924             {
8925                DU_LOG("\nERROR --> F1AP : Failed to extract format 3 Cfg in  extractPucchCfg()");
8926                return RFAILED;
8927             }
8928             memset(macPucchCfg->format3, 0, sizeof(PucchFormatCfg));
8929             extractPucchFormatCfg(macPucchCfg->format3,\
8930                cuPucchCfg->choice.setup->format3->choice.setup);
8931          }
8932
8933          /* Format 4 Cfg */
8934          if(cuPucchCfg->choice.setup->format4)
8935          {
8936             DU_ALLOC_SHRABL_BUF(macPucchCfg->format4, sizeof(PucchFormatCfg));
8937             if(macPucchCfg->format4 == NULLP)
8938             {
8939                DU_LOG("\nERROR --> F1AP : Failed to extract format 4 Cfg in  extractPucchCfg()");
8940                return RFAILED;
8941             }
8942             memset(macPucchCfg->format4, 0, sizeof(PucchFormatCfg));
8943             extractPucchFormatCfg(macPucchCfg->format4,\
8944                cuPucchCfg->choice.setup->format4->choice.setup);
8945          }
8946
8947          /* Sched Req List */
8948          if(cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList)
8949          {
8950             DU_ALLOC_SHRABL_BUF(macPucchCfg->schedReq, sizeof(PucchSchedReqCfg));
8951             if(macPucchCfg->schedReq == NULLP)
8952             {
8953                DU_LOG("\nERROR --> F1AP : Failed to extract schedReqCfg in  extractPucchCfg()");
8954                return RFAILED;
8955             }
8956             memset(macPucchCfg->schedReq, 0, sizeof(PucchSchedReqCfg));
8957             extractSchedReqCfgToAddMod(macPucchCfg->schedReq,\
8958             cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList);
8959          }
8960
8961          /*TODO: Add support for  Spatial Info */
8962
8963          /* MultiCsiCfg */
8964          if(cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList)
8965          {
8966             DU_ALLOC_SHRABL_BUF(macPucchCfg->multiCsiCfg, sizeof(PucchMultiCsiCfg));
8967             if(macPucchCfg->multiCsiCfg == NULLP)
8968             {
8969                DU_LOG("\nERROR --> F1AP : Failed to extract multiCsiCfg in  extractPucchCfg()");
8970                return RFAILED;
8971             }
8972             memset(macPucchCfg->multiCsiCfg, 0, sizeof(PucchMultiCsiCfg));
8973             macPucchCfg->multiCsiCfg->multiCsiResrcListCount = cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.count;
8974             for(arrIdx =0; arrIdx < macPucchCfg->multiCsiCfg->multiCsiResrcListCount; arrIdx++)
8975             {
8976                macPucchCfg->multiCsiCfg->multiCsiResrcList[arrIdx] =\
8977                  *cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.array[arrIdx];
8978             }
8979          }
8980
8981          /* Dl_DataToUL_ACK */
8982          if(cuPucchCfg->choice.setup->dl_DataToUL_ACK)
8983     {
8984        if(storedPucchCfg)
8985        {
8986           if(storedPucchCfg->dlDataToUlAck)
8987           {
8988              macPucchCfg->dlDataToUlAck = storedPucchCfg->dlDataToUlAck;
8989           }
8990           else
8991           {
8992             DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
8993           }
8994        }
8995        else
8996        {
8997           DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
8998        }
8999        if(macPucchCfg->dlDataToUlAck == NULLP)
9000        {
9001           DU_LOG("\nERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
9002           return RFAILED;
9003        }
9004        memset(macPucchCfg->dlDataToUlAck, 0, sizeof(PucchDlDataToUlAck));
9005        macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount = cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.count;
9006        for(arrIdx = 0; arrIdx < macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount; arrIdx++)
9007        {
9008           macPucchCfg->dlDataToUlAck->dlDataToUlAckList[arrIdx] =\
9009           *cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.array[arrIdx];
9010        }
9011          }
9012
9013          /* Power Control */
9014          if(cuPucchCfg->choice.setup->pucch_PowerControl)
9015          {
9016             DU_ALLOC_SHRABL_BUF(macPucchCfg->powerControl, sizeof(PucchPowerControl));
9017             if(macPucchCfg->powerControl == NULLP)
9018             {
9019                DU_LOG("\nERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
9020                return RFAILED;
9021             }
9022             extractPucchPowerControl(macPucchCfg->powerControl,\
9023                cuPucchCfg->choice.setup->pucch_PowerControl);
9024          }
9025       }
9026    }
9027    return ROK;
9028 }
9029
9030 /*******************************************************************
9031  *
9032  * @brief Fills ServingCellReconfig received by CU
9033  *
9034  * @details
9035  *
9036  *    Function : extractSpCellDedicatedCfg
9037  *
9038  *    Functionality: Fills ServingCellReconfig received  by CU
9039  *
9040  * @params[in] ServingCellConfig_t *cuSrvCellCfg = Information which is send by
9041  *                  CU, which we have stored in F1UeContextSetupDb,
9042  *             ServCellCfgInfo *macSrvCellCfg = Used to Store the information
9043  *                  which  needs to send in other layer, as well as this can be the
9044  *                  variable which stores the information in DuCb,
9045  *             ServCellCfgInfo *storedSrvCellCfg = Null in case of sending the
9046  *                  information to other layer else it will have ServCellCfgInfo which
9047  *                  we have stored in copyOfmacUeCfg.
9048  * @return ROK/RFAILD
9049  *
9050  * ****************************************************************/
9051 uint8_t extractSpCellDedicatedCfg(ServingCellConfig_t *cuSrvCellCfg, ServCellCfgInfo *macSrvCellCfg,\
9052 ServCellCfgInfo *storedSrvCellCfg)
9053 {
9054    uint8_t ret = ROK;
9055    BWP_DownlinkDedicated_t *dlBwp = NULLP;
9056    BWP_UplinkDedicated_t   *ulBwp = NULLP;
9057
9058    if(cuSrvCellCfg->initialDownlinkBWP)
9059    {
9060       dlBwp = ((BWP_DownlinkDedicated_t *)(cuSrvCellCfg->initialDownlinkBWP));
9061       if(dlBwp->pdcch_Config)
9062       {
9063          if(dlBwp->pdcch_Config->choice.setup)
9064          {
9065             macSrvCellCfg->initDlBwp.pdcchPresent = true;
9066             extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
9067          }
9068       }
9069       if(dlBwp->pdsch_Config)
9070       {
9071          if(dlBwp->pdsch_Config->choice.setup)
9072          {
9073             macSrvCellCfg->initDlBwp.pdschPresent = true;
9074
9075             if(storedSrvCellCfg)
9076             {
9077                if(!storedSrvCellCfg->initDlBwp.pdschPresent)
9078                {
9079                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
9080                }
9081                else
9082                {
9083                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg,\
9084                         &storedSrvCellCfg->initDlBwp.pdschCfg);
9085                }
9086             }
9087             else
9088             {
9089                extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
9090             }
9091          }
9092       }
9093    }
9094    if(cuSrvCellCfg->firstActiveDownlinkBWP_Id)
9095       macSrvCellCfg->firstActvDlBwpId = *(cuSrvCellCfg->firstActiveDownlinkBWP_Id);
9096    if(cuSrvCellCfg->defaultDownlinkBWP_Id)
9097       macSrvCellCfg->defaultDlBwpId = *(cuSrvCellCfg->defaultDownlinkBWP_Id);
9098    if(cuSrvCellCfg->bwp_InactivityTimer)
9099    {
9100       if(macSrvCellCfg->bwpInactivityTmr)
9101       {
9102          memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
9103       }
9104       else
9105       {
9106          macSrvCellCfg->bwpInactivityTmr = NULLP;
9107          DU_ALLOC_SHRABL_BUF(macSrvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
9108          if(macSrvCellCfg->bwpInactivityTmr)
9109          {
9110             memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
9111          }
9112          else
9113          {
9114             DU_LOG("\nERROR  --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
9115             return RFAILED;
9116          }
9117       }
9118    }
9119    if(cuSrvCellCfg->pdsch_ServingCellConfig)
9120    {
9121       if(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup)
9122       {
9123          ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
9124          if(ret == RFAILED)
9125          {
9126             DU_LOG("\nERROR --> F1AP : Failed at extractPdschServingCellCfg()");
9127             return RFAILED;
9128          }
9129       }
9130    }
9131    if(cuSrvCellCfg->uplinkConfig)
9132    {
9133       if(cuSrvCellCfg->uplinkConfig->initialUplinkBWP)
9134       {
9135          ulBwp = ((BWP_UplinkDedicated_t *)(cuSrvCellCfg->uplinkConfig->initialUplinkBWP));
9136          if(ulBwp->pusch_Config)
9137          {
9138             macSrvCellCfg->initUlBwp.puschPresent = true;
9139             extractPuschCfg(ulBwp->pusch_Config, &macSrvCellCfg->initUlBwp.puschCfg);
9140          }
9141          if(ulBwp->pucch_Config)
9142          {
9143             macSrvCellCfg->initUlBwp.pucchPresent = true;
9144             memset(&macSrvCellCfg->initUlBwp.pucchCfg, 0, sizeof(PucchCfg));
9145             if(storedSrvCellCfg)
9146             {
9147                if(!storedSrvCellCfg->initUlBwp.pucchPresent)
9148                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
9149                else
9150                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg,\
9151                   &storedSrvCellCfg->initUlBwp.pucchCfg);
9152             }
9153             else
9154             {
9155                extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
9156             }
9157          }
9158       }
9159       if(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id)
9160          macSrvCellCfg->firstActvUlBwpId = *(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id);
9161    }
9162    return ret;
9163 }
9164 /*******************************************************************
9165  *
9166  * @brief Fills Reconfig Cell group Info received by CU
9167  *
9168  * @details
9169  *
9170  *    Function : extractUeReCfgCellInfo
9171  *
9172  *    Functionality: Fills Reconfig Cell group Info received by CU
9173  *
9174  * @params[in] CellGroupConfigRrc_t *cellGrp = CellGroupConfigRrc_t information which
9175  *                       is send by CU, which we have stored in F1UeContextSetupDb
9176  *             MacUeCfg *MacUeCfg = Used to Store the information,
9177  *                      which needs to send in other layer, as well as this can be
9178  *                      the variable which stores the information in DuCb,
9179  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
9180  *                      information to other layer else it will have copyOfmacUeCfg
9181  *                      which we have stored in F1UeContextSetupDb.
9182  *
9183  * @return ROK/RFAILED
9184  *
9185  * ****************************************************************/
9186 uint8_t extractUeReCfgCellInfo(CellGroupConfigRrc_t *cellGrp, MacUeCfg *macUeCfg, MacUeCfg *storedMacUeCfg)
9187 {
9188    uint8_t ret = ROK;
9189    MAC_CellGroupConfig_t     *macCellGroup = NULLP;
9190    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
9191    SpCellConfig_t            *spcellCfg = NULLP;
9192    ServingCellConfig_t       *servCellCfg = NULLP;
9193
9194    if(cellGrp)
9195    {
9196       /* Fill MacCell Group Reconfig  */
9197       if(cellGrp->mac_CellGroupConfig)
9198       {
9199          macUeCfg->macCellGrpCfgPres = true;
9200          macCellGroup = ((MAC_CellGroupConfig_t *)(cellGrp->mac_CellGroupConfig));
9201          if(macCellGroup->schedulingRequestConfig)
9202          {
9203             extractSchReqReConfig(macCellGroup->schedulingRequestConfig, &macUeCfg->macCellGrpCfg.schReqCfg);
9204          }
9205          if(macCellGroup->tag_Config)
9206          {
9207             extractTagReconfig(macCellGroup->tag_Config, &macUeCfg->macCellGrpCfg.tagCfg);
9208          }
9209          if(macCellGroup->bsr_Config)
9210          {
9211             macUeCfg->macCellGrpCfg.bsrTmrCfg.periodicTimer = macCellGroup->bsr_Config->periodicBSR_Timer;
9212             macUeCfg->macCellGrpCfg.bsrTmrCfg.retxTimer     = macCellGroup->bsr_Config->retxBSR_Timer;
9213             if(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer)
9214             {
9215                macUeCfg->macCellGrpCfg.bsrTmrCfg.srDelayTimer  =\
9216                *(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer);
9217             }
9218          }
9219          if(macCellGroup->phr_Config)
9220          {
9221             if(macCellGroup->phr_Config->present == MAC_CellGroupConfig__phr_Config_PR_setup)
9222             {
9223                macUeCfg->macCellGrpCfg.phrCfgSetupPres = true;
9224                if(macCellGroup->phr_Config->choice.setup)
9225                {
9226                   macUeCfg->macCellGrpCfg.phrCfg.periodicTimer     = \
9227                   macCellGroup->phr_Config->choice.setup->phr_PeriodicTimer;
9228                   macUeCfg->macCellGrpCfg.phrCfg.prohibitTimer     = \
9229                   macCellGroup->phr_Config->choice.setup->phr_ProhibitTimer;
9230                   macUeCfg->macCellGrpCfg.phrCfg.txPowerFactor     = \
9231                   macCellGroup->phr_Config->choice.setup->phr_Tx_PowerFactorChange;
9232                   macUeCfg->macCellGrpCfg.phrCfg.multiplePHR       = \
9233                   macCellGroup->phr_Config->choice.setup->multiplePHR;
9234                   macUeCfg->macCellGrpCfg.phrCfg.dummy             = \
9235                   macCellGroup->phr_Config->choice.setup->dummy;
9236                   macUeCfg->macCellGrpCfg.phrCfg.phrType2OtherCell = \
9237                   macCellGroup->phr_Config->choice.setup->phr_Type2OtherCell;
9238                   macUeCfg->macCellGrpCfg.phrCfg.phrOtherCG        = \
9239                   macCellGroup->phr_Config->choice.setup->phr_ModeOtherCG;
9240                }
9241             }
9242          }
9243       }
9244       /* Fill Physical Cell Group Reconfig */
9245       if(cellGrp->physicalCellGroupConfig)
9246       {
9247          macUeCfg->phyCellGrpCfgPres = true;
9248          phyCellGrpCfg = ((PhysicalCellGroupConfig_t *)(cellGrp->physicalCellGroupConfig));
9249          if(phyCellGrpCfg->p_NR_FR1)
9250          {
9251             if(*(phyCellGrpCfg->p_NR_FR1) != macUeCfg->phyCellGrpCfg.pNrFr1)
9252                macUeCfg->phyCellGrpCfg.pNrFr1 = *(phyCellGrpCfg->p_NR_FR1);
9253          }
9254          macUeCfg->phyCellGrpCfg.pdschHarqAckCodebook = phyCellGrpCfg->pdsch_HARQ_ACK_Codebook;
9255       }
9256       /* Fill SpCell Reconfig */
9257       if(cellGrp->spCellConfig)
9258       {
9259          macUeCfg->spCellCfgPres = true;
9260          spcellCfg = ((SpCellConfig_t *)(cellGrp->spCellConfig));
9261          if(spcellCfg->servCellIndex)
9262          {
9263             macUeCfg->spCellCfg.servCellIdx = *(spcellCfg->servCellIndex);
9264          }
9265          /* Fill Serving cell Reconfig info */
9266          if(cellGrp->spCellConfig->spCellConfigDedicated)
9267          {
9268             servCellCfg = ((ServingCellConfig_t *)(cellGrp->spCellConfig->spCellConfigDedicated));
9269             if(storedMacUeCfg)
9270             {
9271                if(!storedMacUeCfg->spCellCfgPres)
9272                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
9273                else
9274                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg,\
9275                         &storedMacUeCfg->spCellCfg.servCellCfg);
9276             }
9277             else
9278             {
9279                ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
9280             }
9281             if(ret == RFAILED)
9282             {
9283                DU_LOG("\nERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
9284             }
9285          }
9286       }
9287    }
9288    return ret;
9289 }
9290 /*******************************************************************
9291 *
9292 * @brief free the memory allocated by decoder
9293 *
9294 * @details
9295 *
9296 *    Function : freeAperDecodeNrcgi
9297 *
9298 *    Functionality: Free Nrcgi values
9299 *
9300 * @params[in] NRCGI_t *nrcgi
9301 * @return void
9302 *
9303 * ****************************************************************/
9304
9305
9306 void freeAperDecodeNrcgi(NRCGI_t *nrcgi)
9307 {
9308     if(nrcgi->pLMN_Identity.buf != NULLP)
9309     {
9310        free(nrcgi->pLMN_Identity.buf);
9311     }
9312     if(nrcgi->nRCellIdentity.buf != NULLP)
9313     {
9314        free(nrcgi->nRCellIdentity.buf);
9315     }
9316 }
9317 /*******************************************************************
9318 *
9319 * @brief free the memory allocated by decoder
9320 *
9321 * @details
9322 *
9323 *    Function : freeAperDecodeCuToDuInfo
9324 *
9325 *    Functionality:  Free Cu To Du Information
9326 *
9327 * @params[in] CUtoDURRCInformation_t *rrcMsg
9328 * @return void
9329 *
9330 * ****************************************************************/
9331
9332
9333 void freeAperDecodeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
9334 {
9335    uint8_t ieIdx =0;
9336    uint8_t arrIdx =0;
9337
9338    if(rrcMsg->uE_CapabilityRAT_ContainerList)
9339    {
9340       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
9341          free(rrcMsg->uE_CapabilityRAT_ContainerList->buf);
9342       free(rrcMsg->uE_CapabilityRAT_ContainerList);
9343    }
9344
9345    if(rrcMsg->iE_Extensions)
9346    {
9347       if(rrcMsg->iE_Extensions->list.array)
9348       {
9349          for(ieIdx= 0; ieIdx < rrcMsg->iE_Extensions->list.count; ieIdx++)
9350          {
9351             if(rrcMsg->iE_Extensions->list.array[ieIdx])
9352             {
9353                switch(rrcMsg->iE_Extensions->list.array[ieIdx]->id)
9354                {
9355                   case ProtocolIE_ID_id_CellGroupConfig:
9356                      if(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
9357                      {
9358                         free(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf);
9359                      }
9360                      break;
9361                   default:
9362                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
9363                            rrcMsg->iE_Extensions->list.array[ieIdx]->id);
9364                      break;
9365                }
9366             }
9367          }
9368          for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
9369          {
9370             free(rrcMsg->iE_Extensions->list.array[arrIdx]);
9371          }
9372          free(rrcMsg->iE_Extensions->list.array);
9373
9374       }
9375
9376       free(rrcMsg->iE_Extensions);
9377    }
9378 }
9379 /*******************************************************************
9380 *
9381 * @brief free the memory allocated by decoder
9382 *
9383 * @details
9384 *
9385 *    Function : freeAperDecodeSplCellList
9386 *
9387 *    Functionality: Free Spl Cell List
9388                     where memory allocated by aper_decoder
9389 *
9390 * @params[in]  SCell_ToBeSetup_List_t *spCellLst
9391 * @return void
9392 *
9393 * ****************************************************************/
9394
9395
9396 void freeAperDecodeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
9397 {
9398     uint8_t  cellIdx =0;
9399
9400     if(spCellLst->list.array != NULLP)
9401     {
9402        for(cellIdx=0; cellIdx<spCellLst->list.count; cellIdx++)
9403        {
9404           if(cellIdx==0&&spCellLst->list.array[cellIdx]!=NULLP)
9405           {
9406              freeAperDecodeNrcgi(&spCellLst->list.array[cellIdx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
9407           }
9408           if(spCellLst->list.array[cellIdx]!=NULLP)
9409           {
9410              free(spCellLst->list.array[cellIdx]);
9411           }
9412        }
9413        free(spCellLst->list.array);
9414     }
9415 }
9416 /*******************************************************************
9417 *
9418 * @brief free the memory allocated by decoder
9419 *
9420 * @details
9421 *
9422 *    Function : freeAperDecodeSRBSetup
9423 *
9424 *    Functionality: added free part for the memory allocated by aper_decoder
9425 *
9426 * @params[in] SRBs_ToBeSetup_List_t *srbSet
9427 * @return void
9428 *
9429 ****************************************************************/
9430
9431
9432 void freeAperDecodeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
9433 {
9434     uint8_t srbIdx =0;
9435     if(srbSet->list.array != NULLP)
9436     {
9437        for(srbIdx=0; srbIdx<srbSet->list.count; srbIdx++)
9438        {
9439           if(srbSet->list.array[srbIdx]!=NULLP)
9440           {
9441              free(srbSet->list.array[srbIdx]);
9442           }
9443        }
9444        free(srbSet->list.array);
9445     }
9446 }
9447
9448 /*******************************************************************
9449 *
9450 * @brief free the memory allocated by decoder
9451 *
9452 * @details
9453 *
9454 *    Function : freeAperDecodeULTnlInfo
9455 *
9456 *    Functionality: added free part for the memory allocated by aper_decoder
9457 *
9458 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
9459 * @return void
9460 *
9461 * ****************************************************************/
9462
9463
9464 void freeAperDecodeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
9465 {
9466    uint8_t ulIdx=0;
9467    if(ulInfo->list.array != NULLP)
9468    {
9469       for(ulIdx=0; ulIdx<ulInfo->list.count; ulIdx++)
9470       {
9471          if(ulIdx==0&&ulInfo->list.array[ulIdx]!=NULLP)
9472          {
9473             if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
9474             {
9475                if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9476                      transportLayerAddress.buf != NULLP)
9477                {
9478                   if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
9479                         !=NULLP)
9480                   {
9481                      free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf);
9482                   }
9483                   free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9484                         transportLayerAddress.buf);
9485                }
9486                free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel);
9487             }
9488          }
9489          if(ulInfo->list.array[ulIdx]!=NULLP)
9490          {
9491             free(ulInfo->list.array[ulIdx]);
9492          }
9493       }
9494       free(ulInfo->list.array);
9495    }
9496 }
9497 /*******************************************************************
9498 *
9499 * @brief free the memory allocated by decoder
9500 *
9501 * @details
9502 *
9503 *    Function : freeAperDecodeDRBSetup
9504 *
9505 *    Functionality: free DRBSetup which is allocated by decoder
9506 *
9507 * @params[in]  DRBs_ToBeSetup_List_t *drbSet
9508 * @return void
9509 *
9510 * ****************************************************************/
9511
9512 void freeAperDecodeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
9513 {
9514    DRBs_ToBeSetup_Item_t *drbSetItem = NULLP;
9515    uint8_t  flowIdx =0;
9516    uint8_t  drbIdx =0;
9517
9518    if(drbSet->list.array != NULLP)
9519    {
9520       for(drbIdx=0; drbIdx<drbSet->list.count; drbIdx++)
9521       {
9522          if(drbIdx==0&&drbSet->list.array[drbIdx] != NULLP)
9523          {
9524             drbSetItem =&drbSet->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
9525             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
9526             {
9527                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9528                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
9529                {
9530                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9531                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9532                   {
9533                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9534                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9535                      {
9536
9537                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
9538                         {
9539
9540                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
9541                            {
9542
9543                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->\
9544                                     buf!=NULLP)
9545                               {
9546
9547                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
9548                                        flows_Mapped_To_DRB_List.list.array != NULLP)
9549                                  {
9550
9551                                     for(flowIdx=0;flowIdx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9552                                           DRB_Information.flows_Mapped_To_DRB_List.list.count; flowIdx++)
9553                                     {
9554
9555                                        if(flowIdx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9556                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9557                                        {
9558                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9559                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9560                                                 qoSFlowLevelQoSParameters.\
9561                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
9562                                           {
9563                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9564                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9565                                                    qoSFlowLevelQoSParameters.\
9566                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9567                                              {
9568
9569                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9570                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9571                                                       qoSFlowLevelQoSParameters.\
9572                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9573                                                 {
9574
9575
9576                                                    free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9577                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9578                                                          qoSFlowLevelQoSParameters.\
9579                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9580                                                 }
9581
9582                                                 free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9583                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9584                                                       qoSFlowLevelQoSParameters.\
9585                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9586                                              }
9587
9588                                              free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9589
9590                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9591                                                    qoSFlowLevelQoSParameters.\
9592                                                    qoS_Characteristics.choice.non_Dynamic_5QI);
9593                                           }
9594                                        }
9595                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9596                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9597                                        {
9598
9599                                           free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9600                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]);
9601                                        }
9602                                     }
9603
9604                                     free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9605                                           DRB_Information.flows_Mapped_To_DRB_List.list.array);
9606                                  }
9607
9608                                  free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9609                                        DRB_Information.sNSSAI.sD->buf);
9610                               }
9611
9612                               free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD);
9613                            }
9614
9615                            free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf);
9616
9617                         }
9618
9619                         free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9620
9621                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9622                      }
9623
9624                      free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9625                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9626                   }
9627
9628                   free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9629                         qoS_Characteristics.choice.non_Dynamic_5QI);
9630                }
9631                free(drbSetItem->qoSInformation.choice.choice_extension);
9632             }
9633             freeAperDecodeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
9634             if(drbSetItem->uLConfiguration)
9635             {
9636                free(drbSetItem->uLConfiguration);
9637             }
9638          }
9639          if(drbSet->list.array[drbIdx]!=NULLP)
9640          {
9641             free(drbSet->list.array[drbIdx]);
9642          }
9643       }
9644       free(drbSet->list.array);
9645    }
9646 }
9647
9648
9649 /*******************************************************************
9650  *
9651  * @brief builds Mac Cell Cfg
9652  *
9653  * @details
9654  *
9655  *    Function : procUeReCfgCellInfo
9656  *
9657  *    Functionality: builds Mac Cell Cfg
9658  *
9659  * @params[in] MacUeCfg *macUeCfgToSend = Used to Store the information which
9660  *                       needs to send in other layer, as well as this can be
9661  *                       the variable which stores the information in DuCb.
9662  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
9663  *                       information to other layer else it will have copyOfmacUeCfg
9664  *                       which we have stored in F1UeContextSetupDb
9665  *             void *cellInfo = CellGroupConfigRrc_t information which is send
9666  *                        by CU, which we have stored in F1UeContextSetupDb
9667  *
9668  * @return void
9669  *
9670  * ****************************************************************/
9671 uint8_t procUeReCfgCellInfo(MacUeCfg *macUeCfgToSend,MacUeCfg *storedMacUeCfg, void *cellInfo)
9672 {
9673    uint8_t ret = ROK;
9674    CellGroupConfigRrc_t *cellGrp = NULLP;
9675
9676    if(cellInfo)
9677    {
9678       cellGrp = (CellGroupConfigRrc_t *)cellInfo;
9679       ret = extractUeReCfgCellInfo(cellGrp, macUeCfgToSend, storedMacUeCfg);
9680       if(ret == RFAILED)
9681          DU_LOG("\nERROR  -->  F1AP : Failed at procUeReCfgCellInfo()");
9682    }
9683    if(ret == RFAILED)
9684    {
9685       freeUeReCfgCellGrpInfo(macUeCfgToSend);
9686    }
9687    return ret;
9688 }
9689
9690 /*******************************************************************
9691  *
9692  * @brief Filling modulation info in mac ue cfg
9693  *
9694  * @details
9695  *
9696  *    Function : duFillModulationDetails
9697  *
9698  *    Functionality: Filling modulation info in mac ue cfg
9699  *
9700  * @params[in] MAC UE Config to be updated
9701  *             Current UE configuration
9702  *             UE NR capability from CU
9703  * @return ROK     - success
9704  *         RFAILED - failure
9705  *
9706  * ****************************************************************/
9707 void duFillModulationDetails(MacUeCfg *ueCfg, MacUeCfg *oldUeCfg, void *ueCap)
9708 {
9709    UE_NR_Capability_t *ueNrCap=NULLP;
9710
9711    if(!ueCap)
9712    {
9713       memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9714       memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9715    }
9716    else
9717    {
9718       ueNrCap = (UE_NR_Capability_t *)ueCap;
9719
9720       /* Filling DL modulation info */
9721       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsDownlinkPerCC && \
9722          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0] && \
9723          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL)
9724       {
9725          switch(*(ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL))
9726          {
9727             case ModulationOrder_qpsk:
9728                {
9729                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
9730                   break;
9731                }
9732             case ModulationOrder_qam16:
9733                {
9734                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM16;
9735                   break;
9736                }
9737             case ModulationOrder_qam64:
9738                {
9739                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM64;
9740                   ueCfg->dlModInfo.mcsIndex = PDSCH_MCS_INDEX;
9741                   ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64;
9742                   break;
9743                }
9744             case ModulationOrder_qam256:
9745                {
9746                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM256;
9747                   break;
9748                }
9749             default:
9750                {
9751                   DU_LOG("\nERROR  -->  DU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
9752                   memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9753                   break;
9754                }
9755          }
9756       }
9757       else
9758       {
9759          memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9760       }
9761
9762       /* Filling UL modulation info */
9763       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsUplinkPerCC && \
9764          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0] && \
9765          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL)
9766       {
9767          switch(*(ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL))
9768          {
9769             case ModulationOrder_qpsk:
9770                {
9771                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
9772                   break;
9773                }
9774             case ModulationOrder_qam16:
9775                {
9776                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM16;
9777                   ueCfg->ulModInfo.mcsIndex = PUSCH_MCS_INDEX;
9778                   ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64;
9779                   break;
9780                }
9781             case ModulationOrder_qam64:
9782                {
9783                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM64;
9784                   break;
9785                }
9786             case ModulationOrder_qam256:
9787                {
9788                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM256;
9789                   break;
9790                }
9791             default:
9792                {
9793                   DU_LOG("\nERROR  -->  DU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
9794                   memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9795                   break;
9796                }
9797          }
9798       }
9799       else
9800       {
9801          memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9802       }
9803    }
9804 }
9805
9806 /*******************************************************************
9807  *
9808  * @brief Function to extract cellGrp Info present in cutoDu cont
9809  *
9810  * @details
9811  *
9812  *    Function : extractCellGrpInfo
9813  *
9814  *    Functionality: Function to extract cellGrp Info present
9815  *                   in cutoDu cont
9816  *
9817  * @params[in] ProtocolExtensionContainer_4624P16_t pointer
9818  *
9819  * @return CellGroupConfigRrc_t *
9820  *
9821  * ****************************************************************/
9822
9823 CellGroupConfigRrc_t *extractCellGrpInfo(ProtocolExtensionContainer_4624P16_t *protocolIeExtn,\
9824       DuUeCfg *ueCfgDb)
9825 {
9826    uint8_t idx2 =0;
9827    uint16_t id =0;
9828    uint16_t recvBufLen =0;
9829    CellGroupConfigRrc_t *cellGrpCfg = NULLP;
9830    CUtoDURRCInformation_ExtIEs_t *extIeInfo = NULLP;
9831    asn_dec_rval_t rval; /* Decoder return value */
9832    memset(&rval, 0, sizeof(asn_dec_rval_t));
9833
9834    if(protocolIeExtn)
9835    {
9836       for(idx2 = 0; idx2 < protocolIeExtn->list.count; idx2++)
9837       {
9838          extIeInfo = ((CUtoDURRCInformation_ExtIEs_t *)(protocolIeExtn->list.array[idx2]));
9839          id = extIeInfo->id;
9840          switch(id)
9841          {
9842             case ProtocolIE_ID_id_CellGroupConfig:
9843             {
9844                recvBufLen = extIeInfo->extensionValue.choice.CellGroupConfig.size;
9845                /* decoding the CellGroup Buf received */
9846                DU_ALLOC(cellGrpCfg, sizeof(CellGroupConfigRrc_t));
9847                if(cellGrpCfg)
9848                {
9849                   memset(cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
9850                   rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfg,
9851                      extIeInfo->extensionValue.choice.CellGroupConfig.buf, recvBufLen, 0, 0);
9852                   if(rval.code == RC_FAIL || rval.code == RC_WMORE)
9853                   {
9854                      DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
9855                      return NULLP;
9856                   }
9857                   xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfg);
9858                   if(extractRlcCfgToAddMod(cellGrpCfg->rlc_BearerToAddModList, ueCfgDb))
9859                      return NULLP;
9860                }
9861                break;
9862             }
9863             default:
9864                DU_LOG("\nERROR  -->  F1AP : Invalid IE received CUtoDURRCInformation:%d at decodeCellGrpCfg()", id);
9865                break;
9866          }
9867       }
9868    }
9869    return cellGrpCfg;
9870 }
9871
9872 /*******************************************************************
9873  *
9874  * @brief Fills Srb List received by CU
9875  *
9876  * @details
9877  *
9878  *    Function : procSrbListToSetup
9879  *
9880  *    Functionality: Fills Srb List received  by CU
9881  *
9882  * @params[in] SRBs_ToBeSetup_Item_t *cuSrbItem
9883  *             LcCfg pointer
9884  *             RlcBearerCfg pointer
9885  * @return void
9886  *
9887  * ****************************************************************/
9888 uint8_t procSrbListToSetup(SRBs_ToBeSetup_Item_t * srbItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd)
9889 {
9890    uint8_t ret = ROK;
9891
9892    /* Filling RLC INFO */
9893    procRlcLcCfg(srbItem->sRBID, srbItem->sRBID, RB_TYPE_SRB, RLC_AM, CONFIG_ADD, NULL, rlcLcToAdd);
9894
9895    /* Filling MAC INFO */
9896    ret = procMacLcCfg(srbItem->sRBID, RB_TYPE_SRB, CONFIG_ADD, NULL,NULL, NULL, macLcToAdd, NULL);
9897    if(ret == RFAILED)
9898    {
9899       DU_LOG("\nERROR  -->  F1AP : Failed at MAC LC Cfg in procSrbListToSetup()");
9900       return ret;
9901    }
9902    return ret;
9903 }
9904
9905
9906
9907 /*******************************************************************
9908  *
9909  * @brief extract Srb List received by CU
9910  *
9911  * @details
9912  *
9913  *    Function : extractSrbListToSetup
9914  *
9915  *    Functionality: extract Srb List received by CU
9916  *                   for both MAC and RLC
9917  *
9918  * @params[in] SRBs_ToBeSetup_Item_t pointer
9919  *             DuUeCfg pointer
9920  * @return ROK/RFAIED
9921  *
9922  * ****************************************************************/
9923
9924 uint8_t extractSrbListToSetup(SRBs_ToBeSetup_List_t *srbCfg, DuUeCfg *ueCfgDb)
9925 {
9926    uint8_t ret, srbIdx;
9927    SRBs_ToBeSetup_Item_t *srbItem = NULLP;
9928
9929    if(srbCfg)
9930    {
9931       for(srbIdx = 0; srbIdx < srbCfg->list.count; srbIdx++)
9932       {
9933          srbItem = &srbCfg->list.array[srbIdx]->value.choice.SRBs_ToBeSetup_Item;
9934          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
9935          {
9936             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in MAC");
9937             ret = RFAILED;
9938             break;
9939          }
9940          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
9941          {
9942             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in RLC");
9943             ret = RFAILED;
9944             break;
9945          }
9946          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
9947          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
9948          ret = procSrbListToSetup(srbItem, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
9949             &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs]);
9950          ueCfgDb->numRlcLcs++;
9951          ueCfgDb->numMacLcs++;
9952          DU_LOG("\nDEBUG --> DUAPP: extractSrbListToSetup: SRBID: %d [RLC,MAC,NumDrb]:[%x,%x,%x]",\
9953                             srbItem->sRBID, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
9954          if(ret == RFAILED)
9955          {
9956             DU_LOG("\nERROR  -->  F1AP:  Failed at extractSrbListToSetup()");
9957             break;
9958          }
9959       }
9960    }
9961    else
9962       ret = RFAILED;
9963
9964    return ret;
9965 }
9966
9967 /*******************************************************************
9968  *
9969  * @brief Fills Drb List received by CU
9970  *
9971  * @details
9972  *
9973  *    Function : procDrbListToSetup
9974  *
9975  *    Functionality: Fills Drb List received by CU
9976  *                   for both MAC and RLC
9977  *
9978  * @params[in] SRBs_ToBeSetup_Item_t pointer
9979  *             LcCfg pointer,
9980  *             RlcBearerCfg pointer
9981  * @return void
9982  *
9983  * ****************************************************************/
9984
9985 uint8_t procDrbListToSetup(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbItem,\
9986 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd, UpTnlCfg *upTnlInfo)
9987 {
9988
9989    if(drbItem != NULLP)
9990    {
9991       /* Filling RLC INFO */
9992       procRlcLcCfg(drbItem->dRBID, lcId, RB_TYPE_DRB, drbItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd);
9993
9994       /* Filling MAC INFO */
9995       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, drbItem, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
9996       {
9997          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetup()");
9998          return RFAILED;
9999       }
10000    }
10001    else if(drbSetupModItem != NULLP)
10002    {
10003       procRlcLcCfg(drbSetupModItem->dRBID, lcId, RB_TYPE_DRB, drbSetupModItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd);
10004
10005       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, NULL, drbSetupModItem, NULL, macLcToAdd, upTnlInfo) != ROK)
10006       {
10007          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetup()");
10008          return RFAILED;
10009       }
10010    }
10011    return ROK;
10012 }
10013
10014 /*******************************************************************
10015  *
10016  * @brief extract Drb List received by CU
10017  *
10018  * @details
10019  *
10020  *    Function : extractDrbListToSetup
10021  *
10022  *    Functionality: extract Drb List received by CU
10023  *                   for both MAC and RLC
10024  *
10025  * @params[in] DRBs_ToBeSetup_Item_t pointer
10026  *             DuUeCfg pointer
10027  * @return ROK/RFAIED
10028  *
10029  * ****************************************************************/
10030
10031 uint8_t extractDrbListToSetup(DRBs_ToBeSetup_List_t *drbCfg,DRBs_ToBeSetupMod_List_t *drbSetupModCfg,\
10032 uint8_t drbCount, DuUeCfg *ueCfgDb, uint32_t *drbBitMap)
10033 {
10034    uint8_t ret, drbIdx, lcId = 0;
10035    DRBs_ToBeSetup_Item_t *drbItem = NULLP;
10036    DRBs_ToBeSetupMod_ItemIEs_t *drbSetupModItem = NULLP;
10037
10038    ret = ROK;
10039    if(drbCount > 0)
10040    {
10041       for(drbIdx = 0; drbIdx < drbCount; drbIdx++)
10042       {
10043          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
10044          {
10045             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in MAC at extractDrbListToSetup()");
10046             ret = RFAILED;
10047             break;
10048          }
10049          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
10050          {
10051             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in RLC at extractDrbListToSetup()");
10052             ret = RFAILED;
10053             break;
10054          }
10055          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
10056          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
10057
10058          lcId = getDrbLcId(drbBitMap);
10059          if(lcId == RFAILED)
10060          {
10061             DU_LOG("\nERROR  -->  F1AP :  InCorrect LCID extractDrbListToSetup()");
10062             ret = RFAILED;
10063             break;
10064          }
10065          if(drbCfg != NULL)
10066          {
10067             drbItem = &drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
10068             ret = procDrbListToSetup(lcId, drbItem, NULL, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
10069                &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], &ueCfgDb->upTnlInfo[ueCfgDb->numDrb]);
10070             if(ret == RFAILED)
10071             {
10072                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetup()");
10073                break;
10074             }
10075          }
10076          else if(drbSetupModCfg != NULL)
10077          {
10078             drbSetupModItem = (DRBs_ToBeSetupMod_ItemIEs_t *) drbSetupModCfg->list.array[drbIdx];
10079             ret = procDrbListToSetup(lcId, NULL, &(drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item) ,\
10080             &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs],\
10081             &ueCfgDb->upTnlInfo[ueCfgDb->numDrb]);
10082             if(ret == RFAILED)
10083             {
10084                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetup()");
10085                break;
10086             }
10087          }
10088          ueCfgDb->numRlcLcs++;
10089          ueCfgDb->numMacLcs++;
10090          ueCfgDb->numDrb++;
10091
10092          DU_LOG("\nDEBUG --> DUAPP: extractDrbListToSetup:lcId:%x ,BitMap:%x, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
10093                             lcId,*drbBitMap, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
10094          if(ret == RFAILED)
10095          {
10096             DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetup()");
10097             break;
10098          }
10099       }
10100    }
10101    else
10102       ret = RFAILED;
10103
10104    return ret;
10105 }
10106
10107 /*******************************************************************
10108  *
10109  * @brief Function to extract Dl RRC Msg received from CU
10110  *
10111  * @details
10112  *
10113  *    Function : extractDlRrcMsg
10114  *
10115  *    Functionality: Function to extract Dl RRC Msg received from CU
10116  *
10117  * @params[in] F1AP message
10118  * @return ROK     - success
10119  *         RFAILED - failure
10120  *
10121  * ****************************************************************/
10122
10123 uint8_t extractDlRrcMsg(uint32_t gnbDuUeF1apId, uint32_t gnbCuUeF1apId, \
10124    F1DlRrcMsg *dlRrcMsg, RRCContainer_t *rrcContainer)
10125 {
10126    uint8_t ret = ROK;
10127    dlRrcMsg->rrcMsgSize = rrcContainer->size;
10128    if(dlRrcMsg->rrcMsgSize > 0)
10129    {
10130       DU_ALLOC_SHRABL_BUF(dlRrcMsg->rrcMsgPdu, dlRrcMsg->rrcMsgSize);
10131       if(!dlRrcMsg->rrcMsgPdu)
10132       {
10133          DU_LOG("\nERROR  --> DU APP : Memory allocation failed for RRC Msg in extractDlRrcMsg()");
10134          ret = RFAILED;
10135       }
10136       else
10137       {
10138          dlRrcMsg->gnbDuUeF1apId = gnbDuUeF1apId;
10139          dlRrcMsg->gnbCuUeF1apId = gnbCuUeF1apId;
10140          dlRrcMsg->srbId = SRB1_LCID;
10141          memcpy(dlRrcMsg->rrcMsgPdu, rrcContainer->buf, dlRrcMsg->rrcMsgSize);
10142       }
10143    }
10144    return ret;
10145 }
10146
10147 /*******************************************************************
10148  *
10149  * @brief Extract UE capability info
10150  *
10151  * @details
10152  *
10153  *    Function : extractUeCapability
10154  *
10155  *    Functionality: Extract UE capability info and stores in ue Cb
10156  *
10157  * @params[in] Octet string of UE capability RAT container list
10158  * @return ROK     - success
10159  *         RFAILED - failure
10160  *
10161  * ****************************************************************/
10162 UE_NR_Capability_t *extractUeCapability(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf, DuUeCb *ueCb)
10163 {
10164    uint8_t  idx;
10165    uint16_t recvBufLen;
10166    asn_dec_rval_t rval;
10167    UE_NR_Capability_t  *ueNrCap = NULLP;
10168    UE_CapabilityRAT_ContainerListRRC_t  *ueCapRatContList = NULLP;
10169
10170    /* Decoding UE Capability RAT Container List */
10171    recvBufLen = ueCapablityListBuf->size;
10172    DU_ALLOC(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10173    if(!ueCapRatContList)
10174    {
10175       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
10176       return NULLP;
10177    }
10178    memset(ueCapRatContList, 0, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10179    memset(&rval, 0, sizeof(asn_dec_rval_t));
10180    rval = aper_decode(0, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, (void **)&ueCapRatContList,
10181           ueCapablityListBuf->buf, recvBufLen, 0, 0);
10182    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10183    {
10184       DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
10185       return NULLP;
10186    }
10187    xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, ueCapRatContList);
10188
10189    /* Free encoded buffer after decoding */
10190
10191    for(idx = 0; idx < ueCapRatContList->list.count; idx++)
10192    {
10193       if(ueCapRatContList->list.array[idx]->rat_Type == RAT_Type_nr)
10194       {
10195          /* Decoding UE NR Capability */
10196           recvBufLen = ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.size;
10197           DU_ALLOC(ueNrCap, sizeof(UE_NR_Capability_t));
10198           if(!ueNrCap)
10199           {
10200              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
10201              DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10202              return NULLP;
10203           }
10204           memset(ueNrCap, 0, sizeof(UE_NR_Capability_t));
10205           memset(&rval, 0, sizeof(asn_dec_rval_t));
10206           rval = aper_decode(0, &asn_DEF_UE_NR_Capability, (void **)&ueNrCap,
10207                  ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf, recvBufLen, 0, 0);
10208           if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10209           {
10210              DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
10211              return NULLP;
10212           }
10213           xer_fprint(stdout, &asn_DEF_UE_NR_Capability, ueNrCap);
10214
10215           /* Free encoded buffer after decoding */
10216           free(ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf);
10217       }
10218       free(ueCapRatContList->list.array[idx]);
10219    }
10220
10221    /* Free Memory*/
10222    free(ueCapRatContList->list.array);
10223    DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10224    return ueNrCap;
10225 }
10226
10227 /*******************************************************************
10228 *
10229 * @brief free UE context setup request from CU
10230 *
10231 * @details
10232 *
10233 *    Function : freeAperDecodeF1UeContextSetupReq
10234 *
10235 *    Functionality: freeing part for the memory allocated by aper_decoder
10236 *
10237 * @params[in] F1AP message
10238 * @return ROK     - success
10239 *         RFAILED - failure
10240 *
10241 * ****************************************************************/
10242 void freeAperDecodeF1UeContextSetupReq(UEContextSetupRequest_t   *ueSetReq)
10243 {
10244    uint8_t ieIdx = 0;
10245
10246    if(ueSetReq->protocolIEs.list.array != NULLP)
10247    {
10248       for(ieIdx = 0; ieIdx < ueSetReq->protocolIEs.list.count; ieIdx++)
10249       {
10250          if(ueSetReq->protocolIEs.list.array[ieIdx])
10251          {
10252             switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
10253             {
10254                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10255                   break;
10256                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10257                   break;
10258                case ProtocolIE_ID_id_SpCell_ID:
10259                   freeAperDecodeNrcgi(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
10260                   break;
10261                case ProtocolIE_ID_id_ServCellIndex:
10262                   break;
10263                case ProtocolIE_ID_id_SpCellULConfigured:
10264                   break;
10265                case ProtocolIE_ID_id_CUtoDURRCInformation:
10266
10267                   freeAperDecodeCuToDuInfo(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation);
10268                   break;
10269                case ProtocolIE_ID_id_SCell_ToBeSetup_List:
10270
10271                   freeAperDecodeSplCellList(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SCell_ToBeSetup_List);
10272                   break;
10273                case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
10274
10275                   freeAperDecodeSRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List);
10276                   break;
10277                case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
10278
10279                   freeAperDecodeDRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List);
10280                   break;
10281                case ProtocolIE_ID_id_RRCContainer:
10282                   {
10283
10284                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf != NULLP)
10285                      {
10286
10287                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
10288                      }
10289                      break;
10290                   }
10291                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10292                   break;
10293                case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
10294                   {
10295                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf)
10296                      {
10297                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf);
10298                      }
10299                      break;
10300                   }
10301                default:
10302                   DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld " ,ueSetReq->protocolIEs.list.array[ieIdx]->id);
10303             }
10304             free(ueSetReq->protocolIEs.list.array[ieIdx]);
10305          }
10306       }
10307       free(ueSetReq->protocolIEs.list.array);
10308    }
10309 }
10310 /*******************************************************************
10311  *
10312  * @brief Process UE context setup request from CU
10313  *
10314  * @details
10315  *
10316  *    Function : procF1UeContextSetupReq
10317  *
10318  *    Functionality: Process UE context setup request from CU
10319  *
10320  * @params[in] F1AP message
10321  * @return ROK     - success
10322  *         RFAILED - failure
10323  *
10324  * ****************************************************************/
10325 uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
10326 {
10327    uint8_t  ret=0, ieIdx=0, ueIdx=0, cellIdx=0;
10328    bool ueCbFound = false;
10329    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0, bitRateSize=0;
10330    DuUeCb   *duUeCb = NULL;
10331    UEContextSetupRequest_t   *ueSetReq = NULL;
10332    DRBs_ToBeSetup_List_t *drbCfg = NULL;
10333
10334    ret = ROK;
10335
10336    ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
10337    for(ieIdx=0; (ieIdx < ueSetReq->protocolIEs.list.count && ret == ROK); ieIdx++)
10338    {
10339       switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
10340       {
10341          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10342             {
10343                gnbCuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
10344                break;
10345             }
10346          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10347             {
10348                gnbDuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
10349                break;
10350             }
10351          case ProtocolIE_ID_id_ServCellIndex:
10352             {
10353                cellIdx = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.ServCellIndex;
10354                for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
10355                {
10356                   if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
10357                         (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
10358                   {
10359                      ueCbFound = true;
10360                      duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
10361                      DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
10362                      if(duUeCb->f1UeDb)
10363                      {
10364                         memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
10365                         duUeCb->f1UeDb->actionType = UE_CTXT_SETUP;
10366                         duUeCb->f1UeDb->cellIdx = cellIdx;
10367                      }
10368                      else
10369                      {
10370                         DU_LOG("\nERROR  -->  F1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
10371                         ret = RFAILED;
10372                      }
10373                      break;
10374                   }
10375                   else
10376                      ueCbFound = false;
10377
10378                }
10379                if(!ueCbFound)
10380                {
10381                   DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
10382                   ret = RFAILED;
10383                }
10384                break;
10385             }
10386          case ProtocolIE_ID_id_SpCellULConfigured:
10387             /* Indicates whether the gNB-CU requests the gNB-DU to configure the uplink as no UL,
10388                UL, SUL or UL+SUL for the indicated cell for the UE */
10389             break;
10390          case ProtocolIE_ID_id_CUtoDURRCInformation:
10391             {
10392                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.uE_CapabilityRAT_ContainerList)
10393                {
10394                   duUeCb->f1UeDb->duUeCfg.ueNrCapability = \
10395                   extractUeCapability(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.\
10396                   uE_CapabilityRAT_ContainerList, duUeCb);
10397                }
10398                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.iE_Extensions)
10399                {
10400                   duUeCb->f1UeDb->duUeCfg.cellGrpCfg = extractCellGrpInfo(ueSetReq->protocolIEs.list.array[ieIdx]->\
10401                         value.choice.CUtoDURRCInformation.iE_Extensions, &duUeCb->f1UeDb->duUeCfg);
10402                   if(!duUeCb->f1UeDb->duUeCfg.cellGrpCfg)
10403                   {
10404                      DU_LOG("\nERROR  -->  F1AP: Failed to extract cell Grp Info");
10405                      //TODO: Update the failure cause in ue context Setup Response
10406                      ret = RFAILED;
10407                   }
10408                }
10409                break;
10410             }
10411          case ProtocolIE_ID_id_SCell_ToBeSetup_List:
10412             {
10413                DU_LOG("\nINFO   -->  DU_APP: Received SCell_ToBeSetup_List but  Not processing the list");
10414                break;
10415             }
10416          case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
10417             {
10418                if(extractSrbListToSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List,\
10419                &duUeCb->f1UeDb->duUeCfg))
10420                {
10421                   DU_LOG("\nERROR  -->  DU APP : Failed at extractSrbListToSetup()");
10422                   //TODO: Update the failure cause in ue context Setup Response
10423                   ret = RFAILED;
10424                }
10425                break;
10426             }
10427          case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
10428             {
10429                   drbCfg = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List;
10430
10431                   if(extractDrbListToSetup(drbCfg, NULL, drbCfg->list.count, &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap))
10432                   {
10433                      DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetup()");
10434                      //TODO: Update the failure cause in ue context Setup Response
10435                      ret = RFAILED;
10436                   }
10437                break;
10438             }
10439          case ProtocolIE_ID_id_RRCContainer:
10440             {
10441                /* Filling Dl RRC Msg Info */
10442                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
10443                if(!duUeCb->f1UeDb->dlRrcMsg)
10444                {
10445                   DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
10446                   ret = RFAILED;
10447                }
10448                else
10449                {
10450                   duUeCb->f1UeDb->dlRrcMsgPres = true;
10451                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
10452                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
10453                         &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer);
10454                }
10455                break;
10456             }
10457          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10458             {
10459                if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
10460                {
10461                   duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
10462                }
10463                else
10464                {
10465                   DU_LOG("\nERROR  -->  Ignoring delivery report, since rrcContainer is not present");
10466                }
10467                break;
10468             }
10469          case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
10470             {
10471                /* MaximumBitRate Uplink */
10472                bitRateSize = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.size;
10473                if(bitRateSize > 0)
10474                {
10475                   DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.ambrCfg, bitRateSize);
10476                   if(!duUeCb->f1UeDb->duUeCfg.ambrCfg)
10477                   {
10478                      DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
10479                      ret = RFAILED;
10480                   }
10481                   else
10482                   {
10483                      memset(duUeCb->f1UeDb->duUeCfg.ambrCfg, 0, sizeof(AmbrCfg));
10484                      memcpy(&duUeCb->f1UeDb->duUeCfg.ambrCfg->ulBr,
10485                            ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf, bitRateSize);
10486                   }
10487                }
10488                else
10489                   ret = RFAILED;
10490                break;
10491             }
10492          default:
10493             {
10494                break;
10495             }
10496       }
10497    }
10498    if(ret == RFAILED)
10499    {
10500       /*TODO : Negative case*/
10501       // BuildAndSendUeContextSetupRsp(cellId,ueIdx);
10502       DU_LOG("\nERROR  -->  F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
10503    }
10504    else
10505       ret = duProcUeContextSetupRequest(duUeCb);
10506
10507    freeAperDecodeF1UeContextSetupReq(ueSetReq);
10508    return ret;
10509
10510 }
10511 /*******************************************************************
10512  * @brief Free the memory allocated for Dl Tunnel Info
10513  *
10514  * @details
10515  *
10516  *    Function : freeDlTnlInfo
10517  *
10518  *    Functionality:
10519  *       Free the memory allocated for Dl Tunnel Info
10520  *
10521  * @params[in] DLUPTNLInformation_ToBeSetup_List_t *
10522  * @return void
10523  *
10524  * ****************************************************************/
10525
10526 void freeDlTnlInfo(DLUPTNLInformation_ToBeSetup_List_t *tnlInfo)
10527 {
10528    uint8_t arrIdx = 0;
10529
10530    if(tnlInfo)
10531    {
10532       for(arrIdx=0; arrIdx < tnlInfo->list.count; arrIdx++)
10533       {
10534          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf,\
10535                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
10536          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf,\
10537                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
10538          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
10539          DU_FREE(tnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
10540       }
10541       DU_FREE(tnlInfo->list.array, tnlInfo->list.size);
10542    }
10543 }
10544
10545 /*******************************************************************
10546  * @brief Free the memory allocated for DRB setup List
10547  *
10548  * @details
10549  *
10550  *    Function : freeDrbSetupList
10551  *
10552  *    Functionality:
10553  *       Free the memory allocated for DRB setup list
10554  *
10555  * @params[in] DRBs_Setup_List_t *
10556  * @return void
10557  *
10558  * ****************************************************************/
10559 void freeDrbSetupList(DRBs_Setup_List_t *drbSetupList)
10560 {
10561    uint8_t arrIdx = 0;
10562    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
10563
10564    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
10565    {
10566       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
10567       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
10568       DU_FREE(drbSetupList->list.array[arrIdx],  sizeof(DRBs_Setup_Item_t));
10569    }
10570    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
10571 }
10572
10573 /*******************************************************************
10574  * @brief Free the memory allocated for UE Setup response
10575  *
10576  * @details
10577  *
10578  *    Function : FreeUeContextSetupRsp
10579  *
10580  *    Functionality:
10581  *       Free the memory allocated for UE Setup response
10582  *
10583  * @params[in] F1AP PDU for UE setup response
10584  * @return ROK     - success
10585  *         RFAILED - failure
10586  *
10587  * ****************************************************************/
10588 void FreeUeContextSetupRsp(F1AP_PDU_t *f1apMsg)
10589 {
10590    uint8_t idx;
10591    UEContextSetupResponse_t *ueSetRsp = NULLP;
10592
10593    if(f1apMsg)
10594    {
10595       if(f1apMsg->choice.successfulOutcome)
10596       {
10597          ueSetRsp = &f1apMsg->choice.successfulOutcome->value.choice.\
10598                     UEContextSetupResponse;
10599          if(ueSetRsp->protocolIEs.list.array)
10600          {
10601             for(idx = 0; idx < ueSetRsp->protocolIEs.list.count; idx++)
10602             {
10603                if(ueSetRsp->protocolIEs.list.array[idx])
10604                {
10605                   switch(ueSetRsp->protocolIEs.list.array[idx]->id)
10606                   {
10607                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10608                         break;
10609                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10610                         break;
10611                      case ProtocolIE_ID_id_DUtoCURRCInformation:
10612                         {
10613                            CellGroupConfig_t *cellGrpCfg = NULLP;
10614                            cellGrpCfg  = &ueSetRsp->protocolIEs.list.array[idx]->value.choice.\
10615                                          DUtoCURRCInformation.cellGroupConfig;
10616                            if(cellGrpCfg->buf != NULLP)
10617                            {
10618                               DU_FREE(cellGrpCfg->buf, cellGrpCfg->size);
10619                               cellGrpCfg = NULLP;
10620                            }
10621                            break;
10622                         }
10623                     case ProtocolIE_ID_id_DRBs_Setup_List:
10624                         {
10625                            freeDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
10626                            break;
10627                         }
10628                      default:
10629                         DU_LOG("\nERROR  -->  DUAPP: Invalid Id %ld at FreeUeContextSetupRsp()",\
10630                         ueSetRsp->protocolIEs.list.array[idx]->id);
10631                         break;
10632                   }
10633                   DU_FREE(ueSetRsp->protocolIEs.list.array[idx],\
10634                         sizeof(UEContextSetupResponseIEs_t));
10635                }
10636             }
10637             DU_FREE(ueSetRsp->protocolIEs.list.array, \
10638                   ueSetRsp->protocolIEs.list.size);
10639          }
10640          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
10641       }
10642       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10643    }
10644 }
10645
10646 /*******************************************************************
10647  *
10648  * @brief Builds Ue context Setup Rsp DU To CU Info
10649  *
10650  * @details
10651  *
10652  *    Function : EncodeUeCntxtDuToCuInfo
10653  *
10654  *    Functionality: Builds Ue context Setup Rsp DU To CU Info
10655  *
10656  * @params[in] CellGroupConfig_t *, CellGroupConfigRrc_t *
10657  *
10658  * @return ROK     - success
10659  *         RFAILED - failure
10660  *
10661  ******************************************************************/
10662
10663 uint8_t EncodeUeCntxtDuToCuInfo(CellGroupConfig_t *duToCuCellGrp, CellGroupConfigRrc_t *duCellGrpCfg)
10664 {
10665    asn_enc_rval_t        encRetVal;
10666
10667    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, duCellGrpCfg);
10668    memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
10669    encBufSize = 0;
10670    encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, duCellGrpCfg, PrepFinalEncBuf, encBuf);
10671    /* Encode results */
10672    if(encRetVal.encoded == ENCODE_FAIL)
10673    {
10674       DU_LOG( "\nERROR  -->  F1AP : Could not encode UeCntxtDuToCuInfo (at %s)\n",\
10675             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10676       return RFAILED;
10677    }
10678    else
10679    {
10680       DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
10681       for(int i=0; i< encBufSize; i++)
10682       {
10683          printf("%x",encBuf[i]);
10684       }
10685    }
10686    duToCuCellGrp->size = encBufSize;
10687    DU_ALLOC(duToCuCellGrp->buf, duToCuCellGrp->size);
10688    if(!duToCuCellGrp->buf)
10689    {
10690       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in UeCntxtDuToCuInfo");
10691    }
10692    memcpy(duToCuCellGrp->buf, encBuf, duToCuCellGrp->size);
10693    return ROK;
10694 }
10695
10696 /*******************************************************************
10697  *
10698  * @brief Fills Dl Gtp tunnel Info
10699  *
10700  * @details
10701  *
10702  *    Function : fillGtpTunnelforDl
10703  *
10704  *    Functionality: Fills Dl Gtp tunnel Info
10705  *
10706  * @params[in]
10707  *
10708  * @return ROK     - success
10709  *         RFAILED - failure
10710  *
10711  * ****************************************************************/
10712
10713 uint8_t fillGtpTunnelforDl(GTPTunnel_t *gtpDl, GtpTnlCfg *gtpUeCfg)
10714 {
10715    uint8_t bufSize = 0;
10716
10717    gtpDl->transportLayerAddress.size    = 4*sizeof(uint8_t);
10718    DU_ALLOC(gtpDl->transportLayerAddress.buf, gtpDl->transportLayerAddress.size);
10719    if(gtpDl->transportLayerAddress.buf == NULLP)
10720    {
10721       return RFAILED;
10722    }
10723    memcpy(gtpDl->transportLayerAddress.buf, &gtpUeCfg->dlTnlAddress, gtpDl->transportLayerAddress.size);
10724
10725    /*GTP TEID*/
10726    gtpDl->gTP_TEID.size = 4 * sizeof(uint8_t);
10727    DU_ALLOC(gtpDl->gTP_TEID.buf, gtpDl->gTP_TEID.size);
10728    if(gtpDl->gTP_TEID.buf == NULLP)
10729    {
10730       return RFAILED;
10731    }
10732    bufSize = 3; /*forming an Octect String*/
10733    fillTeIdString(bufSize, gtpUeCfg->teId, gtpDl->gTP_TEID.buf);
10734
10735    return ROK;
10736 }
10737
10738 /*******************************************************************
10739  *
10740  * @brief Fills DL Tunnel Setup List
10741  *
10742  * @details
10743  *
10744  *    Function : fillDlTnlSetupList
10745  *
10746  *    Functionality: Fills the DL Tunnel Setup List
10747  *
10748  * @params[in]
10749  *
10750  * @return ROK     - success
10751  *         RFAILED - failure
10752  *
10753  * ****************************************************************/
10754
10755 uint8_t fillDlTnlSetupList(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo, UpTnlCfg *tnlCfg)
10756 {
10757    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
10758
10759    eleCount = 1;
10760    dlTnlInfo->list.count = eleCount;
10761    dlTnlInfo->list.size = (eleCount * sizeof(DLUPTNLInformation_ToBeSetup_Item_t *));
10762
10763    /* Initialize the DL Tnl Setup List Members */
10764    DU_ALLOC(dlTnlInfo->list.array, dlTnlInfo->list.size);
10765    if(dlTnlInfo->list.array == NULLP)
10766    {
10767       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL Tnl Setup List in fillDlTnlSetupList()");
10768       ret = RFAILED;
10769    }
10770    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
10771    {
10772       DU_ALLOC(dlTnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
10773       if(dlTnlInfo->list.array[arrIdx] == NULLP)
10774       {
10775          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDlTnlSetupList()", arrIdx);
10776          return RFAILED;
10777       }
10778       dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
10779       DU_ALLOC(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
10780       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel == NULLP)
10781       {
10782          DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL tunnel info in fillDlTnlSetupList()");
10783          return RFAILED;
10784       }
10785       ret = fillGtpTunnelforDl(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel,\
10786                tnlCfg->tnlCfg1);
10787       if(ret != ROK)
10788          break;
10789    }
10790    return ret;
10791 }
10792
10793 /*******************************************************************
10794  *
10795  * @brief Fills the Drb Setup List for Ue Context Setup Response
10796  *
10797  * @details
10798  *
10799  *    Function : fillDrbSetupList
10800  *
10801  *    Functionality: Fills the Drb Setup List for Ue Context Setup Response
10802  *
10803  * @params[in]
10804  *
10805  * @return ROK     - success
10806  *         RFAILED - failure
10807  *
10808  * ****************************************************************/
10809 uint8_t fillDrbSetupList(DRBs_Setup_List_t *drbSetupList, DuUeCfg *ueCfg)
10810 {
10811    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
10812    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
10813
10814    eleCount = ueCfg->numDrb;
10815    drbSetupList->list.count = eleCount;
10816    drbSetupList->list.size = \
10817         (eleCount * sizeof(DRBs_Setup_Item_t *));
10818
10819    /* Initialize the Drb Setup List Members */
10820    DU_ALLOC(drbSetupList->list.array, drbSetupList->list.size);
10821    if(drbSetupList->list.array == NULLP)
10822    {
10823       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DRB Setup List in fillDrbSetupList()");
10824       ret = RFAILED;
10825    }
10826
10827    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
10828    {
10829       DU_ALLOC(drbSetupList->list.array[arrIdx], sizeof(DRBs_Setup_Item_t));
10830       if(drbSetupList->list.array[arrIdx] == NULLP)
10831       {
10832          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDrbSetupList()", arrIdx);
10833          return RFAILED;
10834       }
10835       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
10836       drbItemIe->id = ProtocolIE_ID_id_DRBs_Setup_Item;
10837       drbItemIe->criticality = Criticality_reject;
10838       drbItemIe->value.present = DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item;
10839       drbItemIe->value.choice.DRBs_Setup_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
10840       ret = fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List,\
10841           &ueCfg->upTnlInfo[arrIdx]);
10842       if(ret != ROK)
10843          break;
10844    }
10845    return ret;
10846 }
10847
10848 /*******************************************************************
10849  *
10850  * @brief Builds and sends the UE Setup Response
10851  *
10852  * @details
10853  *
10854  *    Function : BuildAndSendUeContextSetupRsp
10855  *
10856  *    Functionality: Constructs the UE Setup Response and sends
10857  *                   it to the DU through SCTP.
10858  *
10859  * @params[in] uint8_t cellId,uint8_t ueIdx
10860  *
10861  * @return ROK     - success
10862  *         RFAILED - failure
10863  *
10864  * ****************************************************************/
10865 uint8_t BuildAndSendUeContextSetupRsp(uint8_t cellId,uint8_t ueIdx)
10866 {
10867    uint8_t   idx, ret, cellIdx, elementCnt;
10868    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
10869    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
10870    asn_enc_rval_t  encRetVal;        /* Encoder return value */
10871    F1AP_PDU_t               *f1apMsg = NULLP;
10872    UEContextSetupResponse_t *ueSetRsp = NULLP;
10873    CellGroupConfigRrc_t     *cellGrpCfg = NULLP;
10874    DuUeCb                   *ueCb = NULLP;
10875
10876    DU_LOG("\n INFO   -->  F1AP : Building UE Context Setup Response for cellId %d, ueIdx %d\n", cellId, ueIdx);
10877
10878    while(true)
10879    {
10880       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
10881       if(f1apMsg == NULLP)
10882       {
10883          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
10884          ret = RFAILED;
10885          break;
10886       }
10887
10888       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
10889       DU_ALLOC(f1apMsg->choice.successfulOutcome,
10890             sizeof(SuccessfulOutcome_t));
10891       if(f1apMsg->choice.successfulOutcome == NULLP)
10892       {
10893          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
10894          ret = RFAILED;
10895          break;
10896       }
10897
10898       f1apMsg->choice.successfulOutcome->procedureCode = \
10899                                                          ProcedureCode_id_UEContextSetup;
10900       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
10901       f1apMsg->choice.successfulOutcome->value.present = \
10902                                                          SuccessfulOutcome__value_PR_UEContextSetupResponse;
10903
10904       ueSetRsp =
10905          &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
10906       elementCnt = 4;
10907       ueSetRsp->protocolIEs.list.count = elementCnt;
10908       ueSetRsp->protocolIEs.list.size = \
10909                                         elementCnt * sizeof(UEContextSetupResponse_t *);
10910
10911       /* Initialize the UESetup members */
10912       DU_ALLOC(ueSetRsp->protocolIEs.list.array, \
10913             ueSetRsp->protocolIEs.list.size);
10914       if(ueSetRsp->protocolIEs.list.array == NULLP)
10915       {
10916          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
10917          ret = RFAILED;
10918          break;
10919       }
10920
10921       for(idx=0; idx<elementCnt; idx++)
10922       {
10923          DU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
10924                sizeof(UEContextSetupResponseIEs_t));
10925          if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
10926          {
10927             DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
10928             ret = RFAILED;
10929             break;
10930          }
10931       }
10932       /* Fetching Ue Cb Info*/
10933       GET_CELL_IDX(cellId, cellIdx);
10934       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
10935       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
10936       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
10937
10938       idx = 0;
10939       /*GNB CU UE F1AP ID*/
10940       ueSetRsp->protocolIEs.list.array[idx]->id = \
10941                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
10942       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10943       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
10944                                                              UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
10945       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
10946
10947       /*GNB DU UE F1AP ID*/
10948       idx++;
10949       ueSetRsp->protocolIEs.list.array[idx]->id = \
10950                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
10951       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10952       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
10953                                                              UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
10954       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
10955
10956
10957       /*DUtoCURRC Information */
10958       idx++;
10959       ueSetRsp->protocolIEs.list.array[idx]->id  = \
10960                                                    ProtocolIE_ID_id_DUtoCURRCInformation;
10961       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10962       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
10963                                                             UEContextSetupResponseIEs__value_PR_DUtoCURRCInformation;
10964       if(ueCb->f1UeDb)
10965       {
10966          if(ueCb->f1UeDb->duUeCfg.cellGrpCfg)
10967          {
10968             cellGrpCfg = (CellGroupConfigRrc_t*)ueCb->f1UeDb->duUeCfg.cellGrpCfg;
10969             ret = EncodeUeCntxtDuToCuInfo(&ueSetRsp->protocolIEs.list.array[idx]->value.\
10970                      choice.DUtoCURRCInformation.cellGroupConfig, cellGrpCfg);
10971             if(ret == RFAILED)
10972             {
10973                DU_LOG("\nERROR  -->  F1AP : Failed to EncodeUeCntxtDuToCuInfo in BuildAndSendUeContextSetupRsp()");
10974                freeF1UeDb(ueCb->f1UeDb);
10975                ueCb->f1UeDb = NULLP;
10976                break;
10977             }
10978          }
10979       }
10980       else
10981       {
10982          DU_LOG("\nERROR  -->  F1AP : Failed to form DUtoCU RRCInfo at BuildAndSendUeContextSetupRsp()");
10983          ret = RFAILED;
10984          break;
10985       }
10986
10987       /* Drb Setup List */
10988       idx++;
10989       ueSetRsp->protocolIEs.list.array[idx]->id  = \
10990                                  ProtocolIE_ID_id_DRBs_Setup_List;
10991       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
10992       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
10993                                  UEContextSetupResponseIEs__value_PR_DRBs_Setup_List;
10994       ret = fillDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List,\
10995                &ueCb->f1UeDb->duUeCfg);
10996       if(ret == RFAILED)
10997       {
10998          DU_LOG("\nERROR  -->  F1AP : Failed to fillDrbSetupList in BuildAndSendUeContextSetupRsp()");
10999          freeF1UeDb(ueCb->f1UeDb);
11000          ueCb->f1UeDb = NULLP;
11001          break;
11002       }
11003
11004        /* Free UeContext Db created during Ue context Req */
11005        freeF1UeDb(ueCb->f1UeDb);
11006        ueCb->f1UeDb = NULLP;
11007
11008       /* TODO: To send Drb list */
11009       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11010
11011       /* Encode the UE context setup response type as APER */
11012       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
11013       encBufSize = 0;
11014       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11015             encBuf);
11016       /* Encode results */
11017       if(encRetVal.encoded == ENCODE_FAIL)
11018       {
11019          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Response structure (at %s)\n",\
11020                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11021          ret = RFAILED;
11022          break;
11023       }
11024       else
11025       {
11026          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Setup Response\n");
11027          for(int i=0; i< encBufSize; i++)
11028          {
11029             printf("%x",encBuf[i]);
11030          }
11031       }
11032
11033       /* Sending  msg  */
11034       if(sendF1APMsg()  != ROK)
11035       {
11036          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Response failed");
11037          ret = RFAILED;
11038          break;
11039       }
11040       break;
11041    }
11042    FreeUeContextSetupRsp(f1apMsg);
11043    return ret;
11044 }/* End of BuildAndSendUeContextSetupRsp */
11045 /*******************************************************************
11046 *
11047 * @brief  Build And Send Ue Context Rsp
11048 *
11049 * @details
11050 *
11051 *    Function : BuildAndSendUeCtxtRsp
11052 *
11053 *    Functionality : Build And Send Ue Context Rsp
11054
11055 * @params[in]
11056 * @return sucess = ROK
11057 *         failure = RFAILED
11058 *
11059 * ****************************************************************/
11060 uint8_t BuildAndSendUeCtxtRsp(uint8_t cellId, uint8_t ueIdx)
11061 {
11062    uint8_t cellIdx = 0, actionType = 0;
11063
11064    GET_CELL_IDX(cellId, cellIdx);
11065    actionType = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].f1UeDb->actionType;
11066
11067    switch(actionType)
11068    {
11069       case UE_CTXT_SETUP:
11070          {
11071             BuildAndSendUeContextSetupRsp(cellId,ueIdx);
11072             break;
11073          }
11074       case UE_CTXT_MOD:
11075          {
11076             BuildAndSendUeContextModRsp(cellId, ueIdx);
11077             break;
11078          }
11079       default:
11080          DU_LOG("ERROR  -->  F1AP: Invalid Action Type %d at BuildAndSendUeCtxtRsp()", actionType);
11081          break;
11082
11083    }
11084    return ROK;
11085 }
11086
11087 /*******************************************************************
11088  *
11089  * @brief deallocating the memory of  F1reset msg
11090  *
11091  * @details
11092  *
11093  *    Function : FreeF1ResetReq
11094  *
11095  *    Functionality :
11096  *         - freeing memory of F1reset request msg
11097  *
11098  * @params[in]
11099  * @return void
11100  *
11101  *
11102  * ****************************************************************/
11103 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
11104 {
11105    uint8_t idx =0 ;
11106    Reset_t *f1ResetMsg;
11107
11108    if(f1apMsg)
11109    {
11110       if(f1apMsg->choice.initiatingMessage)
11111       {
11112          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11113
11114          if(f1ResetMsg->protocolIEs.list.array)
11115          {
11116             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
11117             {
11118                if(f1ResetMsg->protocolIEs.list.array[idx])
11119                {
11120                   DU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
11121                }
11122             }
11123             DU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
11124          }
11125          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11126       }
11127       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11128    }
11129 }
11130 /*******************************************************************
11131  *
11132  * @brief Build and Send F1reset request
11133  *
11134  * @details
11135  *
11136  *    Function : BuildAndSendF1ResetReq
11137  *
11138  *    Functionality:
11139  *         - Build and Send F1reset request msg
11140  *
11141  * @params[in]
11142  * @return ROK     - success
11143  *         RFAILED - failure
11144  *
11145  * ****************************************************************/
11146 uint8_t BuildAndSendF1ResetReq()
11147 {
11148    uint8_t          elementCnt=0;
11149    uint8_t          idx=0;
11150    uint8_t          ret= RFAILED;
11151    Reset_t          *f1ResetMsg = NULLP;
11152    F1AP_PDU_t       *f1apMsg = NULLP;
11153    asn_enc_rval_t   encRetVal;
11154    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset request \n");
11155    do
11156    {
11157       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11158       if(f1apMsg == NULLP)
11159       {
11160          break;
11161       }
11162       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
11163       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11164       if(f1apMsg->choice.initiatingMessage == NULLP)
11165       {
11166          break;
11167       }
11168       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
11169       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
11170       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
11171
11172       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11173
11174       elementCnt = 3;
11175       f1ResetMsg->protocolIEs.list.count = elementCnt;
11176       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
11177
11178       /* Initialize the F1Setup members */
11179       DU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
11180       if(f1ResetMsg->protocolIEs.list.array == NULLP)
11181       {
11182          break;
11183       }
11184       for(idx=0; idx<elementCnt; idx++)
11185       {
11186          DU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
11187          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
11188          {
11189             break;
11190          }
11191       }
11192
11193       /*TransactionID*/
11194       idx=0;
11195       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
11196       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11197       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
11198       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
11199
11200       /*Cause*/
11201       idx++;
11202       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
11203       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
11204       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
11205       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
11206       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
11207
11208       /*Reset Type*/
11209       idx++;
11210       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
11211       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11212       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
11213       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
11214       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
11215
11216       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11217
11218       /* Encode the F1SetupRequest type as APER */
11219       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11220       encBufSize = 0;
11221       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11222             encBuf);
11223
11224       /* Encode results */
11225       if(encRetVal.encoded == ENCODE_FAIL)
11226       {
11227          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
11228                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11229          break;
11230       }
11231       else
11232       {
11233          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1Reset\n");
11234          for(idx=0; idx< encBufSize; idx++)
11235          {
11236             printf("%x",encBuf[idx]);
11237          }
11238       }
11239
11240       if(sendF1APMsg() != ROK)
11241       {
11242          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
11243          break;
11244       }
11245
11246       ret = ROK;
11247       break;
11248    }while(true);
11249
11250    FreeF1ResetReq(f1apMsg);
11251    return ret;
11252 }
11253 /*******************************************************************
11254  *
11255  * @brief Build And Send F1ResetAck
11256  *
11257  * @details
11258  *
11259  *    Function : BuildAndSendF1ResetAck
11260  *
11261  *    Functionality:
11262  *         - Build And Send  F1ResetRSP
11263  *
11264  * @return ROK     - success
11265  *         RFAILED - failure
11266  *
11267  * ****************************************************************/
11268 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
11269 {
11270    uint8_t idx;
11271    ResetAcknowledge_t *f1ResetAck;
11272
11273    if(f1apMsg)
11274    {
11275       if(f1apMsg->choice.successfulOutcome)
11276       {
11277          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
11278
11279          if(f1ResetAck->protocolIEs.list.array)
11280          {
11281             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
11282             {
11283                if(f1ResetAck->protocolIEs.list.array[idx])
11284                {
11285                   DU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
11286                }
11287             }
11288             DU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
11289          }
11290          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11291       }
11292       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11293    }
11294 }
11295
11296 /*******************************************************************
11297  *
11298  * @brief Build And Send F1ResetAck
11299  *
11300  * @details
11301  *
11302  *    Function : BuildAndSendF1ResetAck
11303  *
11304  *    Functionality:
11305  *         - Build And Send  F1ResetRSP
11306  *
11307  *  @params[in]
11308  * @return ROK     - success
11309  *         RFAILED - failure
11310  *
11311  * ****************************************************************/
11312 uint8_t BuildAndSendF1ResetAck()
11313 {
11314    uint8_t                idx = 0;
11315    uint8_t                elementCnt = 0;
11316    uint8_t                ret = RFAILED;
11317    F1AP_PDU_t             *f1apMsg = NULL;
11318    ResetAcknowledge_t     *f1ResetAck = NULLP;
11319    asn_enc_rval_t         encRetVal;
11320    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset Acknowledgment \n");
11321
11322    do{
11323       /* Allocate the memory for F1ResetRequest_t */
11324       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11325       if(f1apMsg == NULLP)
11326       {
11327          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11328          break;
11329       }
11330
11331       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
11332
11333       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11334       if(f1apMsg->choice.successfulOutcome == NULLP)
11335       {
11336          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11337          break;
11338       }
11339       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
11340       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
11341       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
11342
11343       elementCnt = 1;
11344
11345       f1ResetAck->protocolIEs.list.count = elementCnt;
11346       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
11347
11348       DU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
11349       if(f1ResetAck->protocolIEs.list.array == NULLP)
11350       {
11351          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
11352          break;
11353       }
11354
11355       for(idx=0; idx<elementCnt; idx++)
11356       {
11357          DU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
11358          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
11359          {
11360             break;
11361          }
11362       }
11363       /*TransactionID*/
11364       idx = 0;
11365       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
11366       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11367       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
11368       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
11369
11370       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11371
11372       /* Encode the F1SetupRequest type as UPER */
11373       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11374       encBufSize = 0;
11375       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
11376
11377       /* Check encode results */
11378       if(encRetVal.encoded == ENCODE_FAIL)
11379       {
11380          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
11381                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11382          break;
11383       }
11384       else
11385       {
11386          DU_LOG("\nDUBUG   -->  F1AP : Created APER encoded buffer for F1ResetAck\n");
11387          for(int i=0; i< encBufSize; i++)
11388          {
11389             printf("%x",encBuf[i]);
11390          }
11391       }
11392       /* Sending msg */
11393       if(sendF1APMsg() != ROK)
11394       {
11395          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Acknowledgement failed");
11396          break;
11397       }
11398
11399       ret = ROK;
11400       break;
11401    }while(true);
11402
11403    FreeF1ResetAck(f1apMsg);
11404    return ret;
11405 }
11406 /******************************************************************
11407 *
11408 * @brief free F1 reset msg allocated by aper_decoder
11409 *
11410 * @details
11411 *
11412 *    Function : freeAperDecodeF1ResetMsg
11413 *
11414 *    Functionality: free F1 reset msg allocated by aper_decoder
11415 *
11416 * @params[in] Reset_t *f1ResetMsg
11417 * @return void
11418 *
11419 * ****************************************************************/
11420
11421 void freeAperDecodeF1ResetMsg(Reset_t *f1ResetMsg)
11422 {
11423    uint8_t ieIdx =0;
11424    if(f1ResetMsg->protocolIEs.list.array)
11425    {
11426       for(ieIdx=0 ;ieIdx < f1ResetMsg->protocolIEs.list.count ; ieIdx++)
11427       {
11428          if(f1ResetMsg->protocolIEs.list.array[ieIdx])
11429          {
11430             free(f1ResetMsg->protocolIEs.list.array[ieIdx]);
11431          }
11432       }
11433       free(f1ResetMsg->protocolIEs.list.array);
11434    }
11435 }
11436
11437 /******************************************************************
11438  *
11439  * @brief Processes DL RRC Message Transfer  sent by CU
11440  *
11441  * @details
11442  *
11443  *    Function : procF1ResetReq
11444  *
11445  *    Functionality: Processes DL RRC Message Transfer sent by CU
11446  *
11447  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11448  * @return ROK     - success
11449  *         RFAILED - failure
11450  *
11451  * ****************************************************************/
11452 uint8_t procF1ResetReq(F1AP_PDU_t *f1apMsg)
11453 {
11454    /* we are currently not supporting Ue release. right now we are supporting only init case of fireset */
11455    uint8_t       ieIdx = 0;
11456    uint8_t        ret = ROK;
11457    Reset_t       *f1ResetMsg = NULLP;
11458
11459    DU_LOG("\nINFO   -->  Processing F1 reset request");
11460    f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11461
11462    for(ieIdx=0; ieIdx<f1ResetMsg->protocolIEs.list.count; ieIdx++)
11463    {
11464       switch(f1ResetMsg->protocolIEs.list.array[ieIdx]->id)
11465       {
11466          case ProtocolIE_ID_id_TransactionID:
11467             break;
11468
11469          case ProtocolIE_ID_id_Cause:
11470             break;
11471
11472          case ProtocolIE_ID_id_ResetType:
11473             {
11474                break;
11475             }
11476
11477          default:
11478             break;
11479       }
11480    }
11481    ret = BuildAndSendF1ResetAck();
11482    DU_LOG("\nINFO   -->  UE release is not supported for now");
11483
11484    freeAperDecodeF1ResetMsg(f1ResetMsg);
11485
11486    return ret;
11487 }
11488
11489 /*******************************************************************
11490  *
11491  * @brief free the RRC delivery report
11492  *
11493  * @details
11494  *
11495  *    Function : freeRrcDeliveryReport
11496  *
11497  *    Functionality: free the RRC delivery report
11498  *
11499  * @params[in]
11500  * @return ROK     - success
11501  *         RFAILED - failure
11502  *
11503  * ****************************************************************/
11504 void freeRrcDeliveryReport(F1AP_PDU_t  *f1apMsg )
11505 {
11506    uint8_t idx=0;
11507    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11508
11509    if(f1apMsg)
11510    {
11511       if(f1apMsg->choice.initiatingMessage)
11512       {
11513          rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11514          if(rrcDeliveryReport->protocolIEs.list.array)
11515          {
11516             for(idx =0 ;idx <rrcDeliveryReport->protocolIEs.list.count ;
11517                   idx++)
11518             {
11519                if(rrcDeliveryReport->protocolIEs.list.array[idx])
11520                {
11521                   DU_FREE(rrcDeliveryReport->protocolIEs.list.array[idx],
11522                         sizeof(RRCDeliveryReportIEs_t));
11523                }
11524             }
11525             DU_FREE(rrcDeliveryReport->protocolIEs.list.array,
11526                   rrcDeliveryReport->protocolIEs.list.size);
11527          }
11528          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11529       }
11530       DU_FREE(f1apMsg,
11531             sizeof(F1AP_PDU_t));
11532    }
11533 }
11534
11535 /*******************************************************************
11536 *
11537 * @brief Builds and sends the RRC delivery report
11538 *
11539 * @details
11540 *
11541 *    Function : BuildAndSendRrcDeliveryReport
11542 *
11543 *    Functionality: Builds and sends the RRC delivery report
11544 *
11545 * @params[in]
11546 *
11547 * @return ROK     - success
11548 *         RFAILED - failure
11549 *
11550 * ****************************************************************/
11551 uint8_t BuildAndSendRrcDeliveryReport(uint32_t gnbCuUeF1apId, \
11552    uint32_t gnbDuUeF1apId, RrcDeliveryReport *rrcDelivery)
11553 {
11554    uint8_t             ret = RFAILED;
11555    uint8_t             idx    = 0;
11556    uint8_t             idx1   = 0;
11557    uint8_t             elementCnt = 0;
11558    F1AP_PDU_t          *f1apMsg = NULLP;
11559    asn_enc_rval_t      encRetVal;
11560    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11561
11562    do{
11563
11564       DU_LOG("\nINFO   -->  F1AP : Building RRC delivery Message Transfer Message\n");
11565       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11566       if(f1apMsg == NULLP)
11567       {
11568          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11569          break;
11570       }
11571       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
11572       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11573       if(f1apMsg->choice.initiatingMessage == NULLP)
11574       {
11575          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU  failed");
11576          break;
11577       }
11578       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_RRCDeliveryReport;
11579       f1apMsg->choice.initiatingMessage->criticality   = Criticality_ignore;
11580       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RRCDeliveryReport;
11581
11582       rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11583       elementCnt = 4;
11584       rrcDeliveryReport->protocolIEs.list.count = elementCnt;
11585       rrcDeliveryReport->protocolIEs.list.size = elementCnt * sizeof(RRCDeliveryReportIEs_t *);
11586
11587       /* Initialize the F1Setup members */
11588       DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array, rrcDeliveryReport->protocolIEs.list.size);
11589       if(rrcDeliveryReport->protocolIEs.list.array == NULLP)
11590       {
11591          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRC Delivery  failed");
11592          break;
11593       }
11594       for(idx =0 ;idx <elementCnt; idx++)
11595       {
11596          DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array[idx], sizeof(RRCDeliveryReportIEs_t));
11597          if(rrcDeliveryReport->protocolIEs.list.array[idx] == NULLP)
11598          {
11599             break;
11600          }
11601       }
11602
11603       idx1 = 0;
11604
11605       /*GNB CU UE F1AP ID*/
11606       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11607       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
11608       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_CU_UE_F1AP_ID;
11609       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
11610
11611       /*GNB DU UE F1AP ID*/
11612       idx1++;
11613       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11614       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
11615       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_DU_UE_F1AP_ID;
11616       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
11617
11618       /*RRC delivery status*/
11619       idx1++;
11620       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_RRCDeliveryStatus;
11621       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
11622       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_RRCDeliveryStatus;
11623       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.delivery_status =\
11624       rrcDelivery->rrcDeliveryStatus.deliveryStatus;
11625       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.triggering_message =\
11626       rrcDelivery->rrcDeliveryStatus.triggeringMessage;
11627
11628       /* SRB ID */
11629       idx1++;
11630       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
11631       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
11632       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_SRBID;
11633       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.SRBID =  rrcDelivery->srbId;
11634
11635       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11636
11637       /* Encode the RRC DELIVERY REPORT type as APER */
11638       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11639       encBufSize = 0;
11640       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11641             encBuf);
11642
11643       /* Encode results */
11644       if(encRetVal.encoded == ENCODE_FAIL)
11645       {
11646          DU_LOG("\nERROR  -->  F1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
11647                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11648          break;
11649       }
11650       else
11651       {
11652          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for RRC Delivery Msg \n");
11653          for(idx=0; idx< encBufSize; idx++)
11654          {
11655             printf("%x",encBuf[idx]);
11656          }
11657       }
11658
11659       /* Sending msg */
11660       if(sendF1APMsg() != ROK)
11661       {
11662          DU_LOG("\nERROR  -->  F1AP : Sending RRC delivery  msg request failed");
11663          break;
11664       }
11665       ret = ROK;
11666       break;
11667
11668    }while(true);
11669
11670    freeRrcDeliveryReport(f1apMsg);
11671    return ret;
11672 }
11673
11674 /*******************************************************************
11675  *
11676  * @brief Processes cells to be activated
11677  *
11678  * @details
11679  *
11680  *    Function : extractCellsToBeActivated
11681  *
11682  *    Functionality:
11683  *      - Processes cells to be activated list received in F1SetupRsp
11684  *
11685  * @params[in] void
11686  * @return ROK     - success
11687  *         RFAILED - failure
11688  *
11689  * ****************************************************************/
11690
11691 uint8_t extractCellsToBeActivated(Cells_to_be_Activated_List_t cellsToActivate)
11692 {
11693    uint8_t  ret = ROK;
11694    uint16_t idx, nci, pci = 0;
11695    Cells_to_be_Activated_List_Item_t cell;
11696
11697    for(idx=0; idx<cellsToActivate.list.count; idx++)
11698    {
11699       nci = 0;
11700       cell = cellsToActivate.list.array[idx]->value.choice.Cells_to_be_Activated_List_Item;
11701       bitStringToInt(&cell.nRCGI.nRCellIdentity, &nci);
11702
11703       if(cell.nRPCI)
11704       {
11705          pci = *cell.nRPCI;
11706       }
11707       ret = duProcCellsToBeActivated(cell.nRCGI.pLMN_Identity.buf, nci, pci);
11708    }
11709    return ret;
11710 }
11711 /******************************************************************
11712 *
11713 * @brief Processes F1 Setup Response allocated by aper_decoder
11714 *
11715 * @details
11716 *
11717 *    Function : freeF1SetupRsp
11718 *
11719 *    Functionality: free F1 Setup Response allocated by aper_decoder
11720 *
11721 * @params[in] F1SetupResponse_t *f1SetRspMsg
11722 * @return void
11723 *
11724 * ****************************************************************/
11725
11726 void freeAperDecodeF1SetupRsp(F1SetupResponse_t *f1SetRspMsg)
11727 {
11728    uint8_t ieIdx =0;
11729    uint8_t arrIdx =0;
11730    Cells_to_be_Activated_List_t *cellToActivate =NULLP;
11731    RRC_Version_t      *rrcVer =NULLP;
11732
11733    if(f1SetRspMsg->protocolIEs.list.array)
11734    {
11735       for(ieIdx=0; ieIdx<f1SetRspMsg->protocolIEs.list.count; ieIdx++)
11736       {
11737          if(f1SetRspMsg->protocolIEs.list.array[ieIdx])
11738          {
11739             switch(f1SetRspMsg->protocolIEs.list.array[ieIdx]->id)
11740             {
11741                case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11742                   {
11743                      cellToActivate =
11744                         &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.Cells_to_be_Activated_List;
11745                      if(cellToActivate->list.array)
11746                      {
11747                         for(arrIdx=0; arrIdx<cellToActivate->list.count ; arrIdx++)
11748                         {
11749                            if(cellToActivate->list.array[arrIdx])
11750                            {
11751
11752                               if(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.\
11753                               pLMN_Identity.buf)
11754                               {
11755                                  if(cellToActivate->list.array[0]->value.choice.\
11756                                        Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf)
11757                                  {
11758                                     free(cellToActivate->list.array[0]->value.choice.\
11759                                           Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf);
11760                                  }
11761
11762                                  free(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
11763                                        nRCGI.pLMN_Identity.buf);
11764                               }
11765                               free(cellToActivate->list.array[arrIdx]);
11766                            }
11767                         }
11768                         free(cellToActivate->list.array);
11769                      }
11770                      break;
11771                   }
11772                case ProtocolIE_ID_id_TransactionID:
11773                   {
11774                      break;
11775                   }
11776                case ProtocolIE_ID_id_gNB_CU_Name:
11777                   {
11778                      free(f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_Name.buf);
11779                      break;
11780                   }
11781                case ProtocolIE_ID_id_GNB_CU_RRC_Version:
11782                   {
11783                      rrcVer = &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
11784                      if(rrcVer->latest_RRC_Version.buf)
11785                      {
11786                         if(rrcVer->iE_Extensions)
11787                         {
11788                            if(rrcVer->iE_Extensions->list.array)
11789                            {
11790                               if(rrcVer->iE_Extensions->list.array[0])
11791                               {
11792                                  if(rrcVer->iE_Extensions->list.\
11793                                        array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf)
11794                                  {
11795                                     free(rrcVer->iE_Extensions->list.\
11796                                           array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf);
11797                                  }
11798                                  free(rrcVer->iE_Extensions->list.array[0]);
11799                               }
11800                               free(rrcVer->iE_Extensions->list.array);
11801                            }
11802                            free(rrcVer->iE_Extensions);
11803                         }
11804                         free(rrcVer->latest_RRC_Version.buf);
11805                      }
11806                      break;
11807
11808                   }
11809                default:
11810                   {
11811                      DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
11812                            f1SetRspMsg->protocolIEs.list.array[ieIdx]->id);
11813                   }
11814             }
11815             free(f1SetRspMsg->protocolIEs.list.array[ieIdx]);
11816          }
11817       }
11818       free(f1SetRspMsg->protocolIEs.list.array);
11819    }
11820 }
11821 /******************************************************************
11822  *
11823  * @brief Processes F1 Setup Response sent by CU
11824  *
11825  * @details
11826  *
11827  *    Function : procF1SetupRsp
11828  *
11829  *    Functionality: Processes F1 Setup Response sent by CU
11830  *
11831  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11832  * @return ROK     - success
11833  *         RFAILED - failure
11834  *
11835  * ****************************************************************/
11836 uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg)
11837 {
11838    uint8_t ret = ROK;
11839    uint16_t idx =0;
11840    F1SetupResponse_t *f1SetRspMsg = NULLP;
11841    GNB_CU_Name_t     *cuName = NULLP;
11842    F1SetupRsp  f1SetRspDb;
11843    RRC_Version_t      *rrcVer =NULLP;
11844
11845    memset(&f1SetRspDb, 0, sizeof(F1SetupRsp));
11846
11847    DU_LOG("\nINFO   -->  F1AP : F1 Setup Response received");
11848    f1SetRspMsg = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
11849
11850    for(idx=0; idx<f1SetRspMsg->protocolIEs.list.count; idx++)
11851    {
11852       switch(f1SetRspMsg->protocolIEs.list.array[idx]->id)
11853       {
11854          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11855             {
11856                extractCellsToBeActivated(f1SetRspMsg->protocolIEs.list.array[idx]->\
11857                      value.choice.Cells_to_be_Activated_List);
11858                break;
11859             }
11860          case ProtocolIE_ID_id_TransactionID:
11861             {
11862                f1SetRspDb.transId = f1SetRspMsg->protocolIEs.list.array[idx]->\
11863                                     value.choice.TransactionID;
11864                break;
11865             }
11866          case ProtocolIE_ID_id_gNB_CU_Name:
11867             {
11868                cuName = &f1SetRspMsg->protocolIEs.list.array[idx]->\
11869                         value.choice.GNB_CU_Name;
11870                strcpy(f1SetRspDb.cuName, (const char*)cuName->buf);
11871                break;
11872             }
11873          case ProtocolIE_ID_id_GNB_CU_RRC_Version:
11874             {
11875                rrcVer = &f1SetRspMsg->protocolIEs.list.array[idx]->value.choice.RRC_Version;
11876                strcpy(f1SetRspDb.rrcVersion.rrcVer,
11877                      (const char*)rrcVer->latest_RRC_Version.buf);
11878                break;
11879             }
11880          default:
11881             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
11882                   f1SetRspMsg->protocolIEs.list.array[idx]->id);
11883       }
11884       duProcF1SetupRsp();
11885    }
11886
11887    freeAperDecodeF1SetupRsp(f1SetRspMsg);
11888    return ret;
11889 }
11890 /*******************************************************************
11891 *
11892 * @brief free GNB DU config update ack
11893 *
11894 * @details
11895 *
11896 *    Function : freeAperDecodeGnbDuAck
11897 *
11898 *    Functionality: Processes GNB DU config update ack And
11899 *                     added free part for the memory allocated by aper_decoder
11900 *
11901 * @params[in] F1AP_PDU_t ASN decoded F1AP message
11902 * @return ROK     - success
11903 *         RFAILED - failure
11904 *
11905 * ****************************************************************/
11906
11907 void freeAperDecodeGnbDuAck(GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck)
11908 {
11909    uint8_t ieIdx = 0;
11910
11911    if(gnbDuAck->protocolIEs.list.array)
11912    {
11913       for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
11914       {
11915          if(gnbDuAck->protocolIEs.list.array[ieIdx])
11916          {
11917             free(gnbDuAck->protocolIEs.list.array[ieIdx]);
11918          }
11919       }
11920       free(gnbDuAck->protocolIEs.list.array);
11921    }
11922 }
11923
11924 /*******************************************************************
11925 *
11926 * @brief Building  result of gnb-du config update ack output
11927 *
11928 * @details
11929 *
11930 *    Function : duProcGnbDuCfgUpdAckMsg
11931 *
11932 *    Functionality:
11933 *        Building output of gnb-du config update ack
11934 *
11935 * @params[in] transId
11936 * @return void
11937 *
11938 * ****************************************************************/
11939
11940 uint8_t duProcGnbDuCfgUpdAckMsg(uint8_t transId)
11941 {
11942    uint8_t  ieIdx=0, arrIdx=0,ret=ROK;
11943    uint8_t  ueId =0 , ueIdx =0;
11944    uint16_t cellId =0, cellIdx =0, crnti=0;
11945    CmLList *f1apPduNode = NULLP;
11946    ReservedF1apPduInfo *f1apPduInfo =NULLP;
11947    F1AP_PDU_t *f1apMsgPdu = NULLP;
11948    GNBDUConfigurationUpdate_t *gnbDuConfigUpdate = NULLP;
11949    BIT_STRING_t *cellIdentity=NULLP;
11950    struct Served_Cells_To_Delete_ItemIEs *deleteItemIe=NULLP;
11951    Served_Cells_To_Delete_List_t *cellsToDelete=NULLP;
11952    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
11953
11954    DU_LOG("\nINFO   -->  DU APP: GNB-DU config update Ack received ");
11955    f1apPduNode = searchFromReservedF1apPduList(transId);
11956    f1apPduInfo = (ReservedF1apPduInfo *)f1apPduNode->node;
11957    f1apMsgPdu = (F1AP_PDU_t *)f1apPduInfo->f1apMsg;
11958
11959    if(f1apMsgPdu)
11960    {
11961       if(f1apMsgPdu->choice.initiatingMessage)
11962       {
11963          gnbDuConfigUpdate = &f1apMsgPdu->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
11964          for(ieIdx=0; ieIdx < gnbDuConfigUpdate->protocolIEs.list.count; ieIdx++)
11965          {
11966             switch(gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->id)
11967             {
11968                case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
11969                   {
11970                      cellsToDelete = &gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
11971                                      Served_Cells_To_Delete_List;
11972                      if(cellsToDelete->list.array)
11973                      {
11974                         if(cellsToDelete->list.array[arrIdx])
11975                         {
11976                            deleteItemIe = (Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx];
11977                            deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
11978                            if(deleteItem->oldNRCGI.nRCellIdentity.buf)
11979                            {
11980                               cellIdentity = &deleteItem->oldNRCGI.nRCellIdentity;
11981                               bitStringToInt(cellIdentity, &cellId);
11982                            }
11983                         }
11984                      }
11985
11986                      GET_CELL_IDX(cellId, cellIdx);
11987                      if(duCb.actvCellLst[cellIdx] != NULLP)
11988                      {
11989                         if(duCb.actvCellLst[cellIdx]->numActvUes == 0)
11990                         {
11991                            duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
11992                            ret = duSendCellDeletReq(cellId);
11993                            if(ret == RFAILED)
11994                            {
11995                               DU_LOG("ERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to send cell delete\
11996                               request for cellId[%d]", cellId);
11997                            }
11998                         }
11999                         else
12000                         {
12001                            for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
12002                            {
12003                               crnti = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].crnti;
12004                               GET_UE_IDX(crnti,ueId);
12005                               ret = BuildAndSendUeContextReleaseReq(cellId, ueId);
12006                               if(ret == RFAILED)
12007                               {
12008                                  DU_LOG("ERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to build and send UE delete\
12009                                  request for cellId[%d]", cellId);
12010                               }
12011                            }
12012                         }
12013                      }
12014                      else
12015                      {
12016                         DU_LOG("ERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): CellId [%d] not found", cellId);
12017                         ret = RFAILED;
12018                      }
12019                      break;
12020                   }
12021
12022                default:
12023                   break;
12024             }
12025          }
12026       }
12027    }
12028
12029    FreeDUConfigUpdate(f1apMsgPdu);
12030    deleteFromReservedF1apPduList(f1apPduNode);
12031    return ret;
12032 }
12033
12034 /*******************************************************************
12035 *
12036 * @brief Processes GNB DU config update ack
12037 *
12038 * @details
12039 *
12040 *    Function : procF1GNBDUCfgUpdAck
12041 *
12042 *    Functionality: added free part for the memory allocated by aper_decoder
12043 *
12044 * @params[in] F1AP_PDU_t *f1apMsg
12045 * @return void
12046 *
12047 * ****************************************************************/
12048 uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
12049 {
12050    uint8_t ieIdx=0,transId=0;
12051    GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
12052
12053    DU_LOG("\nINFO   -->  F1AP : GNB-DU config update acknowledgment");
12054    gnbDuAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
12055
12056    for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
12057    {
12058       switch(gnbDuAck->protocolIEs.list.array[ieIdx]->id)
12059       {
12060          case ProtocolIE_ID_id_TransactionID:
12061             {
12062                transId = gnbDuAck->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
12063                break;
12064             }
12065          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
12066             {
12067                break;
12068             }
12069          default :
12070             {
12071                DU_LOG("\nERROR  -->  F1AP: procF1GNBDUCfgUpdAck(): Invalid IE Received: %ld", \
12072                      gnbDuAck->protocolIEs.list.array[ieIdx]->id);
12073                break;
12074             }
12075       }
12076    }
12077
12078    duProcGnbDuCfgUpdAckMsg(transId);
12079
12080 #if 0
12081    /* presently we are not supporting F1 Reset from DU to CU , we are only
12082     * supporting F1 Reset from CU to DU */
12083
12084    if(BuildAndSendF1ResetReq() != ROK)
12085    {
12086       return RFAILED;
12087    }
12088 #endif
12089
12090    freeAperDecodeGnbDuAck(gnbDuAck);
12091    return ROK;
12092 }
12093 /******************************************************************
12094 *
12095 * @brief free DL RRC Message Transfer allocated by aper_decoder
12096 *
12097 * @details
12098 *
12099 *    Function : freeAperDecodef1DlRrcMsg
12100 *
12101 *    Functionality: free DL RRC Message Transfer allocated by aper_decoder
12102 *
12103 * @params[in] DLRRCMessageTransfer_t *f1DlRrcMsg
12104 * @return ROK     - success
12105 *         RFAILED - failure
12106 *
12107 * ****************************************************************/
12108
12109 void freeAperDecodef1DlRrcMsg(DLRRCMessageTransfer_t *f1DlRrcMsg)
12110 {
12111    uint8_t ieIdx =0;
12112    RRCContainer_t *rrcContainer = NULLP;
12113
12114    if(f1DlRrcMsg->protocolIEs.list.array)
12115    {
12116       for(ieIdx=0; ieIdx<f1DlRrcMsg->protocolIEs.list.count; ieIdx++)
12117       {
12118          if(f1DlRrcMsg->protocolIEs.list.array[ieIdx])
12119          {
12120             switch(f1DlRrcMsg->protocolIEs.list.array[ieIdx]->id)
12121             {
12122                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12123                   break;
12124                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12125                   break;
12126                case ProtocolIE_ID_id_SRBID:
12127                   break;
12128                case ProtocolIE_ID_id_RRCContainer:
12129                   {
12130                      rrcContainer =&f1DlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
12131                      free(rrcContainer->buf);
12132                   }
12133                case ProtocolIE_ID_id_ExecuteDuplication:
12134                   break;
12135                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
12136                   break;
12137                   break;
12138             }
12139             free(f1DlRrcMsg->protocolIEs.list.array[ieIdx]);
12140          }
12141       }
12142       free(f1DlRrcMsg->protocolIEs.list.array);
12143    }
12144 }
12145 /******************************************************************
12146  *
12147  * @brief Processes DL RRC Message Transfer  sent by CU
12148  *
12149  * @details
12150  *
12151  *    Function : procF1DlRrcMsgTrans
12152  *
12153  *    Functionality: Processes DL RRC Message Transfer sent by CU
12154  *
12155  * @params[in] F1AP_PDU_t ASN decoded F1AP message
12156  * @return ROK     - success
12157  *         RFAILED - failure
12158  *
12159  * ****************************************************************/
12160 uint8_t procF1DlRrcMsgTrans(F1AP_PDU_t *f1apMsg)
12161 {
12162    uint8_t  idx, ret;
12163    DLRRCMessageTransfer_t *f1DlRrcMsg = NULLP;
12164    F1DlRrcMsg dlMsg;
12165    memset(&dlMsg, 0, sizeof(F1DlRrcMsg));
12166
12167    DU_LOG("\nINFO   -->  DU_APP : DL RRC message transfer Recevied");
12168    f1DlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
12169
12170    ret = ROK;
12171
12172    for(idx=0; idx<f1DlRrcMsg->protocolIEs.list.count; idx++)
12173    {
12174       switch(f1DlRrcMsg->protocolIEs.list.array[idx]->id)
12175       {
12176          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12177             {
12178                dlMsg.gnbCuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
12179                break;
12180             }
12181          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12182             {
12183                dlMsg.gnbDuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
12184                break;
12185             }
12186          case ProtocolIE_ID_id_SRBID:
12187             {
12188                dlMsg.srbId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
12189                break;
12190             }
12191          case ProtocolIE_ID_id_ExecuteDuplication:
12192             dlMsg.execDup = true;
12193             break;
12194
12195          case ProtocolIE_ID_id_RRCContainer:
12196             {
12197                if(f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0)
12198                {
12199                   dlMsg.rrcMsgSize = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
12200                   DU_ALLOC_SHRABL_BUF(dlMsg.rrcMsgPdu, dlMsg.rrcMsgSize);
12201                   if(dlMsg.rrcMsgPdu)
12202                   {
12203                      memcpy(dlMsg.rrcMsgPdu, f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
12204                         dlMsg.rrcMsgSize);
12205                   }
12206                   else
12207                   {
12208                      DU_LOG("\nERROR  -->  DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
12209                      return RFAILED;
12210                   }
12211                }
12212                else
12213                {
12214                   DU_LOG("\nERROR  -->  DU_APP : RRC Container Size is invalid:%ld",\
12215                   f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
12216                   return RFAILED;
12217                }
12218                break;
12219             }
12220          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
12221             {
12222                dlMsg.deliveryStatRpt = true;
12223                break;
12224             }
12225          default:
12226             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
12227                   f1DlRrcMsg->protocolIEs.list.array[idx]->id);
12228       }
12229    }
12230
12231    ret = duProcDlRrcMsg(&dlMsg);
12232
12233    freeAperDecodef1DlRrcMsg(f1DlRrcMsg);
12234    return ret;
12235 }
12236 /*******************************************************************
12237  *
12238 * @brief Builds the DRB to be Setup Mod list
12239 *
12240 * @details
12241 *
12242 *    Function :
12243 *
12244 *    Functionality: Constructs the DRB to be Setup Mod list
12245 *
12246 * @params[in] DRBs_SetupMod_List_t *drbSet
12247 *
12248 * @return ROK     - success
12249 *         RFAILED - failure
12250 *
12251 * ****************************************************************/
12252
12253 uint8_t BuildDrbSetupModList(DRBs_SetupMod_List_t *drbSet , DuUeCfg *ueCfg)
12254 {
12255    uint8_t arrIdx =0;
12256    uint8_t drbCnt =0;
12257    struct DRBs_SetupMod_ItemIEs *drbItemIe;
12258
12259    drbCnt = 1;
12260    drbSet->list.count = drbCnt;
12261    drbSet->list.size = drbCnt * sizeof(DRBs_SetupMod_ItemIEs_t *);
12262    DU_ALLOC(drbSet->list.array, drbSet->list.size);
12263    if(drbSet->list.array == NULLP)
12264    {
12265       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
12266       return  RFAILED;
12267    }
12268    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
12269    {
12270       DU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
12271       if(drbSet->list.array[arrIdx] == NULLP)
12272       {
12273               DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
12274               return  RFAILED;
12275       }
12276
12277       drbItemIe = (struct DRBs_SetupMod_ItemIEs *)drbSet->list.array[arrIdx];
12278       drbItemIe->id = ProtocolIE_ID_id_DRBs_SetupMod_Item;
12279       drbItemIe->criticality = Criticality_reject;
12280       drbItemIe->value.present = DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item;
12281       drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
12282       if(fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List,\
12283       &ueCfg->upTnlInfo[arrIdx])!= ROK)
12284       {
12285          DU_LOG("\nERROR  -->  F1AP : Failed to fill DlTnl SetupList in BuildDrbToBeSetupModList");
12286          return RFAILED;
12287       }
12288
12289    }
12290
12291    return ROK;
12292 }
12293 /*******************************************************************
12294 * @brief Free the memory allocated for DRB setup List
12295 *
12296 * @details
12297 *
12298 *    Function : FreeDrbSetupModList
12299 *
12300 *    Functionality:
12301 *       Free the memory allocated for DRB setup list
12302 *
12303 * @params[in] DRBs_Setup_List_t *
12304 * @return void
12305 *
12306 * ****************************************************************/
12307 void FreeDrbSetupModList(DRBs_SetupMod_List_t *drbSetupList)
12308 {
12309    uint8_t arrIdx = 0;
12310    DRBs_SetupMod_ItemIEs_t *drbItemIe = NULLP;
12311
12312    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
12313    {
12314       drbItemIe = ((DRBs_SetupMod_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
12315       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
12316       DU_FREE(drbSetupList->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
12317    }
12318    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
12319 }
12320 /*******************************************************************
12321 * @brief Free the memory allocated for UE Context Mod Response
12322 *
12323 * @details
12324 *
12325 *    Function : FreeUeContextModResp
12326 *
12327 *    Functionality:
12328 *       Free the memory allocated for UE Context Mod Response
12329 *
12330 * @params[in] F1AP_PDU_t *f1apMsg
12331 * @return void
12332 *
12333 * ****************************************************************/
12334
12335 void FreeUeContextModResp(F1AP_PDU_t *f1apMsg)
12336 {
12337    uint8_t ieIdx;
12338    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
12339    if(f1apMsg)
12340    {
12341       if(f1apMsg->choice.successfulOutcome)
12342       {
12343          ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
12344          if(ueContextModifyRes->protocolIEs.list.array)
12345          {
12346             for(ieIdx=0 ; ieIdx<ueContextModifyRes->protocolIEs.list.count; ieIdx++)
12347             {
12348                if(ueContextModifyRes->protocolIEs.list.array[ieIdx])
12349                {
12350                   switch(ueContextModifyRes->protocolIEs.list.array[ieIdx]->id)
12351                   {
12352                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12353                         break;
12354                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12355                         break;
12356                      case ProtocolIE_ID_id_DRBs_SetupMod_List:
12357                         {
12358                             FreeDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
12359                             value.choice.DRBs_SetupMod_List));
12360                             break;
12361                         }
12362                   }
12363                   DU_FREE(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
12364                }
12365
12366             }
12367             DU_FREE(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
12368          }
12369          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12370       }
12371       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12372    }
12373 }
12374
12375 /*****************************************************************i
12376 *
12377 * @brief Creating the ue context modifcation response and sending
12378 *
12379 * @details
12380 *
12381 *    Function : BuildAndSendUeContextModRsp
12382 *
12383 *    Functionality:
12384 *         - Creating the ue context modifcation response
12385 *
12386 * @params[in] uint8_t cellId,uint8_t ueIdx
12387 * @return ROK     - success
12388 *         RFAILED - failure
12389 *
12390 * ****************************************************************/
12391 uint8_t BuildAndSendUeContextModRsp(uint8_t cellId,uint8_t ueIdx)
12392 {
12393    uint8_t   ieIdx = 0;
12394    uint8_t   cellIdx =0;
12395    uint8_t   elementCnt = 0;
12396    uint8_t   ret = RFAILED;
12397    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
12398    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
12399    F1AP_PDU_t *f1apMsg = NULLP;
12400    asn_enc_rval_t         encRetVal;
12401    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
12402    DuUeCb                   *ueCb = NULLP;
12403
12404    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification response\n");
12405
12406    while(1)
12407    {
12408       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12409       if(f1apMsg == NULLP)
12410       {
12411          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
12412          break;
12413       }
12414
12415       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
12416
12417       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12418       if(f1apMsg->choice.successfulOutcome == NULLP)
12419       {
12420          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
12421          break;
12422       }
12423       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextModification;
12424       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
12425       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_UEContextModificationResponse;
12426
12427       ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
12428
12429       elementCnt = 3;
12430       ueContextModifyRes->protocolIEs.list.count = elementCnt;
12431       ueContextModifyRes->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationResponse_t*);
12432
12433       /* Initialize the UE context modification members */
12434       DU_ALLOC(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
12435       if(ueContextModifyRes->protocolIEs.list.array == NULLP)
12436       {
12437          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
12438          break;
12439       }
12440
12441       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
12442       {
12443          DU_ALLOC(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
12444          if(ueContextModifyRes->protocolIEs.list.array[ieIdx] == NULLP)
12445          {
12446             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
12447             break;
12448          }
12449       }
12450
12451       /* Fetching Ue Cb Info*/
12452       GET_CELL_IDX(cellId, cellIdx);
12453       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
12454       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
12455       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
12456
12457       ieIdx=0;
12458       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
12459       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12460       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
12461       UEContextModificationResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
12462       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
12463
12464       ieIdx++;
12465       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
12466       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12467       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present=\
12468       UEContextModificationResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
12469       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
12470
12471       ieIdx++;
12472       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_SetupMod_List;
12473       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12474       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
12475       UEContextModificationResponseIEs__value_PR_DRBs_SetupMod_List;
12476       if(ueCb->f1UeDb)
12477       {
12478          ret = BuildDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
12479                   value.choice.DRBs_SetupMod_List) , &ueCb->f1UeDb->duUeCfg);
12480          if(ret != ROK)
12481          {
12482             DU_LOG( "\nERROR  -->  F1AP : Failed to build drb setupmod List ");
12483             break;
12484          }
12485          freeF1UeDb(ueCb->f1UeDb);
12486          ueCb->f1UeDb = NULLP;
12487       }
12488       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12489
12490       /* Encode the F1SetupRequest type as APER */
12491       memset(encBuf, 0, ENC_BUF_MAX_LEN);
12492       encBufSize = 0;
12493       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,encBuf);
12494
12495       /* Encode results */
12496       if(encRetVal.encoded == ENCODE_FAIL)
12497       {
12498          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
12499                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12500          ret = RFAILED;
12501          break;
12502       }
12503       else
12504       {
12505          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Modification Response\n");
12506          for(int i=0; i< encBufSize; i++)
12507          {
12508             printf("%x",encBuf[i]);
12509          }
12510       }
12511
12512       /* Sending  msg  */
12513       if(sendF1APMsg() != ROK)
12514       {
12515          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Res Failed");
12516          ret = RFAILED;
12517          break;
12518       }
12519       break;
12520    }
12521    FreeUeContextModResp(f1apMsg);
12522    return ret;
12523 }
12524 /*******************************************************************
12525  *
12526  * @brief Deallocating the memory allocated by the aper decoder
12527  *          for QOSInfo
12528  *
12529  * @details
12530  *
12531  *    Function : freeAperDecodeQosInfo
12532  *
12533  *    Functionality:  Deallocating the memory allocated for QOSInfo
12534  *
12535  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
12536  *
12537  * @return void
12538  *
12539  * ****************************************************************/
12540
12541 void freeAperDecodeQosInfo(QoSFlowLevelQoSParameters_t *drbQos)
12542 {
12543    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
12544    {
12545       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
12546       {
12547          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
12548          {
12549             free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
12550          }
12551          free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
12552       }
12553       free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI);
12554    }
12555 }
12556 /*******************************************************************
12557  *
12558  * @brief Deallocating the memory allocated by the aper decoder
12559  *          for UlTnlInfoforDrb
12560  *
12561  * @details
12562  *
12563  *    Function : freeAperDecodeUlTnlInfoforDrbSetupMod
12564  *
12565  *    Functionality:  Deallocating memory allocated for UlTnlInfoforDrb
12566  *
12567  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
12568  *
12569  * @return void
12570  *
12571  * ****************************************************************/
12572 void freeAperDecodeUlTnlInfoforDrbSetupMod(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
12573 {
12574    uint8_t arrIdx =0;
12575
12576    if(ulInfo->list.array)
12577    {
12578       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
12579       {
12580          if(ulInfo->list.array[arrIdx])
12581          {
12582             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
12583             {
12584                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
12585                {
12586                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
12587                   {
12588                      free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12589                            gTP_TEID.buf);
12590                   }
12591                   free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12592                         transportLayerAddress.buf);
12593                }
12594                free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel);
12595             }
12596             free(ulInfo->list.array[arrIdx]);
12597          }
12598       }
12599       free(ulInfo->list.array);
12600    }
12601 }
12602 /*******************************************************************
12603  *
12604  * @brief Deallocating the memory allocated by the aper decoder
12605  *          for DrbSetupModItem
12606  *
12607  * @details
12608  *
12609  *    Function : freeAperDecodeDrbSetupModItem
12610  *
12611  *    Functionality:  Deallocating memory allocated for DrbSetupModItem
12612  *
12613  * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
12614  *
12615  * @return void
12616  *
12617  * ****************************************************************/
12618
12619 void freeAperDecodeDrbSetupModItem(DRBs_ToBeSetupMod_Item_t *drbItem)
12620 {
12621    uint8_t arrIdx =0;
12622    SNSSAI_t *snssai =NULLP;
12623    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
12624
12625    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
12626    switch(drbItem->qoSInformation.present)
12627    {
12628       case QoSInformation_PR_NOTHING:
12629          break;
12630       case QoSInformation_PR_eUTRANQoS:
12631          {
12632             if(drbItem->qoSInformation.choice.eUTRANQoS)
12633             {
12634                free(drbItem->qoSInformation.choice.eUTRANQoS);
12635             }
12636             break;
12637          }
12638       case QoSInformation_PR_choice_extension:
12639          {
12640             if(drbItem->qoSInformation.choice.choice_extension)
12641             {
12642                freeAperDecodeQosInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.\
12643                      DRB_Information.dRB_QoS);
12644                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
12645                if(snssai->sST.buf)
12646                {
12647                   free(snssai->sST.buf);
12648                }
12649                if(snssai->sD)
12650                {
12651                   if(snssai->sD->buf)
12652                   {
12653                      free(snssai->sD->buf);
12654                   }
12655                   free(snssai->sD);
12656                }
12657
12658                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.\
12659                          DRB_Information.flows_Mapped_To_DRB_List;
12660                if(flowMap->list.array)
12661                {
12662                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
12663                   {
12664                      if(flowMap->list.array[arrIdx] )
12665                      {
12666                         freeAperDecodeQosInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
12667                         free(flowMap->list.array[arrIdx]);
12668                      }
12669                   }
12670                   free(flowMap->list.array);
12671                }
12672
12673                free(drbItem->qoSInformation.choice.choice_extension);
12674             }
12675             break;
12676          }
12677
12678    }
12679    freeAperDecodeUlTnlInfoforDrbSetupMod(&drbItem->uLUPTNLInformation_ToBeSetup_List);
12680    if(drbItem->uLConfiguration)
12681    {
12682       free(drbItem->uLConfiguration);
12683    }
12684 }
12685
12686 /*******************************************************************
12687  *
12688  * @brief Deallocating the memory allocated by the aper decoder
12689  *          for DrbToBeSetupModList
12690  *
12691  * @details
12692  *
12693  *    Function : freeAperDecodeDrbToBeSetupModList
12694  *
12695  *    Functionality:  Deallocating memory allocated for DrbToBeSetupModList
12696  *
12697  * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
12698  *
12699  * @return void
12700  *
12701  * ****************************************************************/
12702
12703 void freeAperDecodeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
12704 {
12705    uint8_t arrIdx =0;
12706    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
12707
12708    if(drbSet->list.array)
12709    {
12710       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
12711       {
12712          if(drbSet->list.array[arrIdx] != NULLP)
12713          {
12714             if(arrIdx == 0)
12715             {
12716                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
12717                freeAperDecodeDrbSetupModItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
12718             }
12719             free(drbSet->list.array[arrIdx]);
12720          }
12721       }
12722       free(drbSet->list.array);
12723    }
12724
12725 }
12726 /*******************************************************************
12727  *
12728  * @brief Deallocating the memory allocated by the aper decoder
12729  *          for UeContextModificationReqMsg
12730  *
12731  * @details
12732  *
12733  *    Function : freeAperDecodeUeContextModificationReqMsg
12734  *
12735  *    Functionality:  Deallocating memory allocated for
12736  *                  UeContextModificationReqMsg
12737  *
12738  * @params[in] UEContextModificationRequest_t *UeContextModifyReq
12739  *
12740  * @return void
12741  *
12742  * ****************************************************************/
12743 void freeAperDecodeUeContextModificationReqMsg(UEContextModificationRequest_t *UeContextModifyReq )
12744 {
12745    uint8_t arrIdx, ieId;
12746
12747    if(UeContextModifyReq->protocolIEs.list.array)
12748    {
12749       for( arrIdx = 0 ; arrIdx<UeContextModifyReq->protocolIEs.list.count ; arrIdx++)
12750       {
12751          if(UeContextModifyReq->protocolIEs.list.array[arrIdx])
12752          {
12753             ieId = UeContextModifyReq->protocolIEs.list.array[arrIdx]->id;
12754             switch(ieId)
12755             {
12756                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12757                   break;
12758                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12759                   break;
12760                case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
12761                   {
12762                      freeAperDecodeDrbToBeSetupModList(&UeContextModifyReq->protocolIEs.list.array[arrIdx]->\
12763                            value.choice.DRBs_ToBeSetupMod_List);
12764                      break;
12765                   }
12766             }
12767             free(UeContextModifyReq->protocolIEs.list.array[arrIdx]);
12768          }
12769       }
12770       free(UeContextModifyReq->protocolIEs.list.array);
12771    }
12772 }
12773 /*******************************************************************
12774  *
12775  * @brief processing the F1 UeContextModificationReq
12776  *
12777  * @details
12778  *
12779  *    Function : procF1UeContextModificationReq
12780  *
12781  *    Functionality:  processing the F1 UeContextModificationReq
12782  *
12783  * @params[in] F1AP_PDU_t *f1apMsg
12784  *
12785  * @return
12786  * ****************************************************************/
12787 uint8_t procF1UeContextModificationReq(F1AP_PDU_t *f1apMsg)
12788 {
12789    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
12790    uint8_t  ret = ROK, ieIdx = 0, cellIdx=0, ueIdx=0;
12791    DuUeCb   *duUeCb = NULLP;
12792    DRBs_ToBeSetupMod_List_t *drbSetupModCfg;
12793    uint32_t gnbCuUeF1apId, gnbDuUeF1apId;
12794
12795    ueContextModifyReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
12796    for(ieIdx=0; (ieIdx < ueContextModifyReq->protocolIEs.list.count && ret == ROK); ieIdx++)
12797    {
12798       switch(ueContextModifyReq->protocolIEs.list.array[ieIdx]->id)
12799       {
12800          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12801             {
12802                gnbCuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
12803                break;
12804             }
12805          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12806             {
12807                gnbDuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
12808                break;
12809             }
12810          case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
12811             {
12812                for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
12813                {
12814                   for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
12815                   {
12816                      if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
12817                            (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
12818                      {
12819
12820                         duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
12821                            DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
12822                            if(duUeCb->f1UeDb)
12823                            {
12824                               duUeCb->f1UeDb->actionType = UE_CTXT_MOD;
12825                               drbSetupModCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
12826                               choice.DRBs_ToBeSetupMod_List;
12827                               if(extractDrbListToSetup(NULL, drbSetupModCfg ,drbSetupModCfg->list.count, \
12828                               &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap))
12829                               {
12830                                  DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetup()");
12831                                  ret = RFAILED;
12832                               }
12833                            }
12834                         break;
12835                      }
12836                   }
12837                   if(ueIdx >= duCb.actvCellLst[cellIdx]->numActvUes)
12838                   {
12839                      DU_LOG("\nERROR  -->  DU APP : wrong values of gnbCuUeF1apId and gnbDuUeF1apId ");
12840                      ret = RFAILED;
12841                   }
12842                }
12843                break;
12844             }
12845       }
12846    }
12847    if(ret != RFAILED)
12848    {
12849       ret = duProcUeContextModReq(duUeCb);
12850    }
12851    freeAperDecodeUeContextModificationReqMsg(ueContextModifyReq);
12852    return ret;
12853 }
12854 /*****************************************************************i
12855 *
12856 * @brief Free memory allocated for UE Context Release Request
12857 *
12858 * @details
12859 *
12860 *    Function : FreeUeContextReleaseReq
12861 *
12862 *    Functionality:
12863 *         - Free memory allocated for UE Context Release Request
12864 *
12865 * @params[in] F1AP_PDU_t *f1apMsg
12866 * @return void
12867 *
12868 * *************************************************************/
12869 void FreeUeContextReleaseReq(F1AP_PDU_t *f1apMsg)
12870 {
12871    uint8_t ieIdx;
12872    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
12873
12874    if(f1apMsg)
12875    {
12876       if(f1apMsg->choice.initiatingMessage)
12877       {
12878          ueReleaseReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
12879          if(ueReleaseReq->protocolIEs.list.array)
12880          {
12881             for(ieIdx=0 ; ieIdx<ueReleaseReq->protocolIEs.list.count; ieIdx++)
12882             {
12883                DU_FREE(ueReleaseReq->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseRequest_t));
12884             }
12885             DU_FREE(ueReleaseReq->protocolIEs.list.array, ueReleaseReq->protocolIEs.list.size);
12886          }
12887          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
12888       }
12889       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12890    }
12891
12892 }
12893 /*****************************************************************i
12894 *
12895 * @brief Build and Send UE Context Release Request
12896 *
12897 * @details
12898 *
12899 *    Function : BuildAndSendUeContextReleaseReq
12900 *
12901 *    Functionality:
12902 *         - Build and Send UE Context Release Request
12903 *
12904 * @params[in]
12905 * @return ROK     - success
12906 *         RFAILED - failure
12907 *
12908 * *************************************************************/
12909 uint8_t BuildAndSendUeContextReleaseReq(uint16_t cellId, uint8_t ueIdx)
12910 {
12911    bool memAllocFail = false;
12912    uint8_t ieIdx =0;
12913    uint8_t ret = RFAILED;
12914    uint16_t cellIdx =0;
12915    uint16_t crnti = 0;
12916    uint8_t  elementCnt = 0;
12917    uint32_t  gnbCuUeF1apId =0;   /* gNB-CU UE F1AP Id */
12918    uint32_t  gnbDuUeF1apId =0;   /* gNB-DU UE F1AP Id */
12919    asn_enc_rval_t encRetVal;
12920    F1AP_PDU_t *f1apMsg = NULLP;
12921    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
12922
12923    DU_LOG("\nINFO  --> Building the UE Context Release Request");
12924    do
12925    {
12926       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12927       if(f1apMsg == NULLP)
12928       {
12929          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for f1apMsg");
12930          break;
12931       }
12932
12933       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
12934       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
12935       if(f1apMsg->choice.initiatingMessage == NULLP)
12936       {
12937          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for\
12938          initiatingMessage");
12939          break;
12940       }
12941       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextReleaseRequest;
12942       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
12943       f1apMsg->choice.initiatingMessage->value.present = \
12944       InitiatingMessage__value_PR_UEContextReleaseRequest;
12945
12946       ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
12947
12948       elementCnt = 2;
12949
12950       ueReleaseReq->protocolIEs.list.count = elementCnt;
12951       ueReleaseReq->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseRequest_t *);
12952
12953       /* Initialize the F1Setup members */
12954       DU_ALLOC(ueReleaseReq->protocolIEs.list.array,ueReleaseReq->protocolIEs.list.size);
12955       if(ueReleaseReq->protocolIEs.list.array == NULLP)
12956       {
12957          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE array");
12958          break;
12959       }
12960       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
12961       {
12962          DU_ALLOC(ueReleaseReq->protocolIEs.list.array[ieIdx],\
12963                sizeof(UEContextReleaseRequest_t));
12964          if(ueReleaseReq->protocolIEs.list.array[ieIdx] == NULLP)
12965          {
12966             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE elements");
12967             memAllocFail = true;
12968             break;
12969          }
12970       }
12971       if(memAllocFail == true)
12972          break;
12973
12974       /* Fetching Ue Cb Info*/
12975       GET_CELL_IDX(cellId, cellIdx);
12976       if(duCb.actvCellLst[cellIdx] == NULLP)
12977       {
12978          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): CellId[%d] does not exist", cellId);
12979          break;
12980       }
12981       else
12982       {
12983          GET_CRNTI(crnti, ueIdx);
12984          if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].crnti != crnti)
12985          {
12986             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): crnti[%d] does not exist", crnti);
12987             break;
12988          }
12989          gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
12990          gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
12991       }
12992
12993       ieIdx=0;
12994       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
12995       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
12996       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present = \
12997       UEContextReleaseRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
12998       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
12999
13000       ieIdx++;
13001       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
13002       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13003       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present =\
13004       UEContextReleaseRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
13005       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
13006
13007       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13008
13009       /* Encode the F1SetupRequest type as APER */
13010       memset(encBuf, 0, ENC_BUF_MAX_LEN);
13011       encBufSize = 0;
13012       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
13013       /* Encode results */
13014       if(encRetVal.encoded == ENCODE_FAIL)
13015       {
13016          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseRequest structure (at %s)\n",\
13017                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13018          break;
13019       }
13020       else
13021       {
13022          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseRequest\n");
13023          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
13024          {
13025             printf("%x",encBuf[ieIdx]);
13026          }
13027       }
13028
13029       /* Sending msg */
13030       if(sendF1APMsg() != ROK)
13031       {
13032          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Request failed");
13033          break;
13034       }
13035       ret = ROK;
13036       break;
13037    }while(true);
13038
13039    FreeUeContextReleaseReq(f1apMsg);
13040    return ret;
13041 }
13042 /*****************************************************************i
13043  *
13044  * @brief Free memory allocated for UE Context Release Complete
13045  *
13046  * @details
13047  *
13048  *    Function : FreeUeContextReleaseComplete
13049  *
13050  *    Functionality:
13051  *         - Free memory allocated for UE Context Release Complete
13052  *
13053  * @params[in] F1AP_PDU_t *f1apMsg
13054  * @return void
13055  *
13056  * *************************************************************/
13057 void FreeUeContextReleaseComplete(F1AP_PDU_t *f1apMsg)
13058 {
13059    uint8_t ieIdx;
13060    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
13061
13062    if(f1apMsg)
13063    {
13064       if(f1apMsg->choice.successfulOutcome)
13065       {
13066          ueReleaseComplete =&f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
13067          if(ueReleaseComplete->protocolIEs.list.array)
13068          {
13069             for(ieIdx=0 ; ieIdx<ueReleaseComplete->protocolIEs.list.count; ieIdx++)
13070             {
13071                DU_FREE(ueReleaseComplete->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseComplete_t));
13072             }
13073             DU_FREE(ueReleaseComplete->protocolIEs.list.array, ueReleaseComplete->protocolIEs.list.size);
13074          }
13075          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
13076       }
13077       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
13078    }
13079
13080 }
13081 /*****************************************************************i
13082  *
13083  * @brief Build and Send UE Context Release Complete
13084  *
13085  * @details
13086  *
13087  *    Function : BuildAndSendUeContextReleaseComplete
13088  *
13089  *    Functionality:
13090  *         - Build and Send UE Context Release Complete
13091  *
13092  * @params[in]  cellId,  gnbCuUeF1apId, gnbDuUeF1apId
13093  * @return ROK     - success
13094  *         RFAILED - failure
13095  *
13096  * *************************************************************/
13097 uint8_t BuildAndSendUeContextReleaseComplete(uint16_t cellId, uint32_t gnbCuUeF1apId, uint32_t gnbDuUeF1apId)
13098 {
13099    bool memAllocFail = false;
13100    uint8_t ieIdx =0, ret = RFAILED, elementCnt = 0;
13101    asn_enc_rval_t encRetVal;
13102    F1AP_PDU_t *f1apMsg = NULLP;
13103    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
13104
13105    DU_LOG("\nINFO  --> Building the UE Context Release Complete");
13106    do
13107    {
13108       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
13109       if(f1apMsg == NULLP)
13110       {
13111          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for f1apMsg");
13112          break;
13113       }
13114
13115       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
13116       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
13117       if(f1apMsg->choice.successfulOutcome == NULLP)
13118       {
13119          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for\
13120                successfulOutcome");
13121          break;
13122       }
13123       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextRelease;
13124       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
13125       f1apMsg->choice.successfulOutcome->value.present = \
13126       SuccessfulOutcome__value_PR_UEContextReleaseComplete;
13127
13128       ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
13129
13130       elementCnt = 2;
13131       ueReleaseComplete->protocolIEs.list.count = elementCnt;
13132       ueReleaseComplete->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseComplete_t *);
13133
13134       /* Initialize the UE Release Complete members */
13135       DU_ALLOC(ueReleaseComplete->protocolIEs.list.array,ueReleaseComplete->protocolIEs.list.size);
13136       if(ueReleaseComplete->protocolIEs.list.array == NULLP)
13137       {
13138          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE array");
13139          break;
13140       }
13141       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
13142       {
13143          DU_ALLOC(ueReleaseComplete->protocolIEs.list.array[ieIdx],\
13144                sizeof(UEContextReleaseComplete_t));
13145          if(ueReleaseComplete->protocolIEs.list.array[ieIdx] == NULLP)
13146          {
13147             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE\
13148             elements");
13149             memAllocFail = true;
13150             break;
13151          }
13152       }
13153       if(memAllocFail == true)
13154          break;
13155
13156
13157       ieIdx=0;
13158       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
13159       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13160       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present = \
13161       UEContextReleaseCompleteIEs__value_PR_GNB_CU_UE_F1AP_ID;
13162       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
13163
13164       ieIdx++;
13165       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
13166       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13167       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present =\
13168       UEContextReleaseCompleteIEs__value_PR_GNB_DU_UE_F1AP_ID;
13169       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
13170
13171       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13172
13173       /* Encode the F1SetupComplete type as APER */
13174       memset(encBuf, 0, ENC_BUF_MAX_LEN);
13175       encBufSize = 0;
13176       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
13177       /* Encode results */
13178       if(encRetVal.encoded == ENCODE_FAIL)
13179       {
13180          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseComplete structure (at %s)\n",\
13181                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13182          break;
13183       }
13184       else
13185       {
13186          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseComplete\n");
13187          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
13188          {
13189             printf("%x",encBuf[ieIdx]);
13190          }
13191       }
13192
13193       /* Sending msg */
13194       if(sendF1APMsg() != ROK)
13195       {
13196          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Complete failed");
13197          break;
13198       }
13199       ret = ROK;
13200       break;
13201    }while(true);
13202
13203    if(ret == ROK)
13204    {
13205       duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
13206       ret = duSendCellDeletReq(cellId);
13207       if(ret != ROK)
13208       {
13209          DU_LOG("\nERROR  -->  F1AP: BuildAndSendUeContextReleaseComplete(): Failed to process cell\
13210                Delete req for CellId");
13211       }
13212    }
13213    FreeUeContextReleaseComplete(f1apMsg);
13214    return ret;
13215
13216 }
13217
13218 /*******************************************************************
13219 *
13220 * @brief added free part for the memory allocated by aper_decoder
13221 *
13222 * @details
13223 *
13224 *    Function : freeAperDecodeUeContextReleaseCommand
13225 *
13226 *    Functionality: added free part for the memory allocated by aper_decoder
13227 *
13228 * @params[in] F1AP_PDU_t *f1apMsg
13229 * @return void
13230 *
13231 * ****************************************************************/
13232 void freeAperDecodeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
13233 {
13234    uint8_t ieIdx=0;
13235    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
13236
13237    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
13238
13239    if(ueContextReleaseCommand->protocolIEs.list.array)
13240    {
13241       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
13242       {
13243          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
13244          {
13245             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
13246             {
13247                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13248                   break;
13249                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13250                   break;
13251                case ProtocolIE_ID_id_Cause:
13252                   break;
13253                case ProtocolIE_ID_id_RRCContainer:
13254                {
13255                   if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
13256                   {
13257                      free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
13258                   }
13259                   break;
13260                }
13261                default :
13262                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
13263                        ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
13264                   break;
13265             }
13266          }
13267          free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]);
13268       }
13269       free(ueContextReleaseCommand->protocolIEs.list.array);
13270    }
13271 }
13272 /*******************************************************************
13273 *
13274 * @brief processing of UE Context Release Command
13275 *
13276 * @details
13277 *
13278 *    Function : procF1UeContextReleaseCommand
13279 *
13280 *    Functionality: processing of UE Context Release Command
13281 *
13282 * @params[in] F1AP_PDU_t *f1apMsg
13283 * @return void
13284 *
13285 * ****************************************************************/
13286 uint8_t procF1UeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
13287 {
13288    uint8_t  ieIdx=0, ret=ROK, ueIdx=0;
13289    uint16_t cellIdx =0;
13290    bool ueIdxFound;
13291    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0;
13292    DuUeCb   *duUeCb = NULLP;
13293    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
13294
13295    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
13296
13297    if(ueContextReleaseCommand->protocolIEs.list.array)
13298    {
13299       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
13300       {
13301          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
13302          {
13303             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
13304             {
13305                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13306                   {
13307                      gnbCuUeF1apId= ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13308                                     value.choice.GNB_CU_UE_F1AP_ID;
13309                      break;
13310                   }
13311
13312                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13313                   {
13314                      gnbDuUeF1apId = ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13315                                      value.choice.GNB_DU_UE_F1AP_ID;
13316                      break;
13317                   }
13318
13319                case ProtocolIE_ID_id_Cause:
13320                   {
13321                      break;
13322                   }
13323
13324                case ProtocolIE_ID_id_RRCContainer:
13325                   {
13326                      for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
13327                      {
13328                         for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
13329                         {
13330                            if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
13331                                  (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
13332                            {
13333                               duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
13334                               DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
13335                               if(duUeCb->f1UeDb)
13336                               {
13337                                  memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
13338                                  duUeCb->f1UeDb->actionType = UE_CTXT_RELEASE;
13339                                  duUeCb->f1UeDb->cellIdx = cellIdx;
13340                                  /* Filling Dl RRC Msg Info */
13341                                  DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
13342                                  if(!duUeCb->f1UeDb->dlRrcMsg)
13343                                  {
13344                                     DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
13345                                     Memory allocation failed ");
13346                                     ret = RFAILED;
13347                                  }
13348                                  else
13349                                  {
13350                                     duUeCb->f1UeDb->dlRrcMsgPres = true;
13351                                     memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
13352                                     ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
13353                                           &ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13354                                           value.choice.RRCContainer);
13355                                  }
13356
13357                               }
13358                               else
13359                               {
13360                                  DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
13361                                  Memory allocation failed ");
13362                                  ret = RFAILED;
13363
13364                               }
13365
13366                               ueIdxFound = true;
13367                               break;
13368                            }
13369                         }
13370                         if(ueIdxFound == true)
13371                         {
13372                            break;
13373                         }
13374                      }
13375                      if(!ueIdxFound)
13376                      {
13377                         DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
13378                         ret = RFAILED;
13379                      }
13380
13381
13382                      break;
13383                   }
13384                default :
13385                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
13386                         ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
13387                   break;
13388             }
13389          }
13390       }
13391    }
13392    if(ret != RFAILED)
13393    {
13394       duProcUeContextReleaseCommand(duUeCb);
13395    }
13396    freeAperDecodeUeContextReleaseCommand(f1apMsg);
13397    return ret;
13398 }
13399 /**************************************************************
13400  *
13401  * @brief Handles received F1AP message and sends back response
13402  *
13403  * @details
13404  *
13405  *    Function : F1APMsgHdlr
13406  *
13407  *    Functionality:
13408  *         - Decodes received F1AP control message
13409  *         - Prepares response message, encodes and sends to SCTP
13410  *
13411  * @params[in]
13412  * @return ROK     - success
13413  *         RFAILED - failure
13414  *
13415  * ****************************************************************/
13416 void F1APMsgHdlr(Buffer *mBuf)
13417 {
13418    int i =0;
13419    char *recvBuf =NULLP;
13420    MsgLen copyCnt =0;
13421    MsgLen recvBufLen =0;
13422    F1AP_PDU_t *f1apMsg =NULLP;
13423    asn_dec_rval_t rval; /* Decoder return value */
13424    F1AP_PDU_t f1apasnmsg ;
13425    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
13426    ODU_PRINT_MSG(mBuf, 0,0);
13427
13428    /* Copy mBuf into char array to decode it */
13429    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
13430    DU_ALLOC(recvBuf, (Size)recvBufLen);
13431
13432    if(recvBuf == NULLP)
13433    {
13434       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
13435       return;
13436    }
13437    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
13438    {
13439       DU_LOG("\nERROR   -->  F1AP : Failed while copying %d", copyCnt);
13440       return;
13441    }
13442
13443    printf("\nDEBUG   -->  F1AP : Received flat buffer to be decoded : ");
13444    for(i=0; i< recvBufLen; i++)
13445    {
13446       printf("%x",recvBuf[i]);
13447    }
13448
13449    /* Decoding flat buffer into F1AP messsage */
13450    f1apMsg = &f1apasnmsg;
13451    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
13452
13453    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
13454    DU_FREE(recvBuf, (Size)recvBufLen);
13455
13456    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
13457    {
13458       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
13459       return;
13460    }
13461    printf("\n");
13462    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13463
13464    switch(f1apMsg->present)
13465    {
13466       case F1AP_PDU_PR_successfulOutcome:
13467          {
13468             switch(f1apMsg->choice.successfulOutcome->value.present)
13469             {
13470                case SuccessfulOutcome__value_PR_ResetAcknowledge:
13471                   {
13472                      DU_LOG("\nINFO   -->  F1AP : F1ResetAcknowledge is received successfully ");
13473                      break;
13474                   }
13475                case SuccessfulOutcome__value_PR_F1SetupResponse:
13476                   {
13477 #ifndef ODU_TEST_STUB
13478                      procF1SetupRsp(f1apMsg);
13479 #endif
13480                      break;
13481                   }
13482
13483                case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
13484                   {
13485                      procF1GNBDUCfgUpdAck(f1apMsg);
13486                      break;
13487                   }
13488
13489                default:
13490                   {
13491                      DU_LOG("\nERROR  -->  F1AP : Invalid type of SuccessfulOutcome__value_PR_ResetAcknowledge [%d]",\
13492                            f1apMsg->choice.successfulOutcome->value.present);
13493                      return;
13494                   }
13495             }/* End of switch(successfulOutcome) */
13496             free(f1apMsg->choice.successfulOutcome);
13497             break;
13498          }
13499       case F1AP_PDU_PR_initiatingMessage:
13500          {
13501             switch(f1apMsg->choice.initiatingMessage->value.present)
13502             {
13503                case InitiatingMessage__value_PR_Reset:
13504                   {
13505                      procF1ResetReq(f1apMsg);
13506                      break;
13507                   }
13508                case InitiatingMessage__value_PR_DLRRCMessageTransfer:
13509                   {
13510                      procF1DlRrcMsgTrans(f1apMsg);
13511                      break;
13512                   }
13513                case InitiatingMessage__value_PR_UEContextSetupRequest:
13514                   {
13515                      procF1UeContextSetupReq(f1apMsg);
13516                      break;
13517                   }
13518                case InitiatingMessage__value_PR_UEContextModificationRequest:
13519                   {
13520                      procF1UeContextModificationReq(f1apMsg);
13521                      break;
13522                   }
13523                case InitiatingMessage__value_PR_UEContextReleaseCommand:
13524                   {
13525                       procF1UeContextReleaseCommand(f1apMsg);
13526                       break;
13527                   }
13528                default:
13529                   {
13530                      DU_LOG("\nERROR  -->  F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
13531                            f1apMsg->choice.initiatingMessage->value.present);
13532                      return;
13533                   }
13534             }/* End of switch(initiatingMessage) */
13535             free(f1apMsg->choice.initiatingMessage);
13536             break;
13537          }
13538
13539       default:
13540          {
13541             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
13542             return;
13543          }
13544          free(f1apMsg);
13545
13546    }/* End of switch(f1apMsg->present) */
13547
13548 } /* End of F1APMsgHdlr */
13549
13550 /**********************************************************************
13551   End of file
13552  **********************************************************************/