src/du_app/du_f1ap_msg_hdl.c

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   4 #                                                                              #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
   6 #   you may not use this file except in compliance with the License.           #
   7 #   You may obtain a copy of the License at                                    #
   8 #                                                                              #
   9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10 #                                                                              #
  11 #   Unless required by applicable law or agreed to in writing, software        #
  12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
  14 #   See the License for the specific language governing permissions and        #
  15 #   limitations under the License.                                             #
  16 ################################################################################
  17 *******************************************************************************/
  18
  19 /* This file contains F1AP message handler functions */
  20 #include "common_def.h"
  21 #include "lrg.h"
  22 #include "legtp.h"
  23 #include "lkw.x"
  24 #include "lrg.x"
  25 #include "F1AP-PDU.h"
  26 #include "du_app_mac_inf.h"
  27 #include "du_cfg.h"
  28 #include "du_app_rlc_inf.h"
  29 #include "du_mgr_main.h"
  30 #include "du_utils.h"
  31 #include "RAT-Type.h"
  32 #include "FeatureSetUplinkPerCC.h"
  33 #include "FeatureSetDownlinkPerCC.h"
  34 #include "FeatureSets.h"
  35 #include "UE-NR-Capability.h"
  36 #include "UE-CapabilityRAT-Container.h"
  37 #include "UE-CapabilityRAT-ContainerListRRC.h"
  38 #include "GNB-DU-System-Information.h"
  39 #include "CellGroupConfigRrc.h"
  40 #include "MAC-CellGroupConfig.h"
  41 #include "SchedulingRequestConfig.h"
  42 #include "SchedulingRequestToAddMod.h"
  43 #include "BSR-Config.h"
  44 #include "TAG-Config.h"
  45 #include "TAG.h"
  46 #include "PHR-Config.h"
  47 #include "RLC-Config.h"
  48 #include "UL-AM-RLC.h"
  49 #include "DL-AM-RLC.h"
  50 #include "LogicalChannelConfig.h"
  51 #include "RLC-BearerConfig.h"
  52 #include "PhysicalCellGroupConfig.h"
  53 #include "SpCellConfig.h"
  54 #include "TDD-UL-DL-ConfigDedicated.h"
  55 #include "ServingCellConfig.h"
  56 #include "ControlResourceSet.h"
  57 #include "SearchSpace.h"
  58 #include "PDCCH-Config.h"
  59 #include "PDSCH-TimeDomainResourceAllocation.h"
  60 #include "PDSCH-TimeDomainResourceAllocationList.h"
  61 #include "PDSCH-CodeBlockGroupTransmission.h"
  62 #include "PDSCH-ServingCellConfig.h"
  63 #include "DMRS-DownlinkConfig.h"
  64 #include "PDSCH-Config.h"
  65 #include "BWP-DownlinkDedicated.h"
  66 #include "PUSCH-TimeDomainResourceAllocation.h"
  67 #include "PUSCH-TimeDomainResourceAllocationList.h"
  68 #include "DMRS-UplinkConfig.h"
  69 #include "PUSCH-Config.h"
  70 #include "SRS-ResourceId.h"
  71 #include "SRS-Resource.h"
  72 #include "SRS-ResourceSet.h"
  73 #include "SRS-Config.h"
  74 #include "BWP-UplinkDedicated.h"
  75 #include "PUSCH-ServingCellConfig.h"
  76 #include "UplinkConfig.h"
  77 #include "DUtoCURRCContainer.h"
  78 #include "GBR-QoSFlowInformation.h"
  79 #include "QoSFlowLevelQoSParameters.h"
  80 #include "PUCCH-Config.h"
  81 #include "PUCCH-ResourceSet.h"
  82 #include "PUCCH-Resource.h"
  83 #include "PUCCH-PowerControl.h"
  84 #include "P0-PUCCH.h"
  85 #include "PUCCH-PathlossReferenceRS.h"
  86 #include "PUCCH-format0.h"
  87 #include "PUCCH-format1.h"
  88 #include "PUCCH-format2.h"
  89 #include "PUCCH-format3.h"
  90 #include "PUCCH-format4.h"
  91 #include "PUCCH-FormatConfig.h"
  92 #include "SchedulingRequestResourceConfig.h"
  93 #include<ProtocolIE-Field.h>
  94 #include "ProtocolExtensionField.h"
  95 #include "odu_common_codec.h"
  96 #include "du_mgr.h"
  97 #include "du_cell_mgr.h"
  98 #include "du_f1ap_msg_hdl.h"
  99 #include "DRBs-Setup-Item.h"
 100 #include "DLUPTNLInformation-ToBeSetup-List.h"
 101 #include "DLUPTNLInformation-ToBeSetup-Item.h"
 102 #include "UPTransportLayerInformation.h"
 103 #include "GTPTunnel.h"
 104
 105 #ifdef O1_ENABLE
 106 #include "ConfigInterface.h"
 107 extern StartupConfig g_cfg;
 108 #endif
 109
 110 DuCfgParams duCfgParam;
 111
 112 /************************************************************************
 113  *
 114  * @brief Converts enum values into actual value of Poll retransmit timer
 115  *
 116  * @details
 117  *
 118  *    Function : getPollPdu
 119  *
 120  *    Functionality: Converts enum values into actual value of poll
 121  *    retransmit timer
 122  *
 123  * @params[in] Enum value of pollPdu
 124  * @return Actual value of pollPdu
 125  *
 126  * **********************************************************************/
 127
 128 uint16_t getPollRetxTmr(uint8_t pollRetxTmrCfg)
 129 {
 130    uint16_t pollRetxTmr;
 131
 132    /* All values of poll retx timer are at interval of 5ms.
 133     * This is valid upto 250ms
 134     * Hence converting the enum value to actual value by multiplying it to 5
 135     */
 136    if(pollRetxTmrCfg <= T_PollRetransmit_ms250)
 137       pollRetxTmr = (pollRetxTmrCfg + 1) * 5;
 138    else
 139    {
 140       switch(pollRetxTmrCfg)
 141       {
 142          case T_PollRetransmit_ms300:
 143             pollRetxTmr = 300;
 144             break;
 145          case T_PollRetransmit_ms350:
 146             pollRetxTmr = 350;
 147             break;
 148          case T_PollRetransmit_ms400:
 149             pollRetxTmr = 400;
 150             break;
 151          case T_PollRetransmit_ms450:
 152             pollRetxTmr = 450;
 153             break;
 154          case T_PollRetransmit_ms500:
 155             pollRetxTmr = 500;
 156             break;
 157          case T_PollRetransmit_ms800:
 158             pollRetxTmr = 800;
 159             break;
 160          default:
 161             DU_LOG("\nERROR  -->  F1AP: Invalid value of Poll Retransmit timer");
 162             pollRetxTmr = 0;
 163       }
 164    }
 165    return pollRetxTmr;
 166 }
 167
 168 /*******************************************************************
 169  *
 170  * @brief Converts enum values into actual value of PollPdu
 171  *
 172  * @details
 173  *
 174  *    Function : getPollPdu
 175  *
 176  *    Functionality: Converts enum values into actual value of PollPdu
 177  *
 178  * @params[in] Enum value of pollPdu
 179  * @return Actual value of pollPdu
 180  *
 181  * ****************************************************************/
 182 int32_t getPollPdu(uint8_t pollPduCfg)
 183 {
 184    int32_t pollPdu;
 185    switch(pollPduCfg)
 186    {
 187       case PollPDU_p4:
 188          pollPdu = 4;
 189          break;
 190       case PollPDU_p8:
 191          pollPdu = 8;
 192          break;
 193       case PollPDU_p16:
 194          pollPdu = 16;
 195          break;
 196       case PollPDU_p32:
 197          pollPdu = 32;
 198          break;
 199       case PollPDU_p64:
 200          pollPdu = 64;
 201          break;
 202       case PollPDU_p128:
 203          pollPdu = 128;
 204          break;
 205       case PollPDU_p256:
 206          pollPdu = 256;
 207          break;
 208       case PollPDU_p512:
 209          pollPdu = 512;
 210          break;
 211       case PollPDU_p1024:
 212          pollPdu = 1024;
 213          break;
 214       case PollPDU_p2048:
 215          pollPdu = 2048;
 216          break;
 217       case PollPDU_p4096:
 218          pollPdu = 4096;
 219          break;
 220       case PollPDU_p6144:
 221          pollPdu = 6144;
 222          break;
 223       case PollPDU_p8192:
 224          pollPdu = 8192;
 225          break;
 226       case PollPDU_p12288:
 227          pollPdu = 12288;
 228          break;
 229       case PollPDU_p16384:
 230          pollPdu = 16384;
 231          break;
 232       case PollPDU_p20480:
 233          pollPdu = 20480;
 234          break;
 235       case PollPDU_p24576:
 236          pollPdu = 24576;
 237          break;
 238       case PollPDU_p28672:
 239          pollPdu = 28672;
 240          break;
 241       case PollPDU_p32768:
 242          pollPdu = 32768;
 243          break;
 244       case PollPDU_p40960:
 245          pollPdu = 40960;
 246          break;
 247       case PollPDU_p49152:
 248          pollPdu = 49152;
 249          break;
 250       case PollPDU_p57344:
 251          pollPdu = 57344;
 252          break;
 253       case PollPDU_p65536:
 254          pollPdu = 65536;
 255          break;
 256       case PollPDU_infinity:
 257          pollPdu = -1;
 258          break;
 259       default:
 260          DU_LOG("\nERROR  -->  F1AP: Invalid value of poll pdu");
 261          pollPdu = 0;
 262          break;
 263    }
 264    return pollPdu;
 265 }
 266
 267 /*******************************************************************
 268  *
 269  * @brief Converts enum values into actual value of poll bytes
 270  *
 271  * @details
 272  *
 273  *    Function : getPollByte
 274  *
 275  *    Functionality: Converts enum values into actual value of pollBytes
 276  *
 277  * @params[in] Enum value
 278  * @return Actual value
 279  *
 280  * ****************************************************************/
 281 int32_t getPollByte(uint16_t pollBytesCfg)
 282 {
 283    int32_t pollBytes;
 284    switch(pollBytesCfg)
 285    {
 286       case PollByte_kB1:
 287          pollBytes = 1000;
 288          break;
 289       case PollByte_kB2:
 290          pollBytes = 2000;
 291          break;
 292       case PollByte_kB5:
 293          pollBytes = 5000;
 294          break;
 295       case PollByte_kB8:
 296          pollBytes = 8000;
 297          break;
 298       case PollByte_kB10:
 299          pollBytes = 10000;
 300          break;
 301       case PollByte_kB15:
 302          pollBytes = 15000;
 303          break;
 304       case PollByte_kB25:
 305          pollBytes = 25000;
 306          break;
 307       case PollByte_kB50:
 308          pollBytes = 50000;
 309          break;
 310       case PollByte_kB75:
 311          pollBytes = 75000;
 312          break;
 313       case PollByte_kB100:
 314          pollBytes = 100000;
 315          break;
 316       case PollByte_kB125:
 317          pollBytes = 125000;
 318          break;
 319       case PollByte_kB250:
 320          pollBytes = 250000;
 321          break;
 322       case PollByte_kB375:
 323          pollBytes = 375000;
 324          break;
 325       case PollByte_kB500:
 326          pollBytes = 500000;
 327          break;
 328       case PollByte_kB750:
 329          pollBytes = 750000;
 330          break;
 331       case PollByte_kB1000:
 332          pollBytes = 1000000;
 333          break;
 334       case PollByte_kB1250:
 335          pollBytes = 1250000;
 336          break;
 337       case PollByte_kB1500:
 338          pollBytes = 1500000;
 339          break;
 340       case PollByte_kB2000:
 341          pollBytes = 2000000;
 342          break;
 343       case PollByte_kB3000:
 344          pollBytes = 3000000;
 345          break;
 346       case PollByte_kB4000:
 347          pollBytes = 4000000;
 348          break;
 349       case PollByte_kB4500:
 350          pollBytes = 4500000;
 351          break;
 352       case PollByte_kB5000:
 353          pollBytes = 5000000;
 354          break;
 355       case PollByte_kB5500:
 356          pollBytes = 5500000;
 357          break;
 358       case PollByte_kB6000:
 359          pollBytes = 6000000;
 360          break;
 361       case PollByte_kB6500:
 362          pollBytes = 6500000;
 363          break;
 364       case PollByte_kB7000:
 365          pollBytes = 7000000;
 366          break;
 367       case PollByte_kB7500:
 368          pollBytes = 7500000;
 369          break;
 370       case PollByte_mB8:
 371          pollBytes = 8000000;
 372          break;
 373       case PollByte_mB9:
 374          pollBytes = 9000000;
 375          break;
 376       case PollByte_mB10:
 377          pollBytes = 10000000;
 378          break;
 379       case PollByte_mB11:
 380          pollBytes = 11000000;
 381          break;
 382       case PollByte_mB12:
 383          pollBytes = 12000000;
 384          break;
 385       case PollByte_mB13:
 386          pollBytes = 13000000;
 387          break;
 388       case PollByte_mB14:
 389          pollBytes = 14000000;
 390          break;
 391       case PollByte_mB15:
 392          pollBytes = 15000000;
 393          break;
 394       case PollByte_mB16:
 395          pollBytes = 16000000;
 396          break;
 397       case PollByte_mB17:
 398          pollBytes = 17000000;
 399          break;
 400       case PollByte_mB18:
 401          pollBytes = 18000000;
 402          break;
 403       case PollByte_mB20:
 404          pollBytes = 20000000;
 405          break;
 406       case PollByte_mB25:
 407          pollBytes = 25000000;
 408          break;
 409       case PollByte_mB30:
 410          pollBytes = 30000000;
 411          break;
 412       case PollByte_mB40:
 413          pollBytes = 40000000;
 414          break;
 415       case PollByte_infinity:
 416          pollBytes = -1;
 417          break;
 418       default:
 419          DU_LOG("\nERROR  -->  F1AP: Invalid value of poll bytes");
 420          pollBytes = 0;
 421    }
 422    return pollBytes;
 423 }
 424
 425 /*******************************************************************
 426  *
 427  * @brief Converts enum values into actual value of maxRetx
 428  *
 429  * @details
 430  *
 431  *    Function : getMaxRetx
 432  *
 433  *    Functionality: Converts enum values into actual value of maxRetx
 434  *
 435  * @params[in] Enum value
 436  * @return Actual value
 437  *
 438  * ****************************************************************/
 439 uint8_t getMaxRetx(uint8_t maxRetxCfg)
 440 {
 441    uint8_t maxRetx;
 442    switch(maxRetxCfg)
 443    {
 444       case UL_AM_RLC__maxRetxThreshold_t1:
 445          maxRetx = 1;
 446          break;
 447       case UL_AM_RLC__maxRetxThreshold_t2:
 448          maxRetx = 2;
 449          break;
 450       case UL_AM_RLC__maxRetxThreshold_t3:
 451          maxRetx = 3;
 452          break;
 453       case UL_AM_RLC__maxRetxThreshold_t4:
 454          maxRetx = 4;
 455          break;
 456       case UL_AM_RLC__maxRetxThreshold_t6:
 457          maxRetx = 6;
 458          break;
 459       case UL_AM_RLC__maxRetxThreshold_t8:
 460          maxRetx = 8;
 461          break;
 462       case UL_AM_RLC__maxRetxThreshold_t16:
 463          maxRetx = 16;
 464          break;
 465       case UL_AM_RLC__maxRetxThreshold_t32:
 466          maxRetx = 32;
 467          break;
 468       default:
 469          DU_LOG("\nERROR  -->  F1AP: Invalid configuration for Max retransmission threshold");
 470          maxRetx = 0;
 471    }
 472    return maxRetx;
 473 }
 474
 475 /*******************************************************************
 476  * @brief Converts enum values into actual value of reassembly timer
 477  *
 478  * @details
 479  *
 480  *    Function : getReAsmblTmr
 481  *
 482  *    Functionality: Converts enum values into actual value of reassembly
 483  *    timer
 484  *
 485  * @params[in] Enum value of reassembly timer
 486  * @return Actual value of reassembly timer
 487  *
 488  * **********************************************************************/
 489
 490 int8_t getReAsmblTmr(uint8_t reAsmblTmrCfg)
 491 {
 492    int8_t reAsmblTmr = 0;
 493
 494    if(reAsmblTmrCfg == T_Reassembly_ms0)
 495    {
 496       reAsmblTmr = 0;
 497    }
 498    else if(reAsmblTmrCfg >= T_Reassembly_ms5 || reAsmblTmrCfg <= T_Reassembly_ms100)
 499    {
 500      /* All values of re assembly timer are at interval of 5ms.
 501       * This is valid upto 100ms
 502       * Hence converting the enum value to actual value by multiplying it to 5
 503       */
 504       reAsmblTmr = reAsmblTmrCfg * 5;
 505    }
 506    else if(reAsmblTmrCfg >= T_Reassembly_ms110 || reAsmblTmrCfg <= T_Reassembly_ms200)
 507    {
 508      /* All values of re assembly timer are at interval of 10ms.
 509       * This is valid upto 200ms
 510       * since enum value starts from 20 for 100ms, subtracting 10 and
 511       * converting the enum value to actual value by multiplying it to 10
 512       */
 513       reAsmblTmr = ((reAsmblTmrCfg-10) * 10);
 514    }
 515    else
 516    {
 517       DU_LOG("\nERROR  -->  F1AP : Invalid value of Re Assembly timer %d", reAsmblTmrCfg);
 518       reAsmblTmr = -1;
 519    }
 520    return reAsmblTmr;
 521 }
 522
 523 /************************************************************************
 524  *
 525  * @brief Converts enum values into actual value of status prohibit timer
 526  *
 527  * @details
 528  *
 529  *    Function : getStatProhTmr
 530  *
 531  *    Functionality: Converts enum values into actual value of status prohibit
 532  *    timer
 533  *
 534  * @params[in] Enum value of status prohibit timer
 535  * @return Actual value of status prohibit timer
 536  *
 537  * **********************************************************************/
 538
 539 int16_t getStatProhTmr(uint8_t statProhTmrCfg)
 540 {
 541    int16_t statProhTmr =0;
 542
 543    if(statProhTmrCfg == T_StatusProhibit_ms0)
 544    {
 545       statProhTmr = 0;
 546    }
 547    else if(statProhTmrCfg >= T_StatusProhibit_ms5 || statProhTmrCfg <= T_StatusProhibit_ms250)
 548    {
 549       /* All values of re assembly timer are at interval of 5ms.
 550        * This is valid upto 250ms
 551        * Hence converting the enum value to actual value by multiplying it to 5
 552        */
 553       statProhTmr = statProhTmrCfg * 5;
 554    }
 555    else
 556    {
 557       switch(statProhTmrCfg)
 558       {
 559          case T_StatusProhibit_ms300:
 560             statProhTmr = 300;
 561             break;
 562          case T_StatusProhibit_ms350:
 563             statProhTmr = 350;
 564             break;
 565          case T_StatusProhibit_ms400:
 566             statProhTmr = 400;
 567             break;
 568          case T_StatusProhibit_ms450:
 569             statProhTmr = 450;
 570             break;
 571          case T_StatusProhibit_ms500:
 572             statProhTmr = 500;
 573             break;
 574          case T_StatusProhibit_ms800:
 575             statProhTmr = 800;
 576             break;
 577          case T_StatusProhibit_ms1000:
 578             statProhTmr = 1000;
 579             break;
 580          case T_StatusProhibit_ms1200:
 581             statProhTmr = 1200;
 582             break;
 583          case T_StatusProhibit_ms1600:
 584             statProhTmr = 1600;
 585             break;
 586          case T_StatusProhibit_ms2000:
 587             statProhTmr = 2000;
 588             break;
 589          case T_StatusProhibit_ms2400:
 590             statProhTmr = 2400;
 591             break;
 592          default:
 593             DU_LOG("\nInvalid value of Status Prohibit timer %d", statProhTmrCfg);
 594             statProhTmr = -1;
 595             break;
 596       }
 597    }
 598    return statProhTmr;
 599 }
 600
 601 /*******************************************************************
 602 *
 603 * @brief Adding F1AP pdu to reserved pdu list
 604 *
 605 * @details
 606 *
 607 *    Function : addToReservedF1apPduList
 608 *
 609 *    Functionality: Adding F1AP pdu to reserved pdu list.
 610 *     These pdu are awaiting aknowledgment from CU
 611 *
 612 * @params[in] uint8_t transId, F1AP_PDU_t *f1apMsg
 613 *
 614 * @return ROK - success
 615 *         RFAILED - failure
 616 *
 617 * ****************************************************************/
 618
 619 void addToReservedF1apPduList(uint8_t transId, F1AP_PDU_t *f1apPdu)
 620 {
 621    CmLList         *node = NULLP;
 622    ReservedF1apPduInfo *pduInfo = NULLP;
 623    DU_ALLOC(pduInfo, sizeof(ReservedF1apPduInfo));
 624    if(pduInfo)
 625    {
 626       DU_ALLOC(node, sizeof(CmLList));
 627       if(node)
 628       {
 629          pduInfo->transId = transId;
 630          pduInfo->f1apMsg = (void*) f1apPdu;
 631
 632          node->node = (PTR)pduInfo;
 633          cmLListAdd2Tail(&duCb.reservedF1apPduList, node);
 634       }
 635    }
 636 }
 637
 638 /*******************************************************************
 639 *
 640 * @brief searching for F1AP pdu from ReservedF1apPduList
 641 *
 642 * @details
 643 *
 644 *    Function : searchFromReservedF1apPduList
 645 *
 646 *    Functionality: searching for F1AP pdu information
 647 *
 648 * @params[in] uint8_t transId
 649 *
 650 * @return pointer to F1AP_PDU_t
 651 *
 652 * ****************************************************************/
 653
 654 CmLList *searchFromReservedF1apPduList(uint8_t transId)
 655 {
 656    CmLList         *node;
 657    ReservedF1apPduInfo *f1apPdu;
 658    if(duCb.reservedF1apPduList.count)
 659    {
 660       CM_LLIST_FIRST_NODE(&duCb.reservedF1apPduList, node);
 661       while(node)
 662       {
 663          f1apPdu = (ReservedF1apPduInfo*)node->node;
 664          if(f1apPdu->transId == transId)
 665          {
 666             return node;
 667          }
 668          node = node->next;
 669       }
 670    }
 671    return NULL;
 672 }
 673
 674 /*******************************************************************
 675 *
 676 * @brief deleting F1AP pdu information from ReservedF1apPduList
 677 *
 678 * @details
 679 *
 680 *    Function : deleteFromReservedF1apPduList
 681 *
 682 *    Functionality: deleting pdu information from ReservedF1apPduList
 683 *
 684 * @params[in] CmLList *node
 685 *
 686 * @return void
 687 *
 688 * ****************************************************************/
 689
 690 void deleteFromReservedF1apPduList(CmLList *node)
 691 {
 692    ReservedF1apPduInfo *f1apPdu;
 693
 694    if(node != NULL)
 695    {
 696       f1apPdu = (ReservedF1apPduInfo *)node->node;
 697       cmLListDelFrm(&duCb.reservedF1apPduList, node);
 698       DU_FREE(f1apPdu, sizeof(ReservedF1apPduInfo));
 699       DU_FREE(node, sizeof(CmLList));
 700       node = NULL;
 701    }
 702 }
 703
 704 /*******************************************************************
 705  *
 706  * @brief Builds Uplink Info for NR
 707  *
 708  * @details
 709  *
 710  *    Function : BuildULNRInfo
 711  *
 712  *    Functionality: Building NR Uplink Info
 713  *
 714  * @params[in] NRFreqInfo_t *ulnrfreq
 715  * @return ROK     - success
 716  *         RFAILED - failure
 717  *
 718  * ****************************************************************/
 719 uint8_t BuildULNRInfo(NRFreqInfo_t *ulnrfreq)
 720 {
 721    uint8_t idx=0;
 722    ulnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 723                        fdd.ulNrFreqInfo.nrArfcn;
 724    ulnrfreq->freqBandListNr.list.count = 1;
 725    ulnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 726    DU_ALLOC(ulnrfreq->freqBandListNr.list.array,ulnrfreq->freqBandListNr.list.size);
 727    if(ulnrfreq->freqBandListNr.list.array == NULLP)
 728    {
 729       return RFAILED;
 730    }
 731    for(idx=0;idx<ulnrfreq->freqBandListNr.list.count;idx++)
 732    {
 733       DU_ALLOC(ulnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 734       if(ulnrfreq->freqBandListNr.list.array[idx] == NULLP)
 735       {
 736          return RFAILED;
 737       }
 738    }
 739    ulnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 740                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
 741                                                                  freqBand[0].nrFreqBand;
 742    ulnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 743    return ROK;
 744 }
 745 /*******************************************************************
 746  *
 747  * @brief Builds Downlink NR Info
 748  *
 749  * @details
 750  *
 751  *    Function : BuildDLNRInfo
 752  *
 753  *    Functionality: Building Downlink NR Info
 754  *
 755  * @params[in] NRFreqInfo_t *dlnrfreq
 756  * @return ROK     - success
 757  *         RFAILED - failure
 758  *
 759  * ****************************************************************/
 760 uint8_t BuildDLNRInfo(NRFreqInfo_t *dlnrfreq)
 761 {
 762    uint8_t idx=0;
 763    dlnrfreq->nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.\
 764                        fdd.dlNrFreqInfo.nrArfcn;
 765    dlnrfreq->freqBandListNr.list.count = 1;
 766    dlnrfreq->freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
 767    DU_ALLOC(dlnrfreq->freqBandListNr.list.array,dlnrfreq->freqBandListNr.list.size);
 768    if(dlnrfreq->freqBandListNr.list.array == NULLP)
 769    {
 770       return RFAILED;
 771    }
 772    for(idx=0;idx< dlnrfreq->freqBandListNr.list.count;idx++)
 773    {
 774       DU_ALLOC(dlnrfreq->freqBandListNr.list.array[idx],sizeof(FreqBandNrItem_t));
 775       if(dlnrfreq->freqBandListNr.list.array[idx] == NULLP)
 776       {
 777          return RFAILED;
 778       }
 779    }
 780    dlnrfreq->freqBandListNr.list.array[0]->freqBandIndicatorNr = \
 781                                                                  duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
 782                                                                  freqBand[0].nrFreqBand;
 783    dlnrfreq->freqBandListNr.list.array[0]->supportedSULBandList.list.count = SUL_BAND_COUNT;
 784
 785    return ROK;
 786 }
 787
 788 /*******************************************************************
 789  *
 790  * @brief Builds NRCell ID
 791  *
 792  * @details
 793  *
 794  *    Function : BuildNrCellId
 795  *
 796  *    Functionality: Building the NR Cell ID
 797  *
 798  * @params[in] BIT_STRING_t *nrcell
 799  * @return ROK     - success
 800  *         RFAILED - failure
 801  *
 802  * ****************************************************************/
 803
 804 S16 BuildNrCellId(BIT_STRING_t *nrcell)
 805 {
 806    memset(nrcell->buf, 0, nrcell->size);
 807    nrcell->buf[4]   = 16;
 808    nrcell->bits_unused = 4;
 809    return ROK;
 810 }
 811
 812 /*******************************************************************
 813  *
 814  * @brief Builds Nrcgi
 815  *
 816  * @details
 817  *
 818  *    Function : BuildNrcgi
 819  *
 820  *    Functionality: Building the PLMN ID and NR Cell id
 821  *
 822  * @params[in] NRCGI_t *nrcgi
 823  * @return ROK     - success
 824  *         RFAILED - failure
 825  *
 826  * ****************************************************************/
 827 uint8_t BuildNrcgi(NRCGI_t *nrcgi)
 828 {
 829    uint8_t ret;
 830    uint8_t byteSize = 5;
 831    /* Allocate Buffer Memory */
 832    nrcgi->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
 833    DU_ALLOC(nrcgi->pLMN_Identity.buf, nrcgi->pLMN_Identity.size);
 834    if(nrcgi->pLMN_Identity.buf == NULLP)
 835    {
 836       return RFAILED;
 837    }
 838    ret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
 839          nrcgi->pLMN_Identity.buf); // Building PLMN function
 840    if(ret != ROK)
 841    {
 842       return RFAILED;
 843    }
 844    /*nrCellIdentity*/
 845    nrcgi->nRCellIdentity.size = byteSize * sizeof(uint8_t);
 846    DU_ALLOC(nrcgi->nRCellIdentity.buf, nrcgi->nRCellIdentity.size);
 847    if(nrcgi->nRCellIdentity.buf == NULLP)
 848    {
 849       return RFAILED;
 850    }
 851    BuildNrCellId(&nrcgi->nRCellIdentity);
 852
 853    return ROK;
 854 }
 855 /*******************************************************************
 856  *
 857  * @brief Builds FiveGStac
 858  *
 859  * @details
 860  *
 861  *    Function : BuildFiveGSTac
 862  *
 863  *    Functionality: Building the FiveGSTac
 864  *
 865  * @params[in] OCTET_STRING_t *fivegsTac
 866  * @return ROK     - success
 867  *         RFAILED - failure
 868  *
 869  * ****************************************************************/
 870 uint8_t BuildFiveGSTac(Served_Cell_Information_t *servcell)
 871 {
 872    DU_ALLOC(servcell->fiveGS_TAC,sizeof(FiveGS_TAC_t));
 873    if(servcell->fiveGS_TAC == NULLP)
 874    {
 875       return RFAILED;
 876    }
 877    servcell->fiveGS_TAC->size = 3 * sizeof(uint8_t);
 878    DU_ALLOC(servcell->fiveGS_TAC->buf,\
 879          sizeof(servcell->fiveGS_TAC->size));
 880    if(servcell->fiveGS_TAC->buf == NULLP)
 881    {
 882       return RFAILED;
 883    }
 884    servcell->fiveGS_TAC->buf[0] = 0;
 885    servcell->fiveGS_TAC->buf[1] = 0;
 886    servcell->fiveGS_TAC->buf[2] = duCfgParam.srvdCellLst[0].duCellInfo.tac;
 887    return ROK;
 888 }
 889 /*******************************************************************
 890  *
 891  * @brief Builds NR Mode
 892  *
 893  * @details
 894  *
 895  *    Function : BuildNrMode
 896  *
 897  *    Functionality: Building the NR Mode
 898  *
 899  * @params[in] NR_Mode_Info_t *fdd
 900  * @return ROK     - success
 901  *         RFAILED - failure
 902  *
 903  * ****************************************************************/
 904 uint8_t BuildNrMode(NR_Mode_Info_t *mode)
 905 {
 906    uint8_t BuildDLNRInforet=0;
 907    uint8_t BuildULNRInforet=0;
 908    /* FDD Mode */
 909    mode->present = NR_Mode_Info_PR_fDD;
 910    if(mode->present == NR_Mode_Info_PR_fDD)
 911    {
 912       DU_ALLOC(mode->choice.fDD,sizeof(FDD_Info_t));
 913       if(mode->choice.fDD == NULLP)
 914       {
 915          return RFAILED;
 916       }
 917       BuildULNRInforet = BuildULNRInfo(&mode->choice.fDD->uL_NRFreqInfo);
 918       if(BuildULNRInforet != ROK)
 919       {
 920          return RFAILED;
 921       }
 922       BuildDLNRInforet = BuildDLNRInfo(&mode->choice.fDD->dL_NRFreqInfo);
 923       if(BuildDLNRInforet != ROK)
 924       {
 925          return RFAILED;
 926       }
 927    }
 928    mode->choice.fDD->uL_Transmission_Bandwidth.nRSCS = \
 929                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 930                                                        f1Mode.mode.fdd.ulTxBw.nrScs;
 931    mode->choice.fDD->uL_Transmission_Bandwidth.nRNRB = \
 932                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 933                                                        f1Mode.mode.fdd.ulTxBw.nrb;
 934    mode->choice.fDD->dL_Transmission_Bandwidth.nRSCS = \
 935                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 936                                                        f1Mode.mode.fdd.dlTxBw.nrScs;
 937    mode->choice.fDD->dL_Transmission_Bandwidth.nRNRB = \
 938                                                        duCfgParam.srvdCellLst[0].duCellInfo.\
 939                                                        f1Mode.mode.fdd.dlTxBw.nrb;
 940    return ROK;
 941 }
 942 /*******************************************************************
 943  *
 944  * @brief Builds IE Extensions for Served PLMNs
 945  *
 946  * @details
 947  *
 948  *    Function : BuildExtensions
 949  *
 950  *    Functionality: Building the IE Extensions
 951  *
 952  * @params[in] struct ProtocolExtensionContainer_4624P3 *buildextend
 953  * @return ROK     - success
 954  *         RFAILED - failure
 955  *
 956  * ****************************************************************/
 957 uint8_t BuildExtensions(ProtocolExtensionContainer_4624P3_t **ieExtend)
 958 {
 959    uint8_t idx=0, plmnidx=0, sliceLstIdx=0;
 960    uint8_t elementCnt=0, extensionCnt=0;
 961
 962    extensionCnt=IE_EXTENSION_LIST_COUNT;
 963    DU_ALLOC(*ieExtend,sizeof(ProtocolExtensionContainer_4624P3_t));
 964    if((*ieExtend) == NULLP)
 965    {
 966       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 967       return RFAILED;
 968    }
 969    (*ieExtend)->list.count = extensionCnt;
 970    (*ieExtend)->list.size = \
 971                             extensionCnt * sizeof(ServedPLMNs_ItemExtIEs_t *);
 972    DU_ALLOC((*ieExtend)->list.array,(*ieExtend)->list.size);
 973    if((*ieExtend)->list.array == NULLP)
 974    {
 975       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 976       return RFAILED;
 977    }
 978    for(plmnidx=0;plmnidx<extensionCnt;plmnidx++)
 979    {
 980       DU_ALLOC((*ieExtend)->list.array[plmnidx],\
 981             sizeof(ServedPLMNs_ItemExtIEs_t));
 982       if((*ieExtend)->list.array[plmnidx] == NULLP)
 983       {
 984          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
 985          return RFAILED;
 986       }
 987    }
 988
 989    elementCnt = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].taiSliceSuppLst.numSupportedSlices;
 990    idx = 0;
 991    (*ieExtend)->list.array[idx]->id = ProtocolIE_ID_id_TAISliceSupportList;
 992    (*ieExtend)->list.array[idx]->criticality = Criticality_ignore;
 993    (*ieExtend)->list.array[idx]->extensionValue.present = \
 994    ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
 995    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 996       list.count = elementCnt;
 997    (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 998       list.size = (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
 999       list.count * sizeof(SliceSupportItem_t *);
1000
1001    DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1002          list.array, elementCnt * sizeof(SliceSupportItem_t *));
1003    if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1004          list.array == NULLP)
1005    {
1006       DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1007       return RFAILED;
1008    }
1009
1010    for(sliceLstIdx =0; sliceLstIdx<elementCnt; sliceLstIdx++)
1011    {
1012       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1013             list.array[sliceLstIdx],sizeof(SliceSupportItem_t));
1014       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1015             list.array[sliceLstIdx] == NULLP)
1016       {
1017          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1018          return RFAILED;
1019       }
1020       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1021          list.array[sliceLstIdx]->sNSSAI.sST.size = sizeof(uint8_t);
1022       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
1023             .list.array[sliceLstIdx]->sNSSAI.sST.buf,(*ieExtend)->list.array[idx]->\
1024             extensionValue.choice.SliceSupportList.\
1025             list.array[sliceLstIdx]->sNSSAI.sST.size);
1026       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList\
1027             .list.array[sliceLstIdx]->sNSSAI.sST.buf == NULLP)
1028       {
1029          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1030          return RFAILED;
1031       }
1032       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1033          list.array[sliceLstIdx]->sNSSAI.sST.buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.\
1034          cellInfo.srvdPlmn[0].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
1035
1036       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1037             list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
1038       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1039             list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
1040       {
1041          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1042          return RFAILED;
1043       }
1044       (*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1045          list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
1046       DU_ALLOC((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1047             list.array[sliceLstIdx]->sNSSAI.sD->buf, (*ieExtend)->list.array[idx]->extensionValue.choice.\
1048             SliceSupportList.list.array[sliceLstIdx]->sNSSAI.sD->size);
1049       if((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1050             list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
1051       {
1052          DU_LOG("ERROR  --> DU_APP : BuildExtensions(): Memory allocation failed");
1053          return RFAILED;
1054       }
1055       memcpy((*ieExtend)->list.array[idx]->extensionValue.choice.SliceSupportList.\
1056       list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[0].duCellInfo.\
1057       cellInfo.srvdPlmn[0].taiSliceSuppLst.snssai[sliceLstIdx]->sd, (*ieExtend)->list.array[idx]->\
1058       extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->sNSSAI.sD->size);
1059    }
1060    return ROK;
1061 }
1062 /*******************************************************************
1063  *
1064  * @brief Builds Served PLMN
1065  *
1066  * @details
1067  *
1068  *    Function : BuildServedPlmn
1069  *
1070  *    Functionality: Building the Served PLMN
1071  *
1072  * @params[in] GNB_DU_Served_Cells_Item_t *srvCellItem
1073  * @return ROK     - success
1074  *         RFAILED - failure
1075  *
1076  * ****************************************************************/
1077 uint8_t  BuildServedPlmn(ServedPLMNs_List_t *srvplmn)
1078 {
1079    uint8_t  plmnidx;
1080    uint8_t  servPlmnCnt=1;
1081    uint8_t buildPlmnIdret=0;
1082    uint8_t BuildExtensionsret=0;
1083    srvplmn->list.count = servPlmnCnt;
1084    srvplmn->list.size = \
1085                         servPlmnCnt*sizeof(ServedPLMNs_Item_t *);
1086    DU_ALLOC(srvplmn->list.array,srvplmn->list.size);
1087    if(srvplmn->list.array == NULLP)
1088    {
1089       return RFAILED;
1090    }
1091    for(plmnidx=0; plmnidx<servPlmnCnt; plmnidx++)
1092    {
1093       DU_ALLOC(srvplmn->list.array[plmnidx],\
1094             sizeof(ServedPLMNs_Item_t));
1095       if(srvplmn->list.array[plmnidx] == NULLP)
1096       {
1097          return RFAILED;
1098       }
1099    }
1100    srvplmn->list.array[0]->pLMN_Identity.size = PLMN_SIZE * sizeof(uint8_t);
1101    DU_ALLOC(srvplmn->list.array[0]->pLMN_Identity.buf, srvplmn->list.array[0]->pLMN_Identity.size);
1102    buildPlmnIdret = buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
1103          srvplmn->list.array[0]->pLMN_Identity.buf);
1104    if(buildPlmnIdret!= ROK)
1105    {
1106       return RFAILED;
1107    }
1108    BuildExtensionsret = BuildExtensions(&srvplmn->list.array[0]->iE_Extensions);
1109    if(BuildExtensionsret!= ROK)
1110    {
1111       return RFAILED;
1112    }
1113    return ROK;
1114 }
1115 /*******************************************************************
1116  *
1117  * @brief Builds Served Cell List
1118  *
1119  * @details
1120  *
1121  *    Function : BuildServedCellList
1122  *
1123  *    Functionality: Building Served Cell List
1124  *
1125  * @params[in] PLMNID plmn
1126  * @return ROK     - success
1127  *         RFAILED - failure
1128  *
1129  * ****************************************************************/
1130
1131 uint8_t BuildServedCellList(GNB_DU_Served_Cells_List_t *duServedCell)
1132 {
1133    uint8_t  BuildNrcgiret=0;
1134    uint8_t  BuildFiveGSTacret=0;
1135    uint8_t  BuildServedPlmnret=0;
1136    uint8_t  BuildNrModeret=0;
1137    uint8_t  idx;
1138    uint8_t  plmnidx;
1139    uint8_t  plmnCnt=1;
1140    GNB_DU_Served_Cells_Item_t *srvCellItem;
1141    duServedCell->list.size = plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t *);
1142    duServedCell->list.count = plmnCnt;
1143
1144    DU_ALLOC(duServedCell->list.array, duServedCell->list.size);
1145    if(duServedCell->list.array == NULLP)
1146    {
1147       return RFAILED;
1148    }
1149    for(plmnidx=0; plmnidx<plmnCnt; plmnidx++)
1150    {
1151       DU_ALLOC(duServedCell->list.array[plmnidx],\
1152             sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1153       if(duServedCell->list.array[plmnidx] == NULLP)
1154       {
1155          return RFAILED;
1156       }
1157    }
1158    idx = 0;
1159    duServedCell->list.array[idx]->id = ProtocolIE_ID_id_GNB_DU_Served_Cells_Item;
1160    duServedCell->list.array[idx]->criticality = Criticality_reject;
1161    duServedCell->list.array[idx]->value.present = \
1162                                                   GNB_DU_Served_Cells_ItemIEs__value_PR_GNB_DU_Served_Cells_Item;
1163    srvCellItem = \
1164                  &duServedCell->list.array[idx]->value.choice.GNB_DU_Served_Cells_Item;
1165    /*nRCGI*/
1166    BuildNrcgiret = BuildNrcgi(&srvCellItem->served_Cell_Information.nRCGI);
1167    if(BuildNrcgiret != ROK)
1168    {
1169       return RFAILED;
1170    }
1171    /*nRPCI*/
1172    srvCellItem->served_Cell_Information.nRPCI = \
1173                                                 duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
1174
1175    /*fiveGS_TAC*/
1176    BuildFiveGSTacret = BuildFiveGSTac(&srvCellItem->served_Cell_Information);
1177    if(BuildFiveGSTacret != ROK)
1178    {
1179       return RFAILED;
1180    }
1181    /*Served PLMNs*/
1182    BuildServedPlmnret = BuildServedPlmn(&srvCellItem->served_Cell_Information.servedPLMNs);
1183    if(BuildServedPlmnret !=ROK)
1184    {
1185       return RFAILED;
1186    }
1187    /*nR Mode Info with FDD*/
1188    BuildNrModeret = BuildNrMode(&srvCellItem->served_Cell_Information.nR_Mode_Info);
1189    if(BuildNrModeret != ROK)
1190    {
1191       return RFAILED;
1192    }
1193    /*Measurement timing Config*/
1194    srvCellItem->served_Cell_Information.measurementTimingConfiguration.\
1195       size = sizeof(uint8_t);
1196    DU_ALLOC(srvCellItem->served_Cell_Information.\
1197          measurementTimingConfiguration.buf,srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1198    if(srvCellItem->served_Cell_Information.\
1199          measurementTimingConfiguration.buf == NULLP)
1200    {
1201       return RFAILED;
1202    }
1203    srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf[0] = \
1204                                                                                 duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
1205
1206    /* GNB DU System Information */
1207    DU_ALLOC(srvCellItem->gNB_DU_System_Information,
1208          sizeof(GNB_DU_System_Information_t));
1209    if(!srvCellItem->gNB_DU_System_Information)
1210    {
1211       return RFAILED;
1212    }
1213    /* MIB */
1214    srvCellItem->gNB_DU_System_Information->mIB_message.size = duCfgParam.srvdCellLst[0].duSysInfo.mibLen;
1215    DU_ALLOC(srvCellItem->gNB_DU_System_Information->mIB_message.buf,
1216          srvCellItem->gNB_DU_System_Information->mIB_message.size);
1217    if(!srvCellItem->gNB_DU_System_Information->mIB_message.buf)
1218    {
1219       return RFAILED;
1220    }
1221    memcpy(srvCellItem->gNB_DU_System_Information->mIB_message.buf, duCfgParam.srvdCellLst[0].duSysInfo.mibMsg, \
1222                    srvCellItem->gNB_DU_System_Information->mIB_message.size);
1223
1224    /* SIB1 */
1225    srvCellItem->gNB_DU_System_Information->sIB1_message.size =\
1226                                                               duCfgParam.srvdCellLst[0].duSysInfo.sib1Len;
1227
1228    DU_ALLOC(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,
1229          srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1230    if(!srvCellItem->gNB_DU_System_Information->sIB1_message.buf)
1231    {
1232       return RFAILED;
1233    }
1234    for(int x=0; x<srvCellItem->gNB_DU_System_Information->sIB1_message.size; x++)
1235    {
1236       srvCellItem->gNB_DU_System_Information->sIB1_message.buf[x]=\
1237                                                                   duCfgParam.srvdCellLst[0].duSysInfo.sib1Msg[x];
1238    }
1239    return ROK;
1240 }
1241 /*******************************************************************
1242  *
1243  * @brief Builds RRC Version
1244  *
1245  * @details
1246  *
1247  *    Function : BuildRrcVer
1248  *
1249  *    Functionality: Building RRC Version
1250  *
1251  * @params[in] int idx,int elementCnt,RRC_Version_t *rrcver
1252  * @return ROK     - success
1253  *         RFAILED - failure
1254  *
1255  * ****************************************************************/
1256 uint8_t BuildRrcVer(RRC_Version_t *rrcVer)
1257 {
1258    uint8_t rrcExt;
1259    uint8_t rrcLatest;
1260    rrcVer->latest_RRC_Version.size = sizeof(uint8_t);
1261    DU_ALLOC(rrcVer->latest_RRC_Version.buf,sizeof(uint8_t));
1262    if(rrcVer->latest_RRC_Version.buf == NULLP)
1263    {
1264       return RFAILED;
1265    }
1266    rrcVer->latest_RRC_Version.buf[0] = 0;
1267    rrcVer->latest_RRC_Version.bits_unused = 5;
1268    DU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1269    if(rrcVer->iE_Extensions == NULLP)
1270    {
1271       return RFAILED;
1272    }
1273    rrcVer->iE_Extensions->list.count = 1;
1274    rrcVer->iE_Extensions->list.size = sizeof(RRC_Version_ExtIEs_t *);
1275    DU_ALLOC(rrcVer->iE_Extensions->list.array,rrcVer->iE_Extensions->list.size);
1276    if(rrcVer->iE_Extensions->list.array == NULLP)
1277    {
1278       return RFAILED;
1279    }
1280    rrcExt = 0;
1281    DU_ALLOC(rrcVer->iE_Extensions->list.array[0],\
1282          sizeof(RRC_Version_ExtIEs_t));
1283    if(rrcVer->iE_Extensions->list.array[0] == NULLP)
1284    {
1285       return RFAILED;
1286    }
1287    rrcVer->iE_Extensions->list.array[rrcExt]->id = \
1288                                                    ProtocolIE_ID_id_latest_RRC_Version_Enhanced;
1289    rrcVer->iE_Extensions->list.array[rrcExt]->criticality = Criticality_reject;
1290    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.present =\
1291                                                                       RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
1292    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1293       .Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
1294    DU_ALLOC(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1295          .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1296          array[rrcExt]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1297    if(rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice\
1298          .Latest_RRC_Version_Enhanced.buf == NULLP)
1299    {
1300       return RFAILED;
1301    }
1302    rrcLatest = 0;
1303    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1304       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 15;
1305    rrcLatest++;
1306    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1307       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 5;
1308    rrcLatest++;
1309    rrcVer->iE_Extensions->list.array[rrcExt]->extensionValue.choice.\
1310       Latest_RRC_Version_Enhanced.buf[rrcLatest] = 0;
1311    return ROK;
1312 }
1313 /*******************************************************************
1314  *
1315  * @brief Sends F1 msg over SCTP
1316  *
1317  * @details
1318  *
1319  *    Function : sendF1APMsg
1320  *
1321  *    Functionality: Sends F1 msg over SCTP
1322  *
1323  * @params[in] Region region
1324  *             Pool pool
1325  * @return ROK     - success
1326  *         RFAILED - failure
1327  *
1328  * ****************************************************************/
1329 uint8_t sendF1APMsg()
1330 {
1331    Buffer *mBuf = NULLP;
1332
1333    if(ODU_GET_MSG_BUF(DU_APP_MEM_REGION, DU_POOL, &mBuf) == ROK)
1334    {
1335       if(ODU_ADD_POST_MSG_MULT((Data *)encBuf, encBufSize, mBuf) == ROK)
1336       {
1337             ODU_PRINT_MSG(mBuf, 0,0);
1338
1339             if(sctpSend(mBuf, F1_INTERFACE) != ROK)
1340             {
1341                DU_LOG("\nERROR  -->  F1AP : SCTP Send failed");
1342                ODU_PUT_MSG_BUF(mBuf);
1343                return RFAILED;
1344             }
1345       }
1346       else
1347       {
1348          DU_LOG("\nERROR  -->  F1AP : ODU_ADD_POST_MSG_MULT failed");
1349          ODU_PUT_MSG_BUF(mBuf);
1350          return RFAILED;
1351       }
1352       ODU_PUT_MSG_BUF(mBuf);
1353    }
1354    else
1355    {
1356       DU_LOG("\nERROR  -->  F1AP : Failed to allocate memory");
1357       return RFAILED;
1358    }
1359    return ROK;
1360 } /* sendF1APMsg */
1361
1362 /*******************************************************************
1363  *
1364  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1365  *
1366  * @details
1367  *
1368  *    Function :  FreeRrcVer
1369  *
1370  *    Functionality: deallocating the memory of function BuildRrcVer
1371  *
1372  * @params[in] RRC_Version_t *rrcVer
1373  *
1374  * @return void
1375  *
1376  *****************************************************************/
1377 void FreeRrcVer(RRC_Version_t *rrcVer)
1378 {
1379    if(rrcVer->latest_RRC_Version.buf != NULLP)
1380    {
1381       if(rrcVer->iE_Extensions != NULLP)
1382       {
1383          if(rrcVer->iE_Extensions->list.array != NULLP)
1384          {
1385             if(rrcVer->iE_Extensions->list.array[0] != NULLP)
1386             {
1387                if(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf
1388                      != NULLP)
1389                {
1390                   DU_FREE(rrcVer->iE_Extensions->list.array[0]->extensionValue.choice\
1391                         .Latest_RRC_Version_Enhanced.buf,rrcVer->iE_Extensions->list.\
1392                         array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.size);
1393                }
1394                DU_FREE(rrcVer->iE_Extensions->list.array[0],sizeof(RRC_Version_ExtIEs_t));
1395             }
1396             DU_FREE(rrcVer->iE_Extensions->list.array,sizeof(RRC_Version_ExtIEs_t*));
1397          }
1398          DU_FREE(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
1399       }
1400       DU_FREE(rrcVer->latest_RRC_Version.buf,rrcVer->latest_RRC_Version.size);
1401    }
1402 }
1403 /*******************************************************************
1404  *
1405  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1406  *
1407  * @details
1408  *
1409  *    Function :  FreeServedCellList
1410  *
1411  *    Functionality:  deallocating the memory of function BuildServedCellList
1412
1413  *
1414  * @params[in] GNB_DU_Served_Cells_List_t *duServedCell
1415  *
1416  * @return void
1417  *
1418  * ****************************************************************/
1419 void FreeServedCellList( GNB_DU_Served_Cells_List_t *duServedCell)
1420 {
1421    uint8_t   plmnCnt=MAX_PLMN;
1422    uint8_t  extensionCnt=IE_EXTENSION_LIST_COUNT;
1423    uint8_t  plmnIdx=0, sliceIdx=0;
1424    GNB_DU_Served_Cells_Item_t *srvCellItem;
1425    ServedPLMNs_Item_t  *servedPlmnItem;
1426    SliceSupportItem_t  *sliceSupportItem;
1427
1428    if(duServedCell->list.array!=NULLP)
1429    {
1430       if(duServedCell->list.array[0]!=NULLP)
1431       {
1432          srvCellItem= &duServedCell->list.array[0]->value.choice.GNB_DU_Served_Cells_Item;
1433
1434          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1435                srvCellItem->served_Cell_Information.nRCGI.pLMN_Identity.size * sizeof(uint8_t));
1436          DU_FREE(srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1437                srvCellItem->served_Cell_Information.nRCGI.nRCellIdentity.size * sizeof(uint8_t));
1438
1439          if(srvCellItem->served_Cell_Information.fiveGS_TAC!=NULLP)
1440          {
1441             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC->buf,\
1442                   sizeof(srvCellItem->served_Cell_Information.fiveGS_TAC->size));
1443             DU_FREE(srvCellItem->served_Cell_Information.fiveGS_TAC,sizeof(FiveGS_TAC_t));
1444          }
1445
1446          if(srvCellItem->served_Cell_Information.servedPLMNs.list.array!=NULLP)
1447          {
1448             if(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx] != NULLP)
1449             {
1450                servedPlmnItem = srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx];
1451                DU_FREE(servedPlmnItem->pLMN_Identity.buf, servedPlmnItem->pLMN_Identity.size);
1452
1453                if(servedPlmnItem->iE_Extensions != NULLP)
1454                {
1455                   if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1456                   {
1457                      if(servedPlmnItem->iE_Extensions->list.array[0] != NULLP)
1458                      {
1459                         if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1460                         SliceSupportList.list.array != NULLP)
1461                         {
1462                            for(sliceIdx =0; sliceIdx<servedPlmnItem->iE_Extensions->list.array[0]->\
1463                            extensionValue.choice.SliceSupportList.list.count; sliceIdx++)
1464                            {
1465                               if(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1466                               SliceSupportList.list.array[sliceIdx] != NULLP)
1467                               {
1468                                  sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[0]->\
1469                                  extensionValue.choice.SliceSupportList.list.array[sliceIdx];
1470
1471                                  DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sizeof(uint8_t));
1472
1473                                  if(sliceSupportItem->sNSSAI.sD != NULLP)
1474                                  {
1475                                     DU_FREE(sliceSupportItem->sNSSAI.sD->buf,\
1476                                     sliceSupportItem->sNSSAI.sD->size);
1477                                     DU_FREE(sliceSupportItem->sNSSAI.sD, sizeof(OCTET_STRING_t));
1478                                  }
1479
1480                                  DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.\
1481                                  choice.SliceSupportList.list.array[sliceIdx], sizeof(SliceSupportItem_t));
1482                               }
1483                            }
1484                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[0]->extensionValue.choice.\
1485                            SliceSupportList.list.array, servedPlmnItem->iE_Extensions->list.array[0]->\
1486                            extensionValue.choice.SliceSupportList.list.size);
1487                         }
1488                         DU_FREE(servedPlmnItem->iE_Extensions->list.array[0],\
1489                         sizeof(ServedPLMNs_ItemExtIEs_t));
1490                      }
1491                      DU_FREE(servedPlmnItem->iE_Extensions->list.array,\
1492                      extensionCnt*sizeof(ServedPLMNs_ItemExtIEs_t*));
1493                   }
1494                   DU_FREE(servedPlmnItem->iE_Extensions, sizeof(ProtocolExtensionContainer_4624P3_t));
1495                }
1496                DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array[plmnIdx],\
1497                sizeof(ServedPLMNs_Item_t));
1498             }
1499             DU_FREE(srvCellItem->served_Cell_Information.servedPLMNs.list.array,\
1500             sizeof(ServedPLMNs_Item_t *));
1501          }
1502
1503          if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD != NULLP)
1504          {
1505             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.\
1506                   freqBandListNr.list.array != NULLP)
1507             {
1508                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
1509                uL_NRFreqInfo.freqBandListNr.list.array[0],sizeof(FreqBandNrItem_t));
1510                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->\
1511                uL_NRFreqInfo.freqBandListNr.list.array,sizeof(FreqBandNrItem_t*));
1512             }
1513
1514             if(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1515                   freqBandListNr.list.array)
1516             {
1517                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1518                      freqBandListNr.list.array[0],sizeof(FreqBandNrItem_t));
1519                DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.\
1520                      freqBandListNr.list.array,sizeof(FreqBandNrItem_t *));
1521             }
1522             DU_FREE(srvCellItem->served_Cell_Information.nR_Mode_Info.choice.fDD, sizeof(FDD_Info_t));
1523          }
1524
1525          DU_FREE(srvCellItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1526                srvCellItem->served_Cell_Information.measurementTimingConfiguration.size);
1527
1528          if(srvCellItem->gNB_DU_System_Information != NULLP)
1529          {
1530             if(srvCellItem->gNB_DU_System_Information->mIB_message.buf != NULLP)
1531             {
1532                DU_FREE(srvCellItem->gNB_DU_System_Information->mIB_message.buf,\
1533                      srvCellItem->gNB_DU_System_Information->mIB_message.size);
1534             }
1535
1536             if(srvCellItem->gNB_DU_System_Information->sIB1_message.buf != NULLP)
1537             {
1538                DU_FREE(srvCellItem->gNB_DU_System_Information->sIB1_message.buf,\
1539                      srvCellItem->gNB_DU_System_Information->sIB1_message.size);
1540             }
1541
1542             DU_FREE(srvCellItem->gNB_DU_System_Information, sizeof(GNB_DU_System_Information_t));
1543          }
1544
1545          DU_FREE(duServedCell->list.array[0], sizeof(GNB_DU_Served_Cells_ItemIEs_t));
1546       }
1547       DU_FREE(duServedCell->list.array, plmnCnt * sizeof(GNB_DU_Served_Cells_ItemIEs_t*));
1548    }
1549 }
1550
1551 /*******************************************************************
1552  *
1553  * @brief  deallocating the memory of function BuildAndSendF1SetupReq()
1554  *
1555  * @details
1556  *
1557  *    Function :  FreeF1SetupReq
1558  *
1559  *    Functionality:  deallocating the memory of function BuildAndSendF1SetupReq
1560  *
1561  * @params[in] F1AP_PDU_t *f1apMsg
1562  *
1563  * @return void
1564  *
1565  * ****************************************************************/
1566 void FreeF1SetupReq(F1AP_PDU_t *f1apMsg)
1567 {
1568    uint8_t ieIdx, ieIdx2;
1569    F1SetupRequest_t *f1SetupReq=NULLP;
1570
1571    if(f1apMsg != NULLP)
1572    {
1573       if(f1apMsg->choice.initiatingMessage != NULLP)
1574       {
1575          f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1576          if(f1SetupReq->protocolIEs.list.array != NULLP)
1577          {
1578             for(ieIdx = 0; ieIdx < f1SetupReq->protocolIEs.list.count; ieIdx++)
1579             {
1580                if(f1SetupReq->protocolIEs.list.array[ieIdx] != NULLP)
1581                {
1582                   switch(f1SetupReq->protocolIEs.list.array[ieIdx]->id)
1583                   {
1584                      case ProtocolIE_ID_id_TransactionID:
1585                         break;
1586                      case ProtocolIE_ID_id_gNB_DU_ID:
1587                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1588                               f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1589                         break;
1590                      case ProtocolIE_ID_id_gNB_DU_Name:
1591                         DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.buf,\
1592                               strlen((char *)duCfgParam.duName));
1593                         break;
1594                      case ProtocolIE_ID_id_gNB_DU_Served_Cells_List:
1595                         FreeServedCellList(&f1SetupReq->protocolIEs.list.\
1596                               array[ieIdx]->value.choice.GNB_DU_Served_Cells_List);
1597                         break;
1598                      case ProtocolIE_ID_id_GNB_DU_RRC_Version:
1599                         FreeRrcVer(&f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version);
1600                         break;
1601                      default:
1602                         DU_LOG("\nERROR  -->  Invalid Event Type %ld", f1SetupReq->protocolIEs.list.array[ieIdx]->id);
1603                         break;
1604                   }
1605                }
1606             }
1607             for(ieIdx2=0; ieIdx2< ieIdx; ieIdx2++)
1608             {
1609                DU_FREE(f1SetupReq->protocolIEs.list.array[ieIdx2],sizeof(F1SetupRequestIEs_t));
1610             }
1611             DU_FREE(f1SetupReq->protocolIEs.list.array,\
1612                   f1SetupReq->protocolIEs.list.size);
1613          }
1614          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1615       }
1616       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
1617    }
1618 }
1619 /*******************************************************************
1620  *
1621  * @brief Builds and Send the F1SetupRequest
1622  *
1623  * @details
1624  *
1625  *    Function : BuildAndSendF1SetupReq
1626  *
1627  * Functionality:Fills the F1SetupRequest
1628  *
1629  * @return ROK     - success
1630  *         RFAILED - failure
1631  *
1632  ******************************************************************/
1633 uint8_t BuildAndSendF1SetupReq()
1634 {
1635    uint8_t   ret, ieIdx, elementCnt;
1636    F1AP_PDU_t                 *f1apMsg = NULLP;
1637    F1SetupRequest_t           *f1SetupReq=NULLP;
1638    GNB_DU_Served_Cells_List_t *duServedCell=NULLP;
1639    RRC_Version_t              *rrcVer=NULLP;
1640    asn_enc_rval_t             encRetVal;        /* Encoder return value */
1641    ret= RFAILED;
1642
1643    DU_LOG("\nINFO   -->  F1AP : Building F1 Setup Request\n");
1644    do
1645    {
1646       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
1647       if(f1apMsg == NULLP)
1648       {
1649          break;
1650       }
1651       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
1652       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
1653       if(f1apMsg->choice.initiatingMessage == NULLP)
1654       {
1655          break;
1656       }
1657       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_F1Setup;
1658       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
1659       f1apMsg->choice.initiatingMessage->value.present = \
1660                                                          InitiatingMessage__value_PR_F1SetupRequest;
1661
1662       f1SetupReq = &f1apMsg->choice.initiatingMessage->value.choice.F1SetupRequest;
1663
1664       elementCnt = (duCfgParam.duName != NULL) ? 5 : 4;
1665
1666       f1SetupReq->protocolIEs.list.count = elementCnt;
1667       f1SetupReq->protocolIEs.list.size = elementCnt * sizeof(F1SetupRequestIEs_t );
1668
1669       /* Initialize the F1Setup members */
1670       DU_ALLOC(f1SetupReq->protocolIEs.list.array,f1SetupReq->protocolIEs.list.size);
1671       if(f1SetupReq->protocolIEs.list.array == NULLP)
1672       {
1673          break;
1674       }
1675       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
1676       {
1677          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx],\
1678                sizeof(F1SetupRequestIEs_t));
1679          if(f1SetupReq->protocolIEs.list.array[ieIdx] == NULLP)
1680          {
1681             break;
1682          }
1683       }
1684
1685       ieIdx = 0;
1686       /*TransactionID*/
1687       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_TransactionID;
1688       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1689       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present =\
1690                                                                F1SetupRequestIEs__value_PR_TransactionID;
1691       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = \
1692                                                                              TRANS_ID;
1693
1694       /*DU ID*/
1695       ieIdx++;
1696       f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
1697       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1698       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1699                                                                 F1SetupRequestIEs__value_PR_GNB_DU_ID;
1700       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size =\
1701                                                                              sizeof(uint8_t);
1702
1703       DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
1704             f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
1705       if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == \
1706             NULLP)
1707       {
1708          break;
1709       }
1710
1711       f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] =\
1712          duCfgParam.duId;
1713
1714       /*DU Name*/
1715       if(duCfgParam.duName != NULL)
1716       {
1717          ieIdx++;
1718          f1SetupReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_Name;
1719          f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_ignore;
1720          f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = F1SetupRequestIEs__value_PR_GNB_DU_Name;
1721          f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.size =\
1722             strlen((char *)duCfgParam.duName);
1723          DU_ALLOC(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.\
1724                GNB_DU_Name.buf, strlen((char *)duCfgParam.duName));
1725          if(f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_Name.\
1726                buf == NULLP)
1727          {
1728             break;
1729          }
1730          strcpy((char*)f1SetupReq->protocolIEs.list.array[ieIdx]->value.\
1731                choice.GNB_DU_Name.buf,
1732                (char*)&duCfgParam.duName);
1733
1734       }
1735
1736       /*Served Cell list */
1737       ieIdx++;
1738       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1739                                                      ProtocolIE_ID_id_gNB_DU_Served_Cells_List;
1740       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1741       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1742                                                                 F1SetupRequestIEs__value_PR_GNB_DU_Served_Cells_List;
1743       duServedCell = &f1SetupReq->protocolIEs.list.\
1744                      array[ieIdx]->value.choice.GNB_DU_Served_Cells_List;
1745       if(BuildServedCellList(duServedCell))
1746       {
1747          break;
1748       }
1749       /*RRC Version*/
1750       ieIdx++;
1751       f1SetupReq->protocolIEs.list.array[ieIdx]->id = \
1752                                                      ProtocolIE_ID_id_GNB_DU_RRC_Version ;
1753       f1SetupReq->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
1754       f1SetupReq->protocolIEs.list.array[ieIdx]->value.present = \
1755                                                                 F1SetupRequestIEs__value_PR_RRC_Version;
1756       rrcVer = &f1SetupReq->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
1757       if(BuildRrcVer(rrcVer))
1758       {
1759          break;
1760       }
1761       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
1762
1763       /* Encode the F1SetupRequest type as APER */
1764       memset(encBuf, 0, ENC_BUF_MAX_LEN);
1765       encBufSize = 0;
1766       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
1767             encBuf);
1768
1769       /* Encode results */
1770       if(encRetVal.encoded == ENCODE_FAIL)
1771       {
1772          DU_LOG("\nERROR  -->  F1AP : Could not encode F1SetupRequest structure (at %s)\n",\
1773                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
1774          break;
1775       }
1776       else
1777       {
1778          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1SetupRequest\n");
1779          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
1780          {
1781             printf("%x",encBuf[ieIdx]);
1782          }
1783       }
1784
1785       /* Sending msg */
1786       if(sendF1APMsg() != ROK)
1787       {
1788          DU_LOG("\nERROR  -->  F1AP : Sending F1 Setup request failed");
1789          break;
1790       }
1791
1792       ret=ROK;
1793       break;
1794    }while(true);
1795
1796    FreeF1SetupReq(f1apMsg);
1797
1798    return ret;
1799 }/* End of BuildAndSendF1SetupReq */
1800
1801 /*******************************************************************
1802  *
1803  * @brief Deallocating memory allocated for Served_Cells_To_Modify_Item_t
1804  *
1805  * @details
1806  *
1807  *    Function : freeCellsToModifyItem
1808  *
1809  *    Functionality: Deallocating memory of variables allocated in
1810  *                    BuildAndSendDUConfigUpdate function
1811  *
1812  * @params[in]  Served_Cells_To_Modify_Item_t *modifyItem
1813  *
1814  * @return ROK     - void
1815  *
1816  * ****************************************************************/
1817
1818 void freeCellsToModifyItem(Served_Cells_To_Modify_Item_t *modifyItem)
1819 {
1820    uint8_t arrIdx=0, servedPlmnIdx=0, sliceLstIdx=0;
1821    ServedPLMNs_Item_t *servedPlmnItem = NULLP;
1822    SliceSupportItem_t *sliceSupportItem = NULLP;
1823
1824    DU_FREE(modifyItem->oldNRCGI.pLMN_Identity.buf, modifyItem->oldNRCGI.pLMN_Identity.size);
1825    DU_FREE(modifyItem->oldNRCGI.nRCellIdentity.buf, modifyItem->oldNRCGI.nRCellIdentity.size);
1826
1827    DU_FREE(modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.buf,\
1828            modifyItem->served_Cell_Information.nRCGI.pLMN_Identity.size);
1829    DU_FREE(modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.buf,\
1830          modifyItem->served_Cell_Information.nRCGI.nRCellIdentity.size);
1831
1832    if(modifyItem->served_Cell_Information.servedPLMNs.list.array != NULLP)
1833    {
1834       if(modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx] != NULLP)
1835       {
1836          servedPlmnItem = modifyItem->served_Cell_Information.servedPLMNs.list.array[arrIdx];
1837
1838          DU_FREE(servedPlmnItem->pLMN_Identity.buf,servedPlmnItem->pLMN_Identity.size);
1839
1840          if(servedPlmnItem->iE_Extensions != NULLP)
1841          {
1842             if(servedPlmnItem->iE_Extensions->list.array != NULLP)
1843             {
1844                if(servedPlmnItem->iE_Extensions->list.array[arrIdx] != NULLP)
1845                {
1846                   if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1847                         list.array != NULLP)
1848                   {
1849                      for(sliceLstIdx =0; sliceLstIdx<servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
1850                            extensionValue.choice.SliceSupportList.list.count; sliceLstIdx++)
1851                      {
1852                         if(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.SliceSupportList.\
1853                               list.array[sliceLstIdx] != NULLP)
1854                         {
1855
1856                            sliceSupportItem = servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1857                                               SliceSupportList.list.array[sliceLstIdx];
1858
1859                            DU_FREE(sliceSupportItem->sNSSAI.sST.buf, sliceSupportItem->sNSSAI.sST.size);
1860                            if(sliceSupportItem->sNSSAI.sD != NULLP)
1861                            {
1862                               DU_FREE(sliceSupportItem->sNSSAI.sD->buf, sliceSupportItem->sNSSAI.sD->size);
1863                               DU_FREE(sliceSupportItem->sNSSAI.sD,sizeof(OCTET_STRING_t));
1864                            }
1865                            DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.choice.\
1866                                  SliceSupportList.list.array[sliceLstIdx], sizeof(SliceSupportItem_t));
1867                         }
1868                      }
1869                      DU_FREE(servedPlmnItem->iE_Extensions->list.array[arrIdx]->extensionValue.\
1870                            choice.SliceSupportList.list.array,\
1871                            servedPlmnItem->iE_Extensions->list.array[arrIdx]->\
1872                            extensionValue.choice.SliceSupportList.list.size);
1873                   }
1874                }
1875                for(servedPlmnIdx=0; servedPlmnIdx< servedPlmnItem->iE_Extensions->list.count ; servedPlmnIdx++)
1876                {
1877                   DU_FREE(servedPlmnItem->iE_Extensions->list.array[servedPlmnIdx], sizeof(ServedPLMNs_ItemExtIEs_t ));
1878                }
1879                DU_FREE(servedPlmnItem->iE_Extensions->list.array, servedPlmnItem->iE_Extensions->list.size);
1880             }
1881             DU_FREE(servedPlmnItem->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
1882          }
1883       }
1884       for(servedPlmnIdx=0; servedPlmnIdx<modifyItem->served_Cell_Information.servedPLMNs.list.count; servedPlmnIdx++)
1885       {
1886          DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array[servedPlmnIdx], sizeof(ServedPLMNs_Item_t));
1887       }
1888       DU_FREE(modifyItem->served_Cell_Information.servedPLMNs.list.array,\
1889          modifyItem->served_Cell_Information.servedPLMNs.list.size);
1890    }
1891
1892    if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD != NULLP)
1893    {
1894       if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1895       {
1896          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
1897                array[arrIdx], sizeof(FreqBandNrItem_t));
1898          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array, \
1899                modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size);
1900       }
1901
1902       if(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array != NULLP)
1903       {
1904          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.\
1905              array[arrIdx], sizeof(FreqBandNrItem_t));
1906          DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,\
1907                modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
1908       }
1909       DU_FREE(modifyItem->served_Cell_Information.nR_Mode_Info.choice.fDD,sizeof(FDD_Info_t));
1910    }
1911
1912    DU_FREE(modifyItem->served_Cell_Information.measurementTimingConfiguration.buf,\
1913       modifyItem->served_Cell_Information.measurementTimingConfiguration.size);
1914 }
1915
1916 /*******************************************************************
1917  *
1918  * @brief Deallocating memory of BuildAndSendDUConfigUpdate
1919  *
1920  * @details
1921  *
1922  *    Function : FreeDUConfigUpdate
1923  *
1924  *    Functionality: Deallocating memory of variables allocated in
1925  *                    BuildAndSendDUConfigUpdate function
1926  *
1927  * @params[in]  F1AP_PDU_t *f1apDuCfg
1928  *
1929  * @return ROK     - void
1930  *
1931  * ****************************************************************/
1932 void FreeDUConfigUpdate(F1AP_PDU_t *f1apDuCfg)
1933 {
1934    uint8_t  ieIdx=0, cellModifyIdx=0, cellDeleteIdx=0;
1935    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
1936    Served_Cells_To_Modify_List_t  *cellsToModify=NULLP;
1937    Served_Cells_To_Delete_List_t  *cellsToDelete=NULLP;
1938    Served_Cells_To_Delete_Item_t  *deleteItem = NULLP;
1939    Served_Cells_To_Delete_ItemIEs_t *deleteItemIe = NULLP;
1940
1941    if(f1apDuCfg != NULLP)
1942    {
1943       if(f1apDuCfg->choice.initiatingMessage != NULLP)
1944       {
1945          duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->\
1946                        value.choice.GNBDUConfigurationUpdate;
1947          if(duCfgUpdate->protocolIEs.list.array != NULLP)
1948          {
1949             for(ieIdx=0; ieIdx<duCfgUpdate->protocolIEs.list.count; ieIdx++)
1950             {
1951                if(duCfgUpdate->protocolIEs.list.array[ieIdx] != NULLP)
1952                {
1953                   switch(duCfgUpdate->protocolIEs.list.array[ieIdx]->id)
1954                   {
1955                      case ProtocolIE_ID_id_Served_Cells_To_Modify_List:
1956                         {
1957                            cellsToModify = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1958                                            value.choice.Served_Cells_To_Modify_List;
1959                            if(cellsToModify->list.array != NULLP)
1960                            {
1961                               for(cellModifyIdx=0; cellModifyIdx<cellsToModify->list.count ;cellModifyIdx++)
1962                               {
1963                                  if(cellsToModify->list.array[cellModifyIdx] != NULLP)
1964                                  {
1965                                     freeCellsToModifyItem(&cellsToModify->list.array[cellModifyIdx]->value.choice.\
1966                                           Served_Cells_To_Modify_Item);
1967                                     DU_FREE(cellsToModify->list.array[cellModifyIdx],\
1968                                           sizeof(Served_Cells_To_Modify_ItemIEs_t));
1969                                  }
1970                               }
1971                               DU_FREE(cellsToModify->list.array,cellsToModify->list.size);
1972                            }
1973                            break;
1974                         }
1975                      case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
1976                         {
1977                            cellsToDelete = &duCfgUpdate->protocolIEs.list.array[ieIdx]->\
1978                                            value.choice.Served_Cells_To_Delete_List;
1979                            if(cellsToDelete->list.array != NULLP)
1980                            {
1981                               for(cellDeleteIdx=0; cellDeleteIdx<cellsToDelete->list.count ;cellDeleteIdx++)
1982                               {
1983                                  if(cellsToDelete->list.array[cellDeleteIdx] != NULLP)
1984                                  {
1985                                     deleteItemIe = ((Served_Cells_To_Delete_ItemIEs_t*)\
1986                                           cellsToDelete->list.array[cellDeleteIdx]);
1987                                     deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
1988                                     DU_FREE(deleteItem->oldNRCGI.pLMN_Identity.buf,\
1989                                           deleteItem->oldNRCGI.pLMN_Identity.size);
1990                                     DU_FREE(deleteItem->oldNRCGI.nRCellIdentity.buf,\
1991                                           deleteItem->oldNRCGI.nRCellIdentity.size);
1992                                     DU_FREE(cellsToDelete->list.array[cellDeleteIdx],\
1993                                           sizeof(Served_Cells_To_Delete_ItemIEs_t));
1994                                  }
1995                               }
1996                               DU_FREE(cellsToDelete->list.array,cellsToDelete->list.size);
1997                            }
1998
1999                            break;
2000                         }
2001                      case ProtocolIE_ID_id_gNB_DU_ID:
2002                         {
2003                            DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2004                                  duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2005                            break;
2006                         }
2007                   }
2008                   DU_FREE(duCfgUpdate->protocolIEs.list.array[ieIdx],\
2009                         sizeof(GNBDUConfigurationUpdateIEs_t));
2010                }
2011             }
2012             DU_FREE(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2013          }
2014          DU_FREE(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2015       }
2016       DU_FREE(f1apDuCfg, (Size)sizeof(F1AP_PDU_t));
2017    }
2018 }
2019
2020 /*******************************************************************
2021  *
2022  * @brief Fills Served Plmns required in ServCellInfo IE
2023  *
2024  * @details
2025  *
2026  *    Function : fillServedPlmns
2027  *
2028  *    Functionality: Fills Served Plmns required in ServCellInfo IE
2029  *
2030  * @params[in] Pointer to ServedPLMNs_List_t *
2031  *
2032  * @return ROK     - success
2033  *         RFAILED - failure
2034  *
2035  *****************************************************************/
2036
2037 uint8_t fillServedPlmns(ServedPLMNs_List_t *servedPlmn)
2038 {
2039    uint8_t ieIdx=0, arrayIdx=0, ieListCnt=0, elementCnt=0, sliceLstIdx=0;
2040
2041    servedPlmn->list.array[arrayIdx]->pLMN_Identity.size = 3*sizeof(uint8_t);
2042    DU_ALLOC(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf, servedPlmn->list.\
2043          array[arrayIdx]->pLMN_Identity.size);
2044    if(servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf == NULLP)
2045    {
2046       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2047       return RFAILED;
2048    }
2049    buildPlmnId(duCfgParam.srvdCellLst[arrayIdx].duCellInfo.cellInfo.srvdPlmn[arrayIdx].plmn,\
2050          servedPlmn->list.array[arrayIdx]->pLMN_Identity.buf);
2051    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P3_t));
2052    if(servedPlmn->list.array[arrayIdx]->iE_Extensions == NULLP)
2053    {
2054       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2055       return RFAILED;
2056    }
2057
2058    ieListCnt=1;
2059    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.count = ieListCnt;
2060    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.size = ieListCnt *sizeof(ServedPLMNs_ItemExtIEs_t *);
2061    DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array,servedPlmn->list.array[arrayIdx]->\
2062          iE_Extensions->list.size);
2063    if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array == NULLP)
2064    {
2065       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2066       return RFAILED;
2067    }
2068    for(ieIdx=arrayIdx;ieIdx<ieListCnt;ieIdx++)
2069    {
2070       DU_ALLOC(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx],\
2071             sizeof(ServedPLMNs_ItemExtIEs_t));
2072       if(servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx] == NULLP)
2073       {
2074          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2075          return RFAILED;
2076       }
2077    }
2078
2079    ieIdx = 0;
2080    elementCnt = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.srvdPlmn[0].taiSliceSuppLst.numSupportedSlices;
2081    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->id =ProtocolIE_ID_id_TAISliceSupportList;
2082    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->criticality = Criticality_ignore;
2083    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.present = \
2084    ServedPLMNs_ItemExtIEs__extensionValue_PR_SliceSupportList;
2085    servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2086       list.count = elementCnt;
2087    servedPlmn->list.array[arrayIdx]->\
2088       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2089       list.size = elementCnt * sizeof(SliceSupportItem_t *);
2090    DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2091          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2092          list.array,servedPlmn->list.array[arrayIdx]->\
2093          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.size);
2094    if(servedPlmn->list.array[arrayIdx]->\
2095          iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2096          list.array == NULLP)
2097    {
2098       DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2099       return RFAILED;
2100    }
2101
2102    for(sliceLstIdx =0; sliceLstIdx< elementCnt; sliceLstIdx++)
2103    {
2104       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2105       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2106       list.array[sliceLstIdx],sizeof( SliceSupportItem_t));
2107       if(servedPlmn->list.array[arrayIdx]->\
2108       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2109       list.array[sliceLstIdx] == NULLP)
2110       {
2111          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2112          return RFAILED;
2113       }
2114
2115       servedPlmn->list.array[arrayIdx]->\
2116       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2117       list.array[sliceLstIdx]->sNSSAI.sST.size = sizeof(uint8_t);
2118       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2119       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2120       list.array[sliceLstIdx]->sNSSAI.sST.buf,servedPlmn->list.array[arrayIdx]->\
2121       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.list.array[sliceLstIdx]->\
2122       sNSSAI.sST.size);
2123
2124       if(servedPlmn->list.array[arrayIdx]->\
2125       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2126       list.array[sliceLstIdx]->sNSSAI.sST.buf == NULLP)
2127       {
2128          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2129          return RFAILED;
2130       }
2131       servedPlmn->list.array[arrayIdx]->\
2132       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2133       list.array[sliceLstIdx]->sNSSAI.sST.buf[arrayIdx] =  duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
2134       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sst;
2135
2136       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2137       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2138       list.array[sliceLstIdx]->sNSSAI.sD,sizeof(OCTET_STRING_t));
2139       if(servedPlmn->list.array[arrayIdx]->\
2140       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2141       list.array[sliceLstIdx]->sNSSAI.sD == NULLP)
2142       {
2143          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2144          return RFAILED;
2145       }
2146       servedPlmn->list.array[arrayIdx]->\
2147       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2148       list.array[sliceLstIdx]->sNSSAI.sD->size = 3 * sizeof(uint8_t);
2149       DU_ALLOC(servedPlmn->list.array[arrayIdx]->\
2150       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2151       list.array[sliceLstIdx]->sNSSAI.sD->buf,servedPlmn->list.array[arrayIdx]->\
2152       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2153       list.array[sliceLstIdx]->sNSSAI.sD->size);
2154       if(servedPlmn->list.array[arrayIdx]->\
2155       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2156       list.array[sliceLstIdx]->sNSSAI.sD->buf == NULLP)
2157       {
2158          DU_LOG("ERROR  --> DU_APP : fillServedPlmns(): Memory allocation failed");
2159          return RFAILED;
2160       }
2161       memcpy(servedPlmn->list.array[arrayIdx]->\
2162       iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2163       list.array[sliceLstIdx]->sNSSAI.sD->buf, duCfgParam.srvdCellLst[arrayIdx].duCellInfo.\
2164       cellInfo.srvdPlmn[arrayIdx].taiSliceSuppLst.snssai[sliceLstIdx]->sd,\
2165       servedPlmn->list.array[arrayIdx]->iE_Extensions->list.array[ieIdx]->extensionValue.choice.SliceSupportList.\
2166       list.array[sliceLstIdx]->sNSSAI.sD->size);
2167    }
2168    return ROK;
2169 }
2170
2171 /*******************************************************************
2172  *
2173  * @brief Fills Nr Fdd Info required in ServCellInfo IE
2174  *
2175  * @details
2176  *
2177  *    Function : fillNrFddInfo
2178  *
2179  *    Functionality: Fills Nr Fdd Info required in ServCellInfo IE
2180  *
2181  * @params[in] Pointer to NR_Mode_Info_t *
2182  *
2183  * @return ROK     - success
2184  *         RFAILED - failure
2185  *
2186  *****************************************************************/
2187
2188 uint8_t fillNrFddInfo(NR_Mode_Info_t *nrFdd)
2189 {
2190    nrFdd->choice.fDD->uL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.\
2191       f1Mode.mode.fdd.ulNrFreqInfo.nrArfcn;
2192    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.count = 1;
2193    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t*);
2194    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.\
2195          array, nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.size);
2196    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2197    {
2198       return RFAILED;
2199    }
2200    DU_ALLOC(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0], \
2201       sizeof(FreqBandNrItem_t));
2202    if(nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2203    {
2204       return RFAILED;
2205    }
2206    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2207       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.ulNrFreqInfo.\
2208       freqBand[0].nrFreqBand;
2209    nrFdd->choice.fDD->uL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2210    nrFdd->choice.fDD->dL_NRFreqInfo.nRARFCN = duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.\
2211       dlNrFreqInfo.nrArfcn;
2212    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.count = 1;
2213    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size = sizeof(FreqBandNrItem_t *);
2214    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array,nrFdd->\
2215          choice.fDD->dL_NRFreqInfo.freqBandListNr.list.size);
2216    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array == NULLP)
2217    {
2218       return RFAILED;
2219    }
2220    DU_ALLOC(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0],\
2221          sizeof(FreqBandNrItem_t));
2222    if(nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0] == NULLP)
2223    {
2224       return RFAILED;
2225    }
2226    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->freqBandIndicatorNr = \
2227       duCfgParam.srvdCellLst[0].duCellInfo.f1Mode.mode.fdd.dlNrFreqInfo.\
2228       freqBand[0].nrFreqBand;
2229    nrFdd->choice.fDD->dL_NRFreqInfo.freqBandListNr.list.array[0]->supportedSULBandList.list.count=0;
2230
2231    /*Transmission Bandwidth*/
2232    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2233       f1Mode.mode.fdd.ulTxBw.nrScs;
2234    nrFdd->choice.fDD->uL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2235       f1Mode.mode.fdd.ulTxBw.nrb;
2236    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRSCS = duCfgParam.srvdCellLst[0].duCellInfo.\
2237       f1Mode.mode.fdd.dlTxBw.nrScs;
2238    nrFdd->choice.fDD->dL_Transmission_Bandwidth.nRNRB = duCfgParam.srvdCellLst[0].duCellInfo.\
2239       f1Mode.mode.fdd.dlTxBw.nrb;
2240
2241    return ROK;
2242 }
2243
2244 /*******************************************************************
2245  *
2246  * @brief Fills ServCellInfo IE
2247  *
2248  * @details
2249  *
2250  *    Function : fillServedCellInfo
2251  *
2252  *    Functionality: Fills ServCellInfo
2253  *
2254  * @params[in] Pointer to Served_Cell_Information_t *
2255  *
2256  * @return ROK     - success
2257  *         RFAILED - failure
2258  *
2259  *****************************************************************/
2260
2261 uint8_t fillServedCellInfo(Served_Cell_Information_t *srvCellInfo)
2262 {
2263    uint8_t tmp, ieIdx, ieListCnt;
2264
2265    /*nRCGI*/
2266    srvCellInfo->nRCGI.pLMN_Identity.size =3*sizeof(uint8_t);
2267    DU_ALLOC(srvCellInfo->nRCGI.pLMN_Identity.buf,\
2268          srvCellInfo->nRCGI.pLMN_Identity.size);
2269    if(srvCellInfo->nRCGI.pLMN_Identity.buf == NULLP)
2270    {
2271       return RFAILED;
2272    }
2273    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2274          srvCellInfo->nRCGI.pLMN_Identity.buf);
2275    srvCellInfo->nRCGI.nRCellIdentity.size =5*sizeof(uint8_t);
2276    DU_ALLOC(srvCellInfo->nRCGI.nRCellIdentity.buf,\
2277          srvCellInfo->nRCGI.nRCellIdentity.size);
2278    if(srvCellInfo->nRCGI.nRCellIdentity.buf == NULLP)
2279    {
2280       return RFAILED;
2281    }
2282    for (tmp = 0 ; tmp < srvCellInfo->\
2283          nRCGI.nRCellIdentity.size-1 ; tmp++)
2284    {
2285       srvCellInfo->nRCGI.nRCellIdentity.buf[tmp] = 0;
2286    }
2287    srvCellInfo->nRCGI.nRCellIdentity.buf[4] = 16;
2288    srvCellInfo->nRCGI.nRCellIdentity.bits_unused =4;
2289
2290    /*nRPCI*/
2291    srvCellInfo->nRPCI = duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrPci;
2292
2293    /*servedPLMNs*/
2294    ieListCnt = 1;
2295    srvCellInfo->servedPLMNs.list.count = ieListCnt;
2296    srvCellInfo->servedPLMNs.list.size = ieListCnt*sizeof(ServedPLMNs_Item_t *);
2297    DU_ALLOC(srvCellInfo->servedPLMNs.list.array,\
2298          srvCellInfo->servedPLMNs.list.size);
2299    if(srvCellInfo->servedPLMNs.list.array == NULLP)
2300    {
2301       return RFAILED;
2302    }
2303    for(ieIdx=0; ieIdx < ieListCnt; ieIdx++)
2304    {
2305       DU_ALLOC(srvCellInfo->servedPLMNs.list.array[ieIdx],\
2306             sizeof(ServedPLMNs_Item_t));
2307       if(srvCellInfo->servedPLMNs.list.array[ieIdx]== NULLP)
2308       {
2309          return RFAILED;
2310       }
2311    }
2312    if(fillServedPlmns(&srvCellInfo->servedPLMNs))
2313    {
2314       return RFAILED;
2315    }
2316
2317    /*nR Mode Info with FDD*/
2318    srvCellInfo->nR_Mode_Info.present = NR_Mode_Info_PR_fDD;
2319    DU_ALLOC(srvCellInfo->nR_Mode_Info.choice.fDD,\
2320          sizeof(FDD_Info_t));
2321    if(srvCellInfo->nR_Mode_Info.choice.fDD == NULLP)
2322    {
2323       return RFAILED;
2324    }
2325    if(fillNrFddInfo(&srvCellInfo->nR_Mode_Info))
2326       return RFAILED;
2327
2328    /*Measurement timing Config*/
2329    srvCellInfo->measurementTimingConfiguration.size = sizeof(uint8_t);
2330    DU_ALLOC(srvCellInfo->measurementTimingConfiguration.\
2331          buf,srvCellInfo->measurementTimingConfiguration.size);
2332    if(srvCellInfo->measurementTimingConfiguration.buf == NULLP)
2333    {
2334       return RFAILED;
2335    }
2336    srvCellInfo->measurementTimingConfiguration.\
2337          buf[0] = duCfgParam.srvdCellLst[0].duCellInfo.measTimeCfg;
2338
2339    return ROK;
2340 }
2341
2342 /*******************************************************************
2343  *
2344  * @brief Fills ServCellToModItem IE
2345  *
2346  * @details
2347  *
2348  *    Function : fillServCellToModItem
2349  *
2350  *    Functionality: Fills ServCellToModItem IE
2351  *
2352  * @params[in] Pointer to Served_Cells_To_Modify_Item_t *
2353  *
2354  * @return ROK     - success
2355  *         RFAILED - failure
2356  *
2357  *****************************************************************/
2358
2359 uint8_t fillServCellToModItem(Served_Cells_To_Modify_Item_t *modifyItem)
2360 {
2361    uint8_t ieIdx;
2362
2363    /*pLMN_Identity*/
2364    modifyItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2365    DU_ALLOC(modifyItem->oldNRCGI.pLMN_Identity.buf,modifyItem->oldNRCGI.pLMN_Identity.size);
2366    if(modifyItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2367    {
2368       return RFAILED;
2369    }
2370    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2371          modifyItem->oldNRCGI.pLMN_Identity.buf);
2372
2373    /*nRCellIdentity*/
2374    modifyItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2375    DU_ALLOC(modifyItem->oldNRCGI.nRCellIdentity.buf,\
2376          modifyItem->oldNRCGI.nRCellIdentity.size);
2377    if(modifyItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2378    {
2379       return RFAILED;
2380    }
2381    for(ieIdx = 0; ieIdx < modifyItem->oldNRCGI.nRCellIdentity.size-1; ieIdx++)
2382    {
2383       modifyItem->oldNRCGI.nRCellIdentity.buf[ieIdx] = 0;
2384    }
2385    modifyItem->oldNRCGI.nRCellIdentity.buf[4] = 16;
2386    modifyItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
2387
2388    if(fillServedCellInfo(&modifyItem->served_Cell_Information))
2389       return RFAILED;
2390    else
2391       return ROK;
2392 }
2393
2394 /*******************************************************************
2395  *
2396  * @brief Builds ServCellToModList
2397  *
2398  * @details
2399  *
2400  *    Function : buildServCellToModList
2401  *
2402  *    Functionality: Builds the serv cell to Mod List
2403  *
2404  * @params[in] Pointer to Served_Cells_To_Modify_List_t *
2405  *
2406  * @return ROK     - success
2407  *         RFAILED - failure
2408  *
2409  *****************************************************************/
2410
2411 uint8_t buildServCellToModList(Served_Cells_To_Modify_List_t *cellsToModify)
2412 {
2413    uint8_t ieListCnt, ieIdx;
2414    Served_Cells_To_Modify_Item_t *modifyItem = NULLP;
2415
2416    ieListCnt = 1;
2417    cellsToModify->list.count = ieListCnt;
2418    cellsToModify->list.size = ieListCnt*sizeof(Served_Cells_To_Modify_ItemIEs_t *);
2419    DU_ALLOC(cellsToModify->list.array,cellsToModify->list.size);
2420    if(cellsToModify->list.array == NULLP)
2421    {
2422       return RFAILED;
2423    }
2424    for(ieIdx=0; ieIdx< ieListCnt; ieIdx++)
2425    {
2426       DU_ALLOC(cellsToModify->list.array[ieIdx],sizeof(Served_Cells_To_Modify_ItemIEs_t));
2427       if(cellsToModify->list.array[ieIdx] == NULLP)
2428       {
2429          return RFAILED;
2430       }
2431    }
2432    cellsToModify->list.array[0]->id = ProtocolIE_ID_id_Served_Cells_To_Modify_Item;
2433    cellsToModify->list.array[0]->criticality = Criticality_reject;
2434    cellsToModify->list.array[0]->value.present =\
2435       Served_Cells_To_Modify_ItemIEs__value_PR_Served_Cells_To_Modify_Item;
2436    modifyItem=&cellsToModify->list.array[0]->value.choice.Served_Cells_To_Modify_Item;
2437
2438    if(fillServCellToModItem(modifyItem))
2439       return RFAILED;
2440    else
2441       return ROK;
2442 }
2443 /*******************************************************************
2444  *
2445  * @brief filling the DeleteItemList
2446  *
2447  * @details
2448  *
2449  *    Function : fillCellToDeleteItem
2450  *
2451  *    Functionality: Filling the DeleteItemIe
2452  *
2453  * @params[in] Pointer to Served_Cells_To_Delete_ItemIEs_t
2454  *
2455  * @return ROK     - success
2456  *         RFAILED - failure
2457  *
2458  *****************************************************************/
2459 uint8_t fillCellToDeleteItem(struct Served_Cells_To_Delete_ItemIEs *deleteItemIe)
2460 {
2461    uint8_t arrIdx;
2462    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
2463
2464    deleteItemIe->id = ProtocolIE_ID_id_Served_Cells_To_Delete_Item;
2465    deleteItemIe->criticality = Criticality_reject;
2466    deleteItemIe->value.present =\
2467    Served_Cells_To_Delete_ItemIEs__value_PR_Served_Cells_To_Delete_Item;
2468    deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
2469
2470    /*pLMN_Identity*/
2471    deleteItem->oldNRCGI.pLMN_Identity.size = 3*sizeof(uint8_t);
2472    DU_ALLOC(deleteItem->oldNRCGI.pLMN_Identity.buf,deleteItem->oldNRCGI.pLMN_Identity.size);
2473    if(deleteItem->oldNRCGI.pLMN_Identity.buf == NULLP)
2474    {
2475       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2476       return RFAILED;
2477    }
2478    buildPlmnId(duCfgParam.srvdCellLst[0].duCellInfo.cellInfo.nrCgi.plmn,\
2479          deleteItem->oldNRCGI.pLMN_Identity.buf);
2480
2481    /*nRCellIdentity*/
2482    deleteItem->oldNRCGI.nRCellIdentity.size = 5*sizeof(uint8_t);
2483    DU_ALLOC(deleteItem->oldNRCGI.nRCellIdentity.buf,\
2484          deleteItem->oldNRCGI.nRCellIdentity.size);
2485    if(deleteItem->oldNRCGI.nRCellIdentity.buf == NULLP)
2486    {
2487       DU_LOG("ERROR  --> F1AP: fillCellToDeleteItem(): Failed to allocate the memory");
2488       return RFAILED;
2489    }
2490    for(arrIdx = 0; arrIdx < deleteItem->oldNRCGI.nRCellIdentity.size-1; arrIdx++)
2491    {
2492       deleteItem->oldNRCGI.nRCellIdentity.buf[arrIdx] = 0;
2493    }
2494    deleteItem->oldNRCGI.nRCellIdentity.buf[4] = 16;
2495    deleteItem->oldNRCGI.nRCellIdentity.bits_unused = 4;
2496    return ROK;
2497 }
2498 /*******************************************************************
2499  *
2500  * @brief Builds ServCellToDeleteList
2501  *
2502  * @details
2503  *
2504  *    Function : buildServCellToDeleteList
2505  *
2506  *    Functionality: Builds the serv cell to delete List
2507  *
2508  * @params[in] Pointer to Served_Cells_To_Delete_List_t *
2509  *
2510  * @return ROK     - success
2511  *         RFAILED - failure
2512  *
2513  *****************************************************************/
2514
2515 uint8_t buildServCellToDeleteList(Served_Cells_To_Delete_List_t *cellsToDelete)
2516 {
2517    uint8_t ieListCnt, arrIdx;
2518
2519    ieListCnt = 1;
2520    cellsToDelete->list.count = ieListCnt;
2521    cellsToDelete->list.size = ieListCnt*sizeof(Served_Cells_To_Delete_ItemIEs_t *);
2522
2523    DU_ALLOC(cellsToDelete->list.array,cellsToDelete->list.size);
2524    if(cellsToDelete->list.array == NULLP)
2525    {
2526       DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2527       return RFAILED;
2528    }
2529
2530    for(arrIdx=0; arrIdx< ieListCnt; arrIdx++)
2531    {
2532       DU_ALLOC(cellsToDelete->list.array[arrIdx],sizeof(Served_Cells_To_Delete_ItemIEs_t));
2533       if(cellsToDelete->list.array[arrIdx] == NULLP)
2534       {
2535          DU_LOG("\nERROR  --> F1AP : buildServCellToDeleteList(): Memory allocation failed");
2536          return RFAILED;
2537       }
2538    }
2539
2540    arrIdx=0;
2541    if(fillCellToDeleteItem((Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx]) !=ROK)
2542    {
2543       DU_LOG("\nERROR  -->  F1AP: buildServCellToDeleteList(): failed to fill Served_Cells_To_Delete_ItemIEs");
2544       return RFAILED;
2545    }
2546    return ROK;
2547 }
2548
2549 /*******************************************************************
2550  *
2551  * @brief Builds and sends the DUConfigUpdate
2552  *
2553  * @details
2554  *
2555  *    Function : BuildAndSendDUConfigUpdate
2556  *
2557  *    Functionality: Constructs the DU Update message and sends
2558  *                   it to the CU through SCTP.
2559  *
2560  * @params[in] void **buf,Buffer to which encoded pattern is written into
2561  * @params[in] int *size,size of buffer
2562  *
2563  * @return ROK     - success
2564  *         RFAILED - failure
2565  *
2566  * ****************************************************************/
2567 uint8_t BuildAndSendDUConfigUpdate(ServCellAction servCellAction)
2568 {
2569    uint8_t ret =0, ieIdx=0, elementCnt=0;
2570    bool memAlloctionFailure = false;
2571    F1AP_PDU_t                 *f1apDuCfg = NULLP;
2572    GNBDUConfigurationUpdate_t *duCfgUpdate = NULLP;
2573    asn_enc_rval_t encRetVal;     /* Encoder return value */
2574
2575    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2576    ret= RFAILED;
2577
2578    while(true)
2579    {
2580       DU_LOG("\nINFO   -->  F1AP : Building DU config update\n");
2581       /* Allocate the memory for F1DuCfg */
2582       DU_ALLOC(f1apDuCfg, sizeof(F1AP_PDU_t));
2583       if(f1apDuCfg == NULLP)
2584       {
2585          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2586          break;
2587       }
2588
2589       f1apDuCfg->present = F1AP_PDU_PR_initiatingMessage;
2590       DU_ALLOC(f1apDuCfg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2591       if(f1apDuCfg->choice.initiatingMessage == NULLP)
2592       {
2593          DU_LOG("\nERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation for F1AP-PDU failed");
2594          break;
2595       }
2596
2597       f1apDuCfg->choice.initiatingMessage->procedureCode = \
2598                                                            ProcedureCode_id_gNBDUConfigurationUpdate;
2599       f1apDuCfg->choice.initiatingMessage->criticality = Criticality_reject;
2600       f1apDuCfg->choice.initiatingMessage->value.present = \
2601                                                            InitiatingMessage__value_PR_GNBDUConfigurationUpdate;
2602       duCfgUpdate = &f1apDuCfg->choice.initiatingMessage->value.\
2603                     choice.GNBDUConfigurationUpdate;
2604       elementCnt = 3;
2605       duCfgUpdate->protocolIEs.list.count = elementCnt;
2606       duCfgUpdate->protocolIEs.list.size = \
2607                                            elementCnt * sizeof(GNBDUConfigurationUpdateIEs_t*);
2608
2609       /* Initialize the F1Setup members */
2610       DU_ALLOC(duCfgUpdate->protocolIEs.list.array,duCfgUpdate->protocolIEs.list.size);
2611       if(duCfgUpdate->protocolIEs.list.array == NULLP)
2612       {
2613          DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2614          break;
2615       }
2616       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
2617       {
2618          DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx],sizeof(GNBDUConfigurationUpdateIEs_t));
2619          if(duCfgUpdate->protocolIEs.list.array[ieIdx] == NULLP)
2620          {
2621             DU_LOG("ERROR  -->  F1AP : BuildAndSendDUConfigUpdate(): Memory allocation failed");
2622             memAlloctionFailure = true;
2623             break;
2624          }
2625       }
2626
2627       if(memAlloctionFailure == true)
2628       {
2629          break;
2630       }
2631       /*TransactionID*/
2632       ieIdx = 0;
2633       duCfgUpdate->protocolIEs.list.array[ieIdx]->id=ProtocolIE_ID_id_TransactionID;
2634       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
2635       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2636       GNBDUConfigurationUpdateIEs__value_PR_TransactionID;
2637       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.TransactionID = TRANS_ID;
2638
2639       ieIdx++;
2640       if(servCellAction == SERV_CELL_TO_MODIFY)
2641       {
2642          /*Served Cell to Modify */
2643          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2644          ProtocolIE_ID_id_Served_Cells_To_Modify_List;
2645          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2646          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2647          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Modify_List;
2648          if(buildServCellToModList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2649                   Served_Cells_To_Modify_List))
2650          {
2651             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToModList");
2652             break;
2653          }
2654       }
2655       else
2656       {
2657          /*Served Cell to Delete */
2658          duCfgUpdate->protocolIEs.list.array[ieIdx]->id = \
2659          ProtocolIE_ID_id_Served_Cells_To_Delete_List;
2660          duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality =Criticality_reject;
2661          duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2662          GNBDUConfigurationUpdateIEs__value_PR_Served_Cells_To_Delete_List;
2663          if(buildServCellToDeleteList(&duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
2664          Served_Cells_To_Delete_List)!=ROK)
2665          {
2666             DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): failed to build ServCellToDeleteList");
2667             break;
2668          }
2669
2670       }
2671       // NOTE :GNB DU SYS INFO:MIB AND SIB1 INFORMATION TO BE BUILT AND FILLED HERE
2672       /*GNB DU ID */
2673       ieIdx++;
2674       duCfgUpdate->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_ID;
2675       duCfgUpdate->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
2676       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.present = \
2677       GNBDUConfigurationUpdateIEs__value_PR_GNB_DU_ID;
2678       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size = sizeof(uint8_t);
2679       DU_ALLOC(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf,\
2680             duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.size);
2681       if(duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf == NULLP)
2682       {
2683          DU_LOG("ERROR  --> DU APP : BuildAndSendDUConfigUpdate(): Memory allocation failed for GNB_DU_ID");
2684          break;
2685       }
2686       duCfgUpdate->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_ID.buf[0] = duCfgParam.duId;
2687
2688       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apDuCfg);
2689
2690       /* Encode the DU Config Update type as APER */
2691       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
2692       encBufSize = 0;
2693       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apDuCfg, PrepFinalEncBuf, encBuf);
2694
2695       /* Checking encode results */
2696       if(encRetVal.encoded == ENCODE_FAIL)
2697       {
2698          DU_LOG("ERROR  -->  F1AP : Could not encode DUConfigUpdate structure (at %s)\n",\
2699                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2700          break;
2701       }
2702       else
2703       {
2704          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DUConfigUpdate\n");
2705          for(ieIdx =0; ieIdx < encBufSize; ieIdx++)
2706          {
2707             printf("%x",encBuf[ieIdx]);
2708          }
2709       }
2710       /* Sending msg */
2711       if(sendF1APMsg() != ROK)
2712       {
2713          DU_LOG("\nERROR  -->  F1AP : Sending GNB-DU Config Update failed");
2714          break;
2715       }
2716
2717       ret = ROK;
2718       break;
2719    }
2720
2721    addToReservedF1apPduList(TRANS_ID,f1apDuCfg);
2722    return ret;
2723 }
2724
2725
2726 /*******************************************************************
2727  *
2728  * @brief free the ULRRCMessageTransfer
2729  *
2730  * @details
2731  *
2732  *    Function : FreeULRRCMessageTransfer
2733  *
2734  *    Functionality: Deallocating the memory of variable allocated in
2735  *                      FreeULRRCMessageTransfer
2736  *
2737  * @params[in]
2738  *
2739  * @return ROK     - void
2740  *
2741  ******************************************************************/
2742 void FreeULRRCMessageTransfer( F1AP_PDU_t *f1apMsg)
2743 {
2744    uint8_t idx1;
2745    ULRRCMessageTransfer_t  *ulRRCMsg;
2746
2747    if(f1apMsg != NULLP)
2748    {
2749       if(f1apMsg->choice.initiatingMessage != NULLP)
2750       {
2751          ulRRCMsg = &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2752          if(ulRRCMsg->protocolIEs.list.array != NULLP)
2753          {
2754             for(idx1=0;idx1<ulRRCMsg->protocolIEs.list.count;idx1++)
2755             {
2756                if(ulRRCMsg->protocolIEs.list.array[idx1] != NULLP)
2757                {
2758                   if(ulRRCMsg->protocolIEs.list.array[idx1]->value.present ==
2759                         ULRRCMessageTransferIEs__value_PR_RRCContainer)
2760                   {
2761                      DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2762                            ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2763                   }
2764                   DU_FREE(ulRRCMsg->protocolIEs.list.array[idx1],sizeof(ULRRCMessageTransferIEs_t));
2765                }
2766             }
2767             DU_FREE(ulRRCMsg->protocolIEs.list.array,ulRRCMsg->protocolIEs.list.size );
2768          }
2769          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2770       }
2771       DU_FREE(f1apMsg,sizeof(F1AP_PDU_t));
2772    }
2773 }
2774 /*******************************************************************
2775  *
2776  * @brief Builds and sends the ULRRCMessageTransfer
2777  *
2778  * @details
2779  *
2780  *    Function : BuildAndSendULRRCMessageTransfer
2781  *
2782  *    Functionality: Constructs the UL RRC Message Transfer and sends
2783  *                   it to the CU through SCTP.
2784  *
2785  * @params[in]
2786  *
2787  * @return ROK     - success
2788  *         RFAILED - failure
2789  *
2790  * ****************************************************************/
2791 uint8_t BuildAndSendULRRCMessageTransfer(DuUeCb  ueCb, uint8_t lcId, \
2792       uint16_t msgLen, uint8_t *rrcMsg)
2793 {
2794    uint8_t   elementCnt =0;
2795    uint8_t   idx1 =0;
2796    uint8_t   idx =0;
2797    F1AP_PDU_t                   *f1apMsg = NULLP;
2798    ULRRCMessageTransfer_t       *ulRRCMsg = NULLP;
2799    asn_enc_rval_t               encRetVal;        /* Encoder return value */
2800    uint8_t ret =RFAILED;
2801
2802    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
2803
2804    while(true)
2805    {
2806       DU_LOG("\n INFO   -->  F1AP : Building UL RRC Message Transfer Message\n");
2807
2808       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
2809       if(f1apMsg == NULLP)
2810       {
2811          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
2812          break;
2813       }
2814       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
2815       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
2816       if(f1apMsg->choice.initiatingMessage == NULLP)
2817       {
2818          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
2819          break;
2820       }
2821       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_ULRRCMessageTransfer;
2822       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
2823       f1apMsg->choice.initiatingMessage->value.present = \
2824                                                          InitiatingMessage__value_PR_ULRRCMessageTransfer;
2825       ulRRCMsg =
2826          &f1apMsg->choice.initiatingMessage->value.choice.ULRRCMessageTransfer;
2827       elementCnt = 4;
2828       ulRRCMsg->protocolIEs.list.count = elementCnt;
2829       ulRRCMsg->protocolIEs.list.size = \
2830                                         elementCnt * sizeof(ULRRCMessageTransferIEs_t *);
2831
2832       /* Initialize the F1Setup members */
2833       DU_ALLOC(ulRRCMsg->protocolIEs.list.array, ulRRCMsg->protocolIEs.list.size);
2834       if(ulRRCMsg->protocolIEs.list.array == NULLP)
2835       {
2836          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UL RRC MessageTransferIEs failed");
2837          break;
2838       }
2839       for(idx=0; idx<elementCnt; idx++)
2840       {
2841          DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx],sizeof(ULRRCMessageTransferIEs_t));
2842          if(ulRRCMsg->protocolIEs.list.array[idx] == NULLP)
2843          {
2844             break;
2845          }
2846       }
2847
2848       idx1 = 0;
2849
2850       /*GNB CU UE F1AP ID*/
2851       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
2852       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2853       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2854                                                               ULRRCMessageTransferIEs__value_PR_GNB_CU_UE_F1AP_ID;
2855       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = ueCb.gnbCuUeF1apId;
2856
2857       /*GNB DU UE F1AP ID*/
2858       idx1++;
2859       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
2860       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2861       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2862                                                               ULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
2863       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = ueCb.gnbDuUeF1apId;
2864
2865       /*SRBID*/
2866       idx1++;
2867       ulRRCMsg->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
2868       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2869       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2870                                                               ULRRCMessageTransferIEs__value_PR_SRBID;
2871       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.SRBID = lcId;
2872
2873       /*RRCContainer*/
2874       idx1++;
2875       ulRRCMsg->protocolIEs.list.array[idx1]->id  = ProtocolIE_ID_id_RRCContainer;
2876       ulRRCMsg->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
2877       ulRRCMsg->protocolIEs.list.array[idx1]->value.present = \
2878                                                               ULRRCMessageTransferIEs__value_PR_RRCContainer;
2879       ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size = msgLen;
2880       DU_ALLOC(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf,
2881             ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size)
2882       if(!ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf)
2883       {
2884          DU_LOG(" ERROR  -->  F1AP : Memory allocation for BuildAndSendULRRCMessageTransfer failed");
2885          break;
2886       }
2887       memset(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, 0, msgLen);
2888       memcpy(ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.buf, \
2889             rrcMsg, ulRRCMsg->protocolIEs.list.array[idx1]->value.choice.RRCContainer.size);
2890
2891       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
2892
2893       /* Encode the F1SetupRequest type as APER */
2894       memset(encBuf, 0, ENC_BUF_MAX_LEN);
2895       encBufSize = 0;
2896       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
2897             encBuf);
2898       /* Encode results */
2899       if(encRetVal.encoded == ENCODE_FAIL)
2900       {
2901          DU_LOG( "\nERROR  -->  F1AP : Could not encode ULRRCMessageTransfer structure (at %s)\n",\
2902                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
2903          break;
2904       }
2905       else
2906       {
2907          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for ULRRCMessageTransfer\n");
2908          for(int i=0; i< encBufSize; i++)
2909          {
2910             printf("%x",encBuf[i]);
2911          }
2912       }
2913
2914       /* Sending  msg  */
2915       if(sendF1APMsg()  !=      ROK)
2916       {
2917          DU_LOG("\nERROR  -->   F1AP : Sending  UL RRC Message Transfer Failed");
2918          break;
2919       }
2920       ret = ROK;
2921       break;
2922    }
2923    FreeULRRCMessageTransfer(f1apMsg);
2924
2925    return ret;
2926 }/* End of BuildAndSendULRRCMessageTransfer*/
2927
2928 /*******************************************************************
2929  *
2930  * @brief Builds tag config
2931  *
2932  * @details
2933  *
2934  *    Function : BuildTagConfig
2935  *
2936  *    Functionality: Builds tag config in MacCellGroupConfig
2937  *
2938  * @params[in] TAG_Config *tag_Config
2939  *
2940  * @return ROK     - success
2941  *         RFAILED - failure
2942  *
2943  * ****************************************************************/
2944 uint8_t BuildTagConfig(struct TAG_Config *tagConfig)
2945 {
2946    struct TAG_Config__tag_ToAddModList *tagList;
2947    uint8_t                     idx, elementCnt;
2948
2949    tagConfig->tag_ToReleaseList = NULLP;
2950    tagConfig->tag_ToAddModList = NULLP;
2951    DU_ALLOC(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
2952    if(!tagConfig->tag_ToAddModList)
2953    {
2954       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2955       return RFAILED;
2956    }
2957
2958    elementCnt = 1; //ODU_VALUE_ONE;
2959    tagList = tagConfig->tag_ToAddModList;
2960    tagList->list.count = elementCnt;
2961    tagList->list.size  =  elementCnt * sizeof(struct TAG *);
2962
2963    tagList->list.array = NULLP;
2964    DU_ALLOC(tagList->list.array, tagList->list.size);
2965    if(!tagList->list.array)
2966    {
2967       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2968       return RFAILED;
2969    }
2970
2971    for(idx=0; idx<tagList->list.count; idx++)
2972    {
2973       tagList->list.array[idx] = NULLP;
2974       DU_ALLOC(tagList->list.array[idx], sizeof(struct TAG));
2975       if(!tagList->list.array[idx])
2976       {
2977          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildTagConfig");
2978          return RFAILED;
2979       }
2980    }
2981
2982    idx = 0;
2983    tagList->list.array[idx]->tag_Id = TAG_ID;
2984    tagList->list.array[idx]->timeAlignmentTimer = TIME_ALIGNMENT_TMR;
2985
2986    return ROK;
2987 }
2988
2989 /*******************************************************************
2990  *
2991  * @brief Builds PHR Config
2992  *
2993  * @details
2994  *
2995  *    Function : BuildPhrConfig
2996  *
2997  *    Functionality: Builds phrConfig in MacCellGroupConfig
2998  *
2999  * @params[in] PHR Config *
3000  *
3001  * @return ROK     - success
3002  *         RFAILED - failure
3003  *
3004  * ****************************************************************/
3005 uint8_t BuildPhrConfig(struct MAC_CellGroupConfig__phr_Config *phrConfig)
3006 {
3007
3008    phrConfig->present = MAC_CellGroupConfig__phr_Config_PR_setup;
3009    phrConfig->choice.setup = NULLP;
3010    DU_ALLOC(phrConfig->choice.setup, sizeof(struct PHR_Config));
3011    if(!phrConfig->choice.setup)
3012    {
3013       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhrConfig");
3014       return RFAILED;
3015    }
3016
3017    phrConfig->choice.setup->phr_PeriodicTimer        = PHR_PERIODIC_TMR;
3018    phrConfig->choice.setup->phr_ProhibitTimer        = PHR_PROHIBHIT_TMR;
3019    phrConfig->choice.setup->phr_Tx_PowerFactorChange = PHR_PWR_FACTOR_CHANGE;
3020    phrConfig->choice.setup->multiplePHR              = false;
3021    phrConfig->choice.setup->dummy                    = false;
3022    phrConfig->choice.setup->phr_Type2OtherCell       = false;
3023    phrConfig->choice.setup->phr_ModeOtherCG          = PHR_MODE_OTHER_CG;
3024
3025    return ROK;
3026 }
3027
3028 /*******************************************************************
3029  *
3030  * @brief Builds BSR Config
3031  *
3032  * @details
3033  *
3034  *    Function : BuildBsrConfig
3035  *
3036  *    Functionality: Builds BuildBsrConfig in MacCellGroupConfig
3037  *
3038  * @params[in] BSR_Config *bsrConfig
3039  *
3040  * @return ROK     - success
3041  *         RFAILED - failure
3042  *
3043  * ****************************************************************/
3044 uint8_t BuildBsrConfig(struct BSR_Config *bsrConfig)
3045 {
3046    bsrConfig->periodicBSR_Timer = PERIODIC_BSR_TMR;
3047    bsrConfig->retxBSR_Timer     = RETX_BSR_TMR;
3048    bsrConfig->logicalChannelSR_DelayTimer = NULLP;
3049
3050    return ROK;
3051 }
3052
3053 /*******************************************************************
3054  *
3055  * @brief Builds scheduling request config
3056  *
3057  * @details
3058  *
3059  *    Function : BuildSchedulingReqConfig
3060  *
3061  *    Functionality: Builds BuildSchedulingReqConfig in MacCellGroupConfig
3062  *
3063  * @params[in] SchedulingRequestConfig *schedulingRequestConfig
3064  *
3065  * @return ROK     - success
3066  *         RFAILED - failure
3067  *
3068  * ****************************************************************/
3069 uint8_t BuildSchedulingReqConfig(struct SchedulingRequestConfig *schedulingRequestConfig)
3070 {
3071    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList;
3072    uint8_t                     idx, elementCnt;
3073
3074    schedulingRequestConfig->schedulingRequestToAddModList = NULLP;
3075    DU_ALLOC(schedulingRequestConfig->schedulingRequestToAddModList,
3076          sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));
3077    if(!schedulingRequestConfig->schedulingRequestToAddModList)
3078    {
3079       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3080       return RFAILED;
3081    }
3082
3083    elementCnt = 1; //ODU_VALUE_ONE;
3084    schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
3085    schReqList->list.count = elementCnt;
3086    schReqList->list.size  = elementCnt * sizeof(struct SchedulingRequestToAddMod *);
3087
3088    schReqList->list.array = NULLP;
3089    DU_ALLOC(schReqList->list.array, schReqList->list.size);
3090    if(!schReqList->list.array)
3091    {
3092       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3093       return RFAILED;
3094    }
3095
3096    for(idx=0;idx<schReqList->list.count; idx++)
3097    {
3098       schReqList->list.array[idx] = NULLP;
3099       DU_ALLOC(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
3100       if(!schReqList->list.array[idx])
3101       {
3102          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3103          return RFAILED;
3104       }
3105    }
3106
3107    idx = 0;
3108    schReqList->list.array[idx]->schedulingRequestId = SCH_REQ_ID;
3109
3110    schReqList->list.array[idx]->sr_ProhibitTimer = NULLP;
3111    DU_ALLOC(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
3112    if(!schReqList->list.array[idx]->sr_ProhibitTimer)
3113    {
3114       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSchedulingReqConfig");
3115       return RFAILED;
3116    }
3117    *(schReqList->list.array[idx]->sr_ProhibitTimer) = SR_PROHIBIT_TMR;
3118    schReqList->list.array[idx]->sr_TransMax = SR_TRANS_MAX;
3119    schedulingRequestConfig->schedulingRequestToReleaseList = NULLP;
3120
3121    return ROK;
3122 }
3123
3124 /*******************************************************************
3125  *
3126  * @brief Builds RLC Config
3127  *
3128  * @details
3129  *
3130  *    Function : BuildRlcConfig
3131  *
3132  *    Functionality: Builds RLC Config in BuildRlcBearerToAddModList
3133  *
3134  * @params[in] RLC_Config *rlcConfig
3135  *
3136  * @return ROK     - success
3137  *         RFAILED - failure
3138  *
3139  * ****************************************************************/
3140 uint8_t BuildRlcConfig(struct RLC_Config *rlcConfig)
3141 {
3142
3143    rlcConfig->present = RLC_Config_PR_am;
3144
3145    rlcConfig->choice.am = NULLP;
3146    DU_ALLOC(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
3147    if(!rlcConfig->choice.am)
3148    {
3149       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3150       return RFAILED;
3151    }
3152
3153    /* UL */
3154    rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength = NULLP;
3155    DU_ALLOC(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3156    if(!rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength)
3157    {
3158       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3159       return RFAILED;
3160    }
3161    *(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3162    rlcConfig->choice.am->ul_AM_RLC.t_PollRetransmit  = T_POLL_RETRANSMIT;
3163    rlcConfig->choice.am->ul_AM_RLC.pollPDU           = POLL_PDU;
3164    rlcConfig->choice.am->ul_AM_RLC.pollByte          = POLL_BYTE;
3165    rlcConfig->choice.am->ul_AM_RLC.maxRetxThreshold  = MAX_RETX_THRESHOLD;
3166
3167    /* DL */
3168    rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength = NULLP;
3169    DU_ALLOC(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
3170    if(!rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength)
3171    {
3172       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcConfig");
3173       return RFAILED;
3174    }
3175    *(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength) = SN_FIELD_LEN;
3176    rlcConfig->choice.am->dl_AM_RLC.t_Reassembly      = T_REASSEMBLY;
3177    rlcConfig->choice.am->dl_AM_RLC.t_StatusProhibit  = T_STATUS_PROHIBHIT;
3178
3179    return ROK;
3180 }
3181
3182 /*******************************************************************
3183  *
3184  * @brief Builds MAC LC Config
3185  *
3186  * @details
3187  *
3188  *    Function : BuildMacLCConfig
3189  *
3190  *    Functionality: Builds MAC LC Config in BuildRlcBearerToAddModList
3191  *
3192  * @params[in] struct LogicalChannelConfig macLcConfig
3193  *
3194  * @return ROK     - success
3195  *         RFAILED - failure
3196  *
3197  * ****************************************************************/
3198 uint8_t BuildMacLCConfig(struct LogicalChannelConfig *macLcConfig)
3199 {
3200
3201    macLcConfig->ul_SpecificParameters = NULLP;
3202    DU_ALLOC(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
3203    if(!macLcConfig->ul_SpecificParameters)
3204    {
3205       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3206       return RFAILED;
3207    }
3208
3209    macLcConfig->ul_SpecificParameters->priority = MAC_LC_PRIORITY;
3210    macLcConfig->ul_SpecificParameters->prioritisedBitRate =     PRIORTISIED_BIT_RATE;
3211    macLcConfig->ul_SpecificParameters->bucketSizeDuration =     BUCKET_SIZE_DURATION;
3212    macLcConfig->ul_SpecificParameters->allowedServingCells = NULLP;
3213    macLcConfig->ul_SpecificParameters->allowedSCS_List = NULLP;
3214    macLcConfig->ul_SpecificParameters->maxPUSCH_Duration = NULLP;
3215    macLcConfig->ul_SpecificParameters->configuredGrantType1Allowed = NULLP;
3216
3217    macLcConfig->ul_SpecificParameters->logicalChannelGroup = NULLP;
3218    DU_ALLOC(macLcConfig->ul_SpecificParameters->logicalChannelGroup,    sizeof(long));
3219    if(!macLcConfig->ul_SpecificParameters->logicalChannelGroup)
3220    {
3221       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3222       return RFAILED;
3223    }
3224    *(macLcConfig->ul_SpecificParameters->logicalChannelGroup) = LC_GRP;
3225
3226    macLcConfig->ul_SpecificParameters->schedulingRequestID = NULLP;
3227    DU_ALLOC(macLcConfig->ul_SpecificParameters->schedulingRequestID,    sizeof(SchedulingRequestId_t));
3228    if(!macLcConfig->ul_SpecificParameters->schedulingRequestID)
3229    {
3230       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacLCConfig");
3231       return RFAILED;
3232    }
3233    *(macLcConfig->ul_SpecificParameters->schedulingRequestID) = SCH_REQ_ID;
3234
3235    macLcConfig->ul_SpecificParameters->logicalChannelSR_Mask = false;
3236    macLcConfig->ul_SpecificParameters->logicalChannelSR_DelayTimerApplied = false;
3237    macLcConfig->ul_SpecificParameters->bitRateQueryProhibitTimer = NULLP;
3238
3239    return ROK;
3240 }
3241
3242 /*******************************************************************
3243  *
3244  * @brief Builds RLC Bearer to Add/Mod list
3245  *
3246  * @details
3247  *
3248  *    Function :BuildRlcBearerToAddModList
3249  *
3250  *    Functionality: Builds RLC Bearer to Add/Mod list in DuToCuRrcContainer
3251  *
3252  * @params[in] rlc_BearerToAddModList
3253  *
3254  * @return ROK     - success
3255  *         RFAILED - failure
3256  *
3257  * ****************************************************************/
3258 uint8_t BuildRlcBearerToAddModList(struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList)
3259 {
3260    uint8_t                     idx, elementCnt;
3261
3262    elementCnt = 1;
3263    rlcBearerList->list.count = elementCnt;
3264    rlcBearerList->list.size  = elementCnt * sizeof(struct RLC_BearerConfig *);
3265
3266    rlcBearerList->list.array = NULLP;
3267    DU_ALLOC(rlcBearerList->list.array, rlcBearerList->list.size);
3268    if(!rlcBearerList->list.array)
3269    {
3270       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3271       return RFAILED;
3272    }
3273
3274    for(idx=0; idx<rlcBearerList->list.count; idx++)
3275    {
3276       rlcBearerList->list.array[idx] = NULLP;
3277       DU_ALLOC(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
3278       if(!rlcBearerList->list.array[idx])
3279       {
3280          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3281          return RFAILED;
3282       }
3283    }
3284
3285    idx = 0;
3286    rlcBearerList->list.array[idx]->logicalChannelIdentity = SRB1_LCID;
3287
3288    DU_ALLOC(rlcBearerList->list.array[idx]->servedRadioBearer, \
3289       sizeof(struct RLC_BearerConfig__servedRadioBearer));
3290    if(!rlcBearerList->list.array[idx]->servedRadioBearer)
3291    {
3292       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3293       return RFAILED;
3294    }
3295
3296    rlcBearerList->list.array[idx]->servedRadioBearer->present = \
3297       RLC_BearerConfig__servedRadioBearer_PR_srb_Identity;
3298    rlcBearerList->list.array[idx]->servedRadioBearer->choice.srb_Identity = \
3299       SRB1_LCID;
3300
3301    rlcBearerList->list.array[idx]->reestablishRLC = NULLP;
3302    rlcBearerList->list.array[idx]->rlc_Config = NULLP;
3303    DU_ALLOC(rlcBearerList->list.array[idx]->rlc_Config, sizeof(struct RLC_Config));
3304    if(!rlcBearerList->list.array[idx]->rlc_Config)
3305    {
3306       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3307       return RFAILED;
3308    }
3309
3310    if(BuildRlcConfig(rlcBearerList->list.array[idx]->rlc_Config) != ROK)
3311    {
3312       DU_LOG("\nERROR  -->  F1AP : BuildRlcConfig failed");
3313       return RFAILED;
3314    }
3315
3316    rlcBearerList->list.array[idx]->mac_LogicalChannelConfig = NULLP;
3317    DU_ALLOC(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, \
3318       sizeof(struct LogicalChannelConfig));
3319    if(!rlcBearerList->list.array[idx]->mac_LogicalChannelConfig)
3320    {
3321       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildRlcBearerToAddModList");
3322       return RFAILED;
3323    }
3324
3325    if(BuildMacLCConfig(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig) != ROK)
3326    {
3327       DU_LOG("\nERROR  -->  F1AP : BuildMacLCConfig failed");
3328       return RFAILED;
3329    }
3330
3331    return ROK;
3332 }
3333
3334 /*******************************************************************
3335  *
3336  * @brief Build Control resource set to add/modify list
3337  *
3338  * @details
3339  *
3340  *    Function : BuildControlRSetToAddModList
3341  *
3342  *    Functionality: Build Control resource set to add/modify list
3343  *
3344  * @params[in]
3345  * struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3346  *
3347  * @return ROK     - success
3348  *         RFAILED - failure
3349  *
3350  * ****************************************************************/
3351    uint8_t BuildControlRSetToAddModList
3352 (
3353  struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList
3354  )
3355 {
3356    uint8_t idx;
3357    uint8_t elementCnt;
3358    uint8_t numBytes, bitsUnused;
3359    struct ControlResourceSet *controlRSet;
3360    uint8_t freqDomainResource[FREQ_DOM_RSRC_SIZE] = {0};
3361    uint8_t coreset0EndPrb, coreset1StartPrb, coreset1NumPrb;
3362
3363
3364    elementCnt = 1;
3365    controlRSetList->list.count = elementCnt;
3366    controlRSetList->list.size = \
3367                                 elementCnt * sizeof(struct ControlResourceSet *);
3368
3369    controlRSetList->list.array = NULLP;
3370    DU_ALLOC(controlRSetList->list.array, controlRSetList->list.size);
3371    if(!controlRSetList->list.array)
3372    {
3373       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3374       return RFAILED;
3375    }
3376
3377    for(idx = 0; idx < elementCnt; idx++)
3378    {
3379       controlRSetList->list.array[idx] = NULLP;
3380       DU_ALLOC(controlRSetList->list.array[idx], sizeof(struct ControlResourceSet));
3381       if(!controlRSetList->list.array[idx])
3382       {
3383          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3384          return RFAILED;
3385       }
3386    }
3387
3388    idx=0;
3389    controlRSet = controlRSetList->list.array[idx];
3390
3391    controlRSet->controlResourceSetId = PDCCH_CTRL_RSRC_SET_ONE_ID;
3392
3393    /* size 6 bytes
3394     * 3 LSBs unsued
3395     * Bit string stored ff0000000000
3396     */
3397    numBytes = 6;
3398    bitsUnused = 3;
3399    controlRSet->frequencyDomainResources.size = numBytes * sizeof(uint8_t);
3400
3401    controlRSet->frequencyDomainResources.buf = NULLP;
3402    DU_ALLOC(controlRSet->frequencyDomainResources.buf, \
3403          controlRSet->frequencyDomainResources.size);
3404    if(!controlRSet->frequencyDomainResources.buf)
3405    {
3406       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3407       return RFAILED;
3408    }
3409
3410    memset(controlRSet->frequencyDomainResources.buf, 0, FREQ_DOM_RSRC_SIZE);
3411    coreset0EndPrb = CORESET0_END_PRB;
3412    coreset1StartPrb = coreset0EndPrb + 6;
3413    coreset1NumPrb = CORESET1_NUM_PRB;
3414    /* calculate the PRBs */
3415    fillCoresetFeqDomAllocMap(((coreset1StartPrb)/6), (coreset1NumPrb/6), freqDomainResource);
3416    memcpy(controlRSet->frequencyDomainResources.buf, freqDomainResource, FREQ_DOM_RSRC_SIZE);
3417    controlRSet->frequencyDomainResources.bits_unused = bitsUnused;
3418
3419    controlRSet->duration = PDCCH_CTRL_RSRC_SET_ONE_DURATION;
3420    controlRSet->cce_REG_MappingType.present = \
3421                                               ControlResourceSet__cce_REG_MappingType_PR_nonInterleaved;
3422
3423    controlRSet->precoderGranularity = PDCCH_CTRL_RSRC_SET_ONE_PRECOD_GRANULARITY;
3424    controlRSet->tci_StatesPDCCH_ToAddList = NULLP;
3425    controlRSet->tci_StatesPDCCH_ToReleaseList = NULLP;
3426    controlRSet->tci_PresentInDCI = NULLP;
3427 #if 0
3428    uint8_t tciStateIdx;
3429
3430    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList, \
3431          sizeof(struct ControlResourceSet__tci_StatesPDCCH_ToAddList));
3432    if(!controlRset->tci_StatesPDCCH_ToAddList)
3433    {
3434       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3435       return RFAILED;
3436    }
3437
3438    elementCnt = 1;
3439    controlRset->tci_StatesPDCCH_ToAddList->list.count = elementCnt;
3440    controlRset->tci_StatesPDCCH_ToAddList->list.size = elementCnt * sizeof(TCI_StateId_t *);
3441    DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array, \
3442          controlRset->tci_StatesPDCCH_ToAddList->list.size)
3443       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array)
3444       {
3445          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3446          return RFAILED;
3447       }
3448
3449    for(tciStateIdx = 0; tciStateIdx <elementCntl; tciStateIdx++)
3450    {
3451       DU_ALLOC(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx], sizeof(TCI_StateId_t));
3452       if(!controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx])
3453       {
3454          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3455          return RFAILED;
3456       }
3457    }
3458
3459    tciStateIdx = 0;
3460    /* TODO */
3461    *(controlRset->tci_StatesPDCCH_ToAddList->list.array[tciStateIdx]);
3462
3463    DU_ALLOC(controlRset->tci_PresentInDCI, sizeof(long));
3464    if(!controlRset->tci_PresentInDCI)
3465    {
3466       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3467       return RFAILED;
3468    }
3469    /* TODO */
3470    *(controlRset->tci_PresentInDCI);
3471 #endif
3472
3473    controlRSet->pdcch_DMRS_ScramblingID = NULLP;
3474    DU_ALLOC(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
3475    if(!controlRSet->pdcch_DMRS_ScramblingID)
3476    {
3477       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildControlRSetToAddModList");
3478       return RFAILED;
3479    }
3480    *(controlRSet->pdcch_DMRS_ScramblingID) = SCRAMBLING_ID;
3481
3482    return ROK;
3483 } /* End BuildControlRSetToAddModList */
3484
3485 /*******************************************************************
3486  *
3487  * @brief Build search space to add/modify list
3488  *
3489  * @details
3490  *
3491  *    Function : BuildSearchSpcToAddModList
3492  *
3493  *    Functionality: Build search space to add/modify list
3494  *
3495  * @params[in]
3496  * @return ROK     - success
3497  *         RFAILED - failure
3498  *
3499  * ****************************************************************/
3500    uint8_t BuildSearchSpcToAddModList
3501 (
3502  struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
3503  )
3504 {
3505    uint8_t idx;
3506    uint8_t numBytes;
3507    uint8_t byteIdx;
3508    uint8_t bitsUnused;
3509    uint8_t elementCnt;
3510    struct SearchSpace *searchSpc;
3511
3512    elementCnt = 1;
3513    searchSpcList->list.count = elementCnt;
3514    searchSpcList->list.size = elementCnt * sizeof(struct SearchSpace *);
3515
3516    searchSpcList->list.array = NULLP;
3517    DU_ALLOC(searchSpcList->list.array, searchSpcList->list.size);
3518    if(!searchSpcList->list.array)
3519    {
3520       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3521       return RFAILED;
3522    }
3523
3524    for(idx = 0; idx < elementCnt; idx++)
3525    {
3526       searchSpcList->list.array[idx] = NULLP;
3527       DU_ALLOC(searchSpcList->list.array[idx], sizeof(struct SearchSpace));
3528       if(!searchSpcList->list.array[idx])
3529       {
3530          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3531          return RFAILED;
3532       }
3533    }
3534
3535    idx = 0;
3536    searchSpc = searchSpcList->list.array[idx];
3537
3538    searchSpc->searchSpaceId = PDCCH_SRCH_SPC_TWO_ID;
3539
3540    searchSpc->controlResourceSetId = NULLP;
3541    DU_ALLOC(searchSpc->controlResourceSetId, sizeof(ControlResourceSetId_t));
3542    if(!searchSpc->controlResourceSetId)
3543    {
3544       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3545       return RFAILED;
3546    }
3547    *(searchSpc->controlResourceSetId) = PDCCH_CTRL_RSRC_SET_ONE_ID;
3548
3549    searchSpc->monitoringSlotPeriodicityAndOffset = NULLP;
3550    DU_ALLOC(searchSpc->monitoringSlotPeriodicityAndOffset, \
3551          sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
3552    if(!searchSpc->monitoringSlotPeriodicityAndOffset)
3553    {
3554       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3555       return RFAILED;
3556    }
3557    searchSpc->monitoringSlotPeriodicityAndOffset->present = \
3558                                                             SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1;
3559
3560    searchSpc->duration = NULLP;
3561    searchSpc->monitoringSymbolsWithinSlot = NULLP;
3562    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot, sizeof(BIT_STRING_t));
3563    if(!searchSpc->monitoringSymbolsWithinSlot)
3564    {
3565       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3566       return RFAILED;
3567    }
3568
3569    /* Values taken from reference logs :
3570     * size 2 bytes
3571     * 2 LSBs unsued
3572     * Bit string stores 8000
3573     */
3574    numBytes = 2;
3575    bitsUnused = 2;
3576
3577    searchSpc->monitoringSymbolsWithinSlot->size = numBytes * sizeof(uint8_t);
3578    searchSpc->monitoringSymbolsWithinSlot->buf = NULLP;
3579    DU_ALLOC(searchSpc->monitoringSymbolsWithinSlot->buf, \
3580          searchSpc->monitoringSymbolsWithinSlot->size);
3581    if(!searchSpc->monitoringSymbolsWithinSlot->buf)
3582    {
3583       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3584       return RFAILED;
3585    }
3586
3587    byteIdx = 0;
3588    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = \
3589                                                             PDCCH_SYMBOL_WITHIN_SLOT /* setting MSB to 128 i.e. 0x80 */;
3590    searchSpc->monitoringSymbolsWithinSlot->buf[byteIdx++] = 0;
3591    searchSpc->monitoringSymbolsWithinSlot->bits_unused = bitsUnused;
3592
3593    searchSpc->nrofCandidates = NULLP;
3594    DU_ALLOC(searchSpc->nrofCandidates, sizeof(struct SearchSpace__nrofCandidates));
3595    if(!searchSpc->nrofCandidates)
3596    {
3597       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3598       return RFAILED;
3599    }
3600
3601    searchSpc->nrofCandidates->aggregationLevel1 = \
3602                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL1_CANDIDATE;
3603    searchSpc->nrofCandidates->aggregationLevel2 = \
3604                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL2_CANDIDATE;
3605    searchSpc->nrofCandidates->aggregationLevel4 = \
3606                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL4_CANDIDATE;
3607    searchSpc->nrofCandidates->aggregationLevel8 = \
3608                                                   PDCCH_SRCH_SPC_TWO_AGG_LVL8_CANDIDATE;
3609    searchSpc->nrofCandidates->aggregationLevel16 = \
3610                                                    PDCCH_SRCH_SPC_TWO_AGG_LVL16_CANDIDATE;
3611
3612    searchSpc->searchSpaceType = NULLP;
3613    DU_ALLOC(searchSpc->searchSpaceType, sizeof(struct SearchSpace__searchSpaceType));
3614    if(!searchSpc->searchSpaceType)
3615    {
3616       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3617       return RFAILED;
3618    }
3619
3620    searchSpc->searchSpaceType->present = SearchSpace__searchSpaceType_PR_ue_Specific;
3621
3622    searchSpc->searchSpaceType->choice.ue_Specific = NULLP;
3623    DU_ALLOC(searchSpc->searchSpaceType->choice.ue_Specific, \
3624          sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
3625    if(!searchSpc->searchSpaceType->choice.ue_Specific)
3626    {
3627       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSearchSpcToAddModList");
3628       return RFAILED;
3629    }
3630    searchSpc->searchSpaceType->choice.ue_Specific->dci_Formats = \
3631                                                                  PDCCH_SRCH_SPC_TWO_UE_SPEC_DCI_FORMAT;
3632
3633    return ROK;
3634 }/* End BuildSearchSpcToAddModList */
3635
3636 /*******************************************************************
3637  *
3638  * @brief Builds BWP DL dedicated PDCCH config
3639  *
3640  * @details
3641  *
3642  *    Function : BuildBWPDlDedPdcchCfg
3643  *
3644  *    Functionality: Builds BWP DL dedicated PDCCH config
3645  *
3646  * @params[in] struct PDCCH_Config *pdcchCfg
3647  *
3648  * @return ROK     - success
3649  *         RFAILED - failure
3650  *
3651  * ****************************************************************/
3652 uint8_t BuildBWPDlDedPdcchCfg(struct PDCCH_Config *pdcchCfg)
3653 {
3654    pdcchCfg->controlResourceSetToAddModList = NULLP;
3655    DU_ALLOC(pdcchCfg->controlResourceSetToAddModList, \
3656          sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
3657    if(!pdcchCfg->controlResourceSetToAddModList)
3658    {
3659       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3660       return RFAILED;
3661    }
3662
3663    if(BuildControlRSetToAddModList(pdcchCfg->controlResourceSetToAddModList) != ROK)
3664    {
3665       return RFAILED;
3666    }
3667
3668    pdcchCfg->controlResourceSetToReleaseList = NULLP;
3669
3670    pdcchCfg->searchSpacesToAddModList = NULLP;
3671    DU_ALLOC(pdcchCfg->searchSpacesToAddModList, \
3672          sizeof(struct PDCCH_Config__searchSpacesToAddModList));
3673    if(!pdcchCfg->searchSpacesToAddModList)
3674    {
3675       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdcchCfg");
3676       return RFAILED;
3677    }
3678
3679    if(BuildSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList) != ROK)
3680    {
3681       return RFAILED;
3682    }
3683
3684    pdcchCfg->searchSpacesToReleaseList = NULLP;
3685    pdcchCfg->downlinkPreemption = NULLP;
3686    pdcchCfg->tpc_PUSCH = NULLP;
3687    pdcchCfg->tpc_PUCCH = NULLP;
3688    pdcchCfg->tpc_SRS = NULLP;
3689
3690    return ROK;
3691 }
3692
3693 /*******************************************************************
3694  *
3695  * @brief Builds DMRS DL PDSCH Mapping type A
3696  *
3697  * @details
3698  *
3699  *    Function : BuildDMRSDLPdschMapTypeA
3700  *
3701  *    Functionality: Builds DMRS DL PDSCH Mapping type A
3702  *
3703  * @params[in]
3704  * struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3705  * @return ROK     - success
3706  *         RFAILED - failure
3707  *
3708  * ****************************************************************/
3709    uint8_t BuildDMRSDLPdschMapTypeA
3710 (
3711  struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg
3712  )
3713 {
3714    dmrsDlCfg->present = PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup;
3715    dmrsDlCfg->choice.setup = NULLP;
3716    DU_ALLOC(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
3717    if(!dmrsDlCfg->choice.setup)
3718    {
3719       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3720       return RFAILED;
3721    }
3722
3723    dmrsDlCfg->choice.setup->dmrs_Type = NULLP;
3724    dmrsDlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
3725    DU_ALLOC(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
3726    if(!dmrsDlCfg->choice.setup->dmrs_AdditionalPosition)
3727    {
3728       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSDLPdschMapTypeA");
3729       return RFAILED;
3730    }
3731    *(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
3732
3733    dmrsDlCfg->choice.setup->maxLength = NULLP;
3734    dmrsDlCfg->choice.setup->scramblingID0 = NULLP;
3735    dmrsDlCfg->choice.setup->scramblingID1 = NULLP;
3736    dmrsDlCfg->choice.setup->phaseTrackingRS = NULLP;
3737
3738    return ROK;
3739 }
3740
3741 /*******************************************************************
3742  *
3743  * @brief Builds TCI states to add/modify list
3744  *
3745  * @details
3746  *
3747  *    Function : BuildTCIStatesToAddModList
3748  *
3749  *    Functionality:Builds TCI states to add/modify list
3750  *
3751  * @params[in]
3752  * struct PDSCH_Config__tci_StatesToAddModList *tciStatesList
3753  *
3754  * @return ROK     - success
3755  *         RFAILED - failure
3756  *
3757  * ****************************************************************/
3758 uint8_t BuildTCIStatesToAddModList(struct PDSCH_Config__tci_StatesToAddModList *tciStatesList)
3759 {
3760    return ROK;
3761 }
3762
3763 /*******************************************************************
3764  *
3765  * @brief Builds PDSCH time domain allocation list
3766  *
3767  * @details
3768  *
3769  *    Function : BuildPdschTimeDomAllocList
3770  *
3771  *    Functionality: Builds PDSCH time domain allocation list
3772  *
3773  * @params[in]
3774  * struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3775  *
3776  * @return ROK     - success
3777  *         RFAILED - failure
3778  *
3779  * ****************************************************************/
3780    uint8_t BuildPdschTimeDomAllocList
3781 (
3782  struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
3783  )
3784 {
3785    uint8_t idx;
3786    uint8_t elementCnt;
3787    struct PDSCH_TimeDomainResourceAllocation *timeDomAlloc;
3788
3789    timeDomAllocList->present = \
3790                                PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup;
3791
3792    timeDomAllocList->choice.setup = NULLP;
3793    DU_ALLOC(timeDomAllocList->choice.setup, \
3794          sizeof(struct PDSCH_TimeDomainResourceAllocationList));
3795    if(!timeDomAllocList->choice.setup)
3796    {
3797       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3798       return RFAILED;
3799    }
3800
3801    elementCnt = 2;
3802    timeDomAllocList->choice.setup->list.count = elementCnt;
3803    timeDomAllocList->choice.setup->list.size = \
3804                                                elementCnt * sizeof(struct PDSCH_TimeDomainResourceAllocation *);
3805
3806    timeDomAllocList->choice.setup->list.array = NULLP;
3807    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
3808          timeDomAllocList->choice.setup->list.size);
3809    if(!timeDomAllocList->choice.setup->list.array)
3810    {
3811       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3812       return RFAILED;
3813    }
3814
3815    for(idx = 0; idx < elementCnt; idx++)
3816    {
3817       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
3818       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx], \
3819             sizeof(struct PDSCH_TimeDomainResourceAllocation));
3820       if(!timeDomAllocList->choice.setup->list.array[idx])
3821       {
3822          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3823          return RFAILED;
3824       }
3825    }
3826
3827    idx = 0;
3828    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3829    DU_ALLOC(timeDomAlloc->k0, sizeof(long));
3830    if(!timeDomAlloc->k0)
3831    {
3832       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3833       return RFAILED;
3834    }
3835    *(timeDomAlloc->k0) = 0;
3836    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3837    timeDomAlloc->startSymbolAndLength = \
3838                                         calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
3839
3840    idx++;
3841    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
3842    DU_ALLOC(timeDomAlloc->k0, sizeof(long));
3843    if(!timeDomAlloc->k0)
3844    {
3845       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschTimeDomAllocList");
3846       return RFAILED;
3847    }
3848    *(timeDomAlloc->k0) = 1;
3849    timeDomAlloc->mappingType = PDSCH_MAPPING_TYPE_A;
3850    timeDomAlloc->startSymbolAndLength = calcSliv(PDSCH_START_SYMBOL, PDSCH_LENGTH_SYMBOL);
3851
3852    return ROK;
3853 }
3854
3855 /*******************************************************************
3856  *
3857  * @brief Builds PDSCH PRB Bundling type
3858  *
3859  * @details
3860  *
3861  *    Function : BuildPdschPrbBundlingType
3862  *
3863  *    Functionality: Builds PDSCH PRB Bundling type
3864  *
3865  * @params[in]
3866  * struct PDSCH_Config__prb_BundlingType *prbBndlType
3867  *
3868  * @return ROK     - success
3869  *         RFAILED - failure
3870  *
3871  * ****************************************************************/
3872    uint8_t BuildPdschPrbBundlingType
3873 (
3874  struct PDSCH_Config__prb_BundlingType *prbBndlType
3875  )
3876 {
3877    prbBndlType->present = PDSCH_Config__prb_BundlingType_PR_staticBundling;
3878
3879    prbBndlType->choice.staticBundling = NULLP;
3880    DU_ALLOC(prbBndlType->choice.staticBundling, \
3881          sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
3882    if(!prbBndlType->choice.staticBundling)
3883    {
3884       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschPrbBundlingType");
3885       return RFAILED;
3886    }
3887    prbBndlType->choice.staticBundling->bundleSize = NULLP;
3888
3889    return ROK;
3890 }
3891
3892 /*******************************************************************
3893  *
3894  * @brief Builds BWP DL dedicated PDSCH config
3895  *
3896  * @details
3897  *
3898  *    Function : BuildBWPDlDedPdschCfg
3899  *
3900  *    Functionality: Builds BWP DL dedicated PDSCH config
3901  *
3902  * @params[in] struct PDSCH_Config *pdschCfg
3903  *
3904  * @return ROK     - success
3905  *         RFAILED - failure
3906  *
3907  * ****************************************************************/
3908 uint8_t BuildBWPDlDedPdschCfg(struct PDSCH_Config *pdschCfg)
3909 {
3910    pdschCfg->dataScramblingIdentityPDSCH = NULLP;
3911
3912    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA = NULLP;
3913    DU_ALLOC(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
3914          sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
3915    if(!pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
3916    {
3917       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3918       return RFAILED;
3919    }
3920
3921    if(BuildDMRSDLPdschMapTypeA(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA) != ROK)
3922    {
3923       return RFAILED;
3924    }
3925
3926    pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeB = NULLP;
3927    pdschCfg->tci_StatesToAddModList = NULLP;
3928    pdschCfg->tci_StatesToReleaseList = NULLP;
3929    pdschCfg->vrb_ToPRB_Interleaver = NULLP;
3930 #if 0
3931    DU_ALLOC(pdschCfg->tci_StatesToAddModList, sizeof(struct PDSCH_Config__tci_StatesToAddModList));
3932    if(!pdschCfg->tci_StatesToAddModList)
3933    {
3934       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3935       return RFAILED;
3936    }
3937    if(BuildTCIStatesToAddModList(pdschCfg->tci_StatesToAddModList) != ROK)
3938    {
3939       return RFAILED;
3940    }
3941 #endif
3942
3943    pdschCfg->resourceAllocation = RES_ALLOC_TYPE;
3944
3945    pdschCfg->pdsch_TimeDomainAllocationList = NULLP;
3946    DU_ALLOC(pdschCfg->pdsch_TimeDomainAllocationList, \
3947          sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
3948    if(!pdschCfg->pdsch_TimeDomainAllocationList)
3949    {
3950       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3951       return RFAILED;
3952    }
3953
3954    if(BuildPdschTimeDomAllocList(pdschCfg->pdsch_TimeDomainAllocationList) != ROK)
3955    {
3956       return RFAILED;
3957    }
3958
3959    pdschCfg->pdsch_AggregationFactor = NULLP;
3960    pdschCfg->rateMatchPatternToAddModList = NULLP;
3961    pdschCfg->rateMatchPatternToReleaseList = NULLP;
3962    pdschCfg->rateMatchPatternGroup1 = NULLP;
3963    pdschCfg->rateMatchPatternGroup2 = NULLP;
3964    pdschCfg->rbg_Size = PDSCH_RBG_SIZE;
3965    pdschCfg->mcs_Table = NULLP;
3966
3967    pdschCfg->maxNrofCodeWordsScheduledByDCI = NULLP;
3968    DU_ALLOC(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
3969    if(!pdschCfg->maxNrofCodeWordsScheduledByDCI)
3970    {
3971       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPDlDedPdschCfg");
3972       return RFAILED;
3973    }
3974    *(pdschCfg->maxNrofCodeWordsScheduledByDCI) = PDSCH_MAX_CODEWORD_SCH_BY_DCI;
3975
3976    if(BuildPdschPrbBundlingType(&pdschCfg->prb_BundlingType) != ROK)
3977    {
3978       return RFAILED;
3979    }
3980
3981    pdschCfg->zp_CSI_RS_ResourceToAddModList = NULLP;
3982    pdschCfg->zp_CSI_RS_ResourceToReleaseList = NULLP;
3983    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3984    pdschCfg->aperiodic_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3985    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToAddModList = NULLP;
3986    pdschCfg->sp_ZP_CSI_RS_ResourceSetsToReleaseList = NULLP;
3987    pdschCfg->p_ZP_CSI_RS_ResourceSet = NULLP;
3988
3989    return ROK;
3990 }
3991
3992 /*******************************************************************
3993  *
3994  * @brief Builds intitial DL BWP
3995  * @details
3996  *
3997  *    Function : BuildInitialDlBWP
3998  *
3999  *    Functionality: Builds intitial DL BWP in spCellCfgDed
4000  *
4001  * @params[in] BWP_DownlinkDedicated_t *dlBwp
4002  *
4003  * @return ROK     - success
4004  *         RFAILED - failure
4005  *
4006  * ****************************************************************/
4007 uint8_t BuildInitialDlBWP(BWP_DownlinkDedicated_t *dlBwp)
4008 {
4009    dlBwp->pdcch_Config = NULLP;
4010    DU_ALLOC(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
4011    if(!dlBwp->pdcch_Config)
4012    {
4013       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4014       return RFAILED;
4015    }
4016    dlBwp->pdcch_Config->present = BWP_DownlinkDedicated__pdcch_Config_PR_setup;
4017
4018    dlBwp->pdcch_Config->choice.setup = NULLP;
4019    DU_ALLOC(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
4020    if(!dlBwp->pdcch_Config->choice.setup)
4021    {
4022       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4023       return RFAILED;
4024    }
4025    if(BuildBWPDlDedPdcchCfg(dlBwp->pdcch_Config->choice.setup) != ROK)
4026    {
4027       return RFAILED;
4028    }
4029
4030    dlBwp->pdsch_Config = NULLP;
4031    DU_ALLOC(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
4032    if(!dlBwp->pdsch_Config)
4033    {
4034       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4035       return RFAILED;
4036    }
4037    dlBwp->pdsch_Config->present = BWP_DownlinkDedicated__pdsch_Config_PR_setup;
4038
4039    dlBwp->pdsch_Config->choice.setup = NULLP;
4040    DU_ALLOC(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
4041    if(!dlBwp->pdsch_Config->choice.setup)
4042    {
4043       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failure in BuildInitialDlBWP");
4044       return RFAILED;
4045    }
4046
4047    if(BuildBWPDlDedPdschCfg(dlBwp->pdsch_Config->choice.setup) != ROK)
4048    {
4049       return RFAILED;
4050    }
4051
4052    dlBwp->sps_Config = NULLP;
4053    dlBwp->radioLinkMonitoringConfig = NULLP;
4054    return ROK;
4055 }
4056
4057 /*******************************************************************
4058  *
4059  * @brief Builds DMRS UL Pusch Mapping type A
4060  *
4061  * @details
4062  *
4063  *    Function : BuildDMRSULPuschMapTypeA
4064  *
4065  *    Functionality: Builds DMRS UL Pusch Mapping type A
4066  *
4067  * @params[in]
4068  *    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4069  * @return ROK     - success
4070  *         RFAILED - failure
4071  *
4072  * ****************************************************************/
4073    uint8_t BuildDMRSULPuschMapTypeA
4074 (
4075  struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg
4076  )
4077 {
4078    dmrsUlCfg->present = PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup;
4079    dmrsUlCfg->choice.setup= NULLP;
4080    DU_ALLOC(dmrsUlCfg->choice.setup, sizeof(DMRS_UplinkConfig_t));
4081    if(!dmrsUlCfg->choice.setup)
4082    {
4083       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4084       return RFAILED;
4085    }
4086
4087    dmrsUlCfg->choice.setup->dmrs_Type = NULLP;
4088    dmrsUlCfg->choice.setup->dmrs_AdditionalPosition = NULLP;
4089    DU_ALLOC(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition, sizeof(long));
4090    if(!dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
4091    {
4092       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4093       return RFAILED;
4094    }
4095    *(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition) = DMRS_ADDITIONAL_POS;
4096
4097    dmrsUlCfg->choice.setup->phaseTrackingRS = NULLP;
4098    dmrsUlCfg->choice.setup->maxLength = NULLP;
4099    dmrsUlCfg->choice.setup->transformPrecodingDisabled = NULLP;
4100    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled, \
4101          sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
4102    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled)
4103    {
4104       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4105       return RFAILED;
4106    }
4107
4108    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0 = NULLP;
4109    DU_ALLOC(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
4110          sizeof(long));
4111    if(!dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0)
4112    {
4113       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDMRSULPuschMapTypeA");
4114       return RFAILED;
4115    }
4116    *(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0) = SCRAMBLING_ID;
4117
4118    dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID1 = NULLP;
4119    dmrsUlCfg->choice.setup->transformPrecodingEnabled = NULLP;
4120    return ROK;
4121 }
4122
4123 /*******************************************************************
4124  *
4125  * @brief Build PUSCH time domain allocation list
4126  *
4127  * @details
4128  *
4129  *    Function : BuildPuschTimeDomAllocList
4130  *
4131  *    Functionality: Build PUSCH time domain allocation list
4132  *
4133  * @params[in]
4134  * struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4135  *
4136  * @return ROK     - success
4137  *         RFAILED - failure
4138  *
4139  * ****************************************************************/
4140    uint8_t BuildPuschTimeDomAllocList
4141 (
4142  struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList
4143  )
4144 {
4145    uint8_t idx;
4146    uint8_t elementCnt;
4147    PUSCH_TimeDomainResourceAllocation_t  *timeDomAlloc;
4148
4149    timeDomAllocList->present = PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup;
4150    timeDomAllocList->choice.setup = NULLP;
4151    DU_ALLOC(timeDomAllocList->choice.setup, \
4152          sizeof(struct PUSCH_TimeDomainResourceAllocationList));
4153    if(!timeDomAllocList->choice.setup)
4154    {
4155       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4156       return RFAILED;
4157    }
4158
4159    elementCnt = 2;
4160    timeDomAllocList->choice.setup->list.count = elementCnt;
4161    timeDomAllocList->choice.setup->list.size = \
4162                                                elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
4163    timeDomAllocList->choice.setup->list.array = NULLP;
4164    DU_ALLOC(timeDomAllocList->choice.setup->list.array, \
4165          timeDomAllocList->choice.setup->list.size);
4166    if(!timeDomAllocList->choice.setup->list.array)
4167    {
4168       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4169       return RFAILED;
4170    }
4171
4172    for(idx = 0; idx < elementCnt; idx++)
4173    {
4174       timeDomAllocList->choice.setup->list.array[idx] = NULLP;
4175       DU_ALLOC(timeDomAllocList->choice.setup->list.array[idx],\
4176             sizeof(PUSCH_TimeDomainResourceAllocation_t));
4177       if(!timeDomAllocList->choice.setup->list.array[idx])
4178       {
4179          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4180          return RFAILED;
4181       }
4182    }
4183
4184    idx = 0;
4185    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4186    DU_ALLOC(timeDomAlloc->k2, sizeof(long));
4187    if(!timeDomAlloc->k2)
4188    {
4189       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4190       return RFAILED;
4191    }
4192    *(timeDomAlloc->k2) = PUSCH_K2_CFG1;
4193    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4194    timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
4195
4196    idx++;
4197    timeDomAlloc = timeDomAllocList->choice.setup->list.array[idx];
4198    DU_ALLOC(timeDomAlloc->k2, sizeof(long));
4199    if(!timeDomAlloc->k2)
4200    {
4201       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschTimeDomAllocList");
4202       return RFAILED;
4203    }
4204    *(timeDomAlloc->k2) = PUSCH_K2_CFG2;
4205    timeDomAlloc->mappingType = PUSCH_MAPPING_TYPE_A;
4206    timeDomAlloc->startSymbolAndLength = calcSliv(PUSCH_START_SYMBOL, PUSCH_LENGTH_SYMBOL);
4207
4208    return ROK;
4209 }
4210
4211 /*******************************************************************
4212  *
4213  * @brief Builds BWP UL dedicated PUSCH Config
4214  *
4215  * @details
4216  *
4217  *    Function : BuildBWPUlDedPuschCfg
4218  *
4219  *    Functionality:
4220  *      Builds BWP UL dedicated PUSCH Config
4221  *
4222  * @params[in] : PUSCH_Config_t *puschCfg
4223  *
4224  * @return ROK     - success
4225  *         RFAILED - failure
4226  *
4227  * ****************************************************************/
4228 uint8_t BuildBWPUlDedPuschCfg(PUSCH_Config_t *puschCfg)
4229 {
4230    puschCfg->dataScramblingIdentityPUSCH = NULLP;
4231    DU_ALLOC(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
4232    if(!puschCfg->dataScramblingIdentityPUSCH)
4233    {
4234       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4235       return RFAILED;
4236    }
4237    *(puschCfg->dataScramblingIdentityPUSCH) = SCRAMBLING_ID;
4238
4239    puschCfg->txConfig = NULLP;
4240    puschCfg->dmrs_UplinkForPUSCH_MappingTypeA = NULLP;
4241    DU_ALLOC(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
4242          sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
4243    if(!puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
4244    {
4245       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4246       return RFAILED;
4247    }
4248
4249    if(BuildDMRSULPuschMapTypeA(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA) != ROK)
4250    {
4251       return RFAILED;
4252    }
4253
4254    puschCfg->dmrs_UplinkForPUSCH_MappingTypeB = NULLP;
4255    puschCfg->pusch_PowerControl = NULLP;
4256    puschCfg->frequencyHopping = NULLP;
4257    puschCfg->frequencyHoppingOffsetLists = NULLP;
4258    puschCfg->resourceAllocation = RES_ALLOC_TYPE;
4259
4260    puschCfg->pusch_TimeDomainAllocationList = NULLP;
4261    DU_ALLOC(puschCfg->pusch_TimeDomainAllocationList, \
4262          sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
4263    if(!puschCfg->pusch_TimeDomainAllocationList)
4264    {
4265       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4266       return RFAILED;
4267    }
4268
4269    if(BuildPuschTimeDomAllocList(puschCfg->pusch_TimeDomainAllocationList) != ROK)
4270    {
4271       return RFAILED;
4272    }
4273
4274    puschCfg->pusch_AggregationFactor = NULLP;
4275    puschCfg->mcs_Table = NULLP;
4276    puschCfg->mcs_TableTransformPrecoder = NULLP;
4277    puschCfg->transformPrecoder = NULLP;
4278    DU_ALLOC(puschCfg->transformPrecoder, sizeof(long));
4279    if(!puschCfg->transformPrecoder)
4280    {
4281       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPuschCfg");
4282       return RFAILED;
4283    }
4284    *(puschCfg->transformPrecoder) = PUSCH_TRANSFORM_PRECODER;
4285
4286    puschCfg->codebookSubset = NULLP;
4287    puschCfg->maxRank = NULLP;
4288    puschCfg->rbg_Size = NULLP;
4289    puschCfg->uci_OnPUSCH = NULLP;
4290    puschCfg->tp_pi2BPSK = NULLP;
4291
4292    return ROK;
4293 }
4294
4295 /*******************************************************************
4296  *
4297  * @brief Builds BWP UL dedicated PUCCH Config
4298  *
4299  * @details
4300  *
4301  *    Function : BuildBWPUlDedPucchCfg
4302  *
4303  *    Functionality:
4304  *      Builds BWP UL dedicated PUCCH Config
4305  *
4306  * @params[in] : PUCCH_Config_t *pucchCfg
4307  *
4308  * @return ROK     - success
4309  *         RFAILED - failure
4310  *
4311  * ****************************************************************/
4312 uint8_t BuildBWPUlDedPucchCfg(PUCCH_Config_t *pucchCfg)
4313 {
4314    uint8_t arrIdx, elementCnt;
4315
4316    DU_ALLOC(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
4317    if(pucchCfg->dl_DataToUL_ACK == NULLP)
4318    {
4319       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4320       return RFAILED;
4321    }
4322
4323    elementCnt = 2;
4324    pucchCfg->dl_DataToUL_ACK->list.count = elementCnt;
4325    pucchCfg->dl_DataToUL_ACK->list.size = elementCnt * sizeof(long *);
4326    DU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
4327    if(pucchCfg->dl_DataToUL_ACK->list.array == NULLP)
4328    {
4329       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4330       return RFAILED;
4331    }
4332
4333    for(arrIdx = 0; arrIdx <  pucchCfg->dl_DataToUL_ACK->list.count; arrIdx++)
4334    {
4335       DU_ALLOC(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx], sizeof(long));
4336       if(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx] == NULLP)
4337       {
4338           DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedPucchCfg");
4339           return RFAILED;
4340       }
4341    }
4342
4343    arrIdx = 0;
4344    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx++]) = 1;
4345    *(pucchCfg->dl_DataToUL_ACK->list.array[arrIdx]) = 2;
4346    return ROK;
4347 }
4348
4349 /*******************************************************************
4350  *
4351  * @brief Fills SRS resource to add/modify list
4352  *
4353  * @details
4354  *
4355  *    Function : BuildSrsRsrcAddModList
4356  *
4357  *    Functionality: Fills SRS resource to add/modify list
4358  *
4359  * @params[in]
4360  * @return ROK     - success
4361  *         RFAILED - failure
4362  *
4363  * ****************************************************************/
4364 uint8_t BuildSrsRsrcAddModList(struct SRS_Config__srs_ResourceToAddModList *resourceList)
4365 {
4366    uint8_t   elementCnt;
4367    uint8_t   rsrcIdx;
4368
4369    elementCnt = 1;
4370    resourceList->list.count = elementCnt;
4371    resourceList->list.size = elementCnt * sizeof(SRS_Resource_t *);
4372    resourceList->list.array = NULLP;
4373    DU_ALLOC(resourceList->list.array, resourceList->list.size);
4374    if(!resourceList->list.array)
4375    {
4376       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4377       return RFAILED;
4378    }
4379
4380    for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
4381    {
4382       DU_ALLOC(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
4383       if(!resourceList->list.array[rsrcIdx])
4384       {
4385          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4386          return RFAILED;
4387       }
4388    }
4389
4390    rsrcIdx = 0;
4391    resourceList->list.array[rsrcIdx]->srs_ResourceId = SRS_RSRC_ID;
4392    resourceList->list.array[rsrcIdx]->nrofSRS_Ports = SRS_Resource__nrofSRS_Ports_port1;
4393    resourceList->list.array[rsrcIdx]->transmissionComb.present = SRS_Resource__transmissionComb_PR_n2;
4394
4395    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2 = NULLP;
4396    DU_ALLOC(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2, \
4397          sizeof(struct SRS_Resource__transmissionComb__n2));
4398    if(!resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2)
4399    {
4400       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4401       return RFAILED;
4402    }
4403    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->combOffset_n2\
4404       = SRS_COMB_OFFSET_N2;
4405    resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2->cyclicShift_n2\
4406       = SRS_CYCLIC_SHIFT_N2;
4407
4408    resourceList->list.array[rsrcIdx]->resourceMapping.startPosition = \
4409                                                                       PUSCH_START_SYMBOL;
4410    resourceList->list.array[rsrcIdx]->resourceMapping.nrofSymbols =  \
4411                                                                      SRS_Resource__resourceMapping__nrofSymbols_n1;
4412    resourceList->list.array[rsrcIdx]->resourceMapping.repetitionFactor = \
4413                                                                          SRS_Resource__resourceMapping__repetitionFactor_n1;
4414
4415    resourceList->list.array[rsrcIdx]->freqDomainPosition = SRS_FREQ_DOM_POS;
4416    resourceList->list.array[rsrcIdx]->freqDomainShift = SRS_FREQ_DOM_SHIFT;
4417    resourceList->list.array[rsrcIdx]->freqHopping.c_SRS = C_SRS;
4418    resourceList->list.array[rsrcIdx]->freqHopping.b_SRS = B_SRS;
4419    resourceList->list.array[rsrcIdx]->freqHopping.b_hop = B_HOP;
4420    resourceList->list.array[rsrcIdx]->groupOrSequenceHopping = \
4421                                                                SRS_Resource__groupOrSequenceHopping_neither;
4422
4423    /* Setting resource type to aperiodic for intergration purposes */
4424    resourceList->list.array[rsrcIdx]->resourceType.present = \
4425                                                              SRS_Resource__resourceType_PR_aperiodic;
4426    resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic = NULLP;
4427    DU_ALLOC(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,
4428          sizeof(struct SRS_Resource__resourceType__aperiodic));
4429    if(!resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic)
4430    {
4431       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcAddModList");
4432       return RFAILED;
4433    }
4434    resourceList->list.array[rsrcIdx]->sequenceId = SRS_SEQ_ID;
4435
4436    return ROK;
4437 }
4438
4439 /*******************************************************************
4440  *
4441  * @brief Build SRS resource set Add/mod list
4442  *
4443  * @details
4444  *
4445  *    Function : BuildSrsRsrcSetAddModList
4446  *
4447  *    Functionality: Build SRS resource set Add/mod list
4448  *
4449  * @params[in]
4450  * @return ROK     - success
4451  *         RFAILED - failure
4452  *
4453  * ****************************************************************/
4454    uint8_t BuildSrsRsrcSetAddModList
4455 (
4456  struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList
4457  )
4458 {
4459    uint8_t  elementCnt;
4460    uint8_t  rSetIdx;
4461    uint8_t  rsrcIdx;
4462    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList;
4463
4464    elementCnt = 1;
4465    rsrcSetList->list.count = elementCnt;
4466    rsrcSetList->list.size = elementCnt * sizeof(SRS_ResourceSet_t *);
4467    rsrcSetList->list.array = NULLP;
4468    DU_ALLOC(rsrcSetList->list.array, rsrcSetList->list.size);
4469    if(!rsrcSetList->list.array)
4470    {
4471       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4472       return RFAILED;
4473    }
4474
4475    for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
4476    {
4477       DU_ALLOC(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
4478       if(!rsrcSetList->list.array[rSetIdx])
4479       {
4480          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4481          return RFAILED;
4482       }
4483    }
4484
4485    rSetIdx = 0;
4486    rsrcSetList->list.array[rSetIdx]->srs_ResourceSetId = SRS_RSET_ID;
4487
4488    /* Fill Resource Id list in resource set */
4489    rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList = NULLP;
4490    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
4491          sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
4492    if(!rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
4493    {
4494       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4495       return RFAILED;
4496    }
4497
4498    elementCnt = 1;
4499    rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
4500    rsrcIdList->list.count = elementCnt;
4501    rsrcIdList->list.size = elementCnt * sizeof(SRS_ResourceId_t *);
4502    rsrcIdList->list.array = NULLP;
4503    DU_ALLOC(rsrcIdList->list.array, rsrcIdList->list.size);
4504    if(!rsrcIdList->list.array)
4505    {
4506       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4507       return RFAILED;
4508    }
4509
4510    for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
4511    {
4512       DU_ALLOC(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
4513       if(!rsrcIdList->list.array[rsrcIdx])
4514       {
4515          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4516          return RFAILED;
4517       }
4518    }
4519
4520    rsrcIdx = 0;
4521    *rsrcIdList->list.array[rsrcIdx] = SRS_RSRC_ID;
4522
4523    /* Fill resource type */
4524    rsrcSetList->list.array[rSetIdx]->resourceType.present = \
4525                                                             SRS_ResourceSet__resourceType_PR_aperiodic;
4526
4527    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic = NULLP;
4528    DU_ALLOC(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
4529          sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
4530    if(!rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic)
4531    {
4532       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildSrsRsrcSetAddModList");
4533       return RFAILED;
4534    }
4535    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->aperiodicSRS_ResourceTrigger \
4536       = APERIODIC_SRS_RESRC_TRIGGER;
4537
4538    /* TODO : Fill values for below IEs as expected by Viavi */
4539    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->csi_RS = NULLP;
4540    rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic->slotOffset = NULLP;
4541
4542
4543    rsrcSetList->list.array[rSetIdx]->usage = SRS_ResourceSet__usage_codebook;
4544    rsrcSetList->list.array[rSetIdx]->alpha = NULLP;
4545    rsrcSetList->list.array[rSetIdx]->p0 = NULLP;
4546    rsrcSetList->list.array[rSetIdx]->pathlossReferenceRS = NULLP;
4547    rsrcSetList->list.array[rSetIdx]->srs_PowerControlAdjustmentStates = NULLP;
4548
4549    return ROK;
4550 }
4551
4552 /*******************************************************************
4553  *
4554  * @brief Builds BWP UL dedicated SRS Config
4555  *
4556  * @details
4557  *
4558  *    Function : BuildBWPUlDedSrsCfg
4559  *
4560  *    Functionality: Builds BWP UL dedicated SRS Config
4561  *
4562  * @params[in] SRS Config
4563  * @return ROK     - success
4564  *         RFAILED - failure
4565  *
4566  * ****************************************************************/
4567 uint8_t BuildBWPUlDedSrsCfg(SRS_Config_t *srsCfg)
4568 {
4569    srsCfg->srs_ResourceSetToReleaseList = NULLP;
4570    srsCfg->srs_ResourceSetToAddModList = NULLP;
4571    DU_ALLOC(srsCfg->srs_ResourceSetToAddModList, \
4572          sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
4573    if(!srsCfg->srs_ResourceSetToAddModList)
4574    {
4575       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4576       return RFAILED;
4577    }
4578    if(BuildSrsRsrcSetAddModList(srsCfg->srs_ResourceSetToAddModList) != ROK)
4579    {
4580       return RFAILED;
4581    }
4582
4583    srsCfg->srs_ResourceToReleaseList = NULLP;
4584
4585    /* Resource to Add/Modify list */
4586    srsCfg->srs_ResourceToAddModList = NULLP;
4587    DU_ALLOC(srsCfg->srs_ResourceToAddModList, \
4588          sizeof(struct SRS_Config__srs_ResourceToAddModList));
4589    if(!srsCfg->srs_ResourceToAddModList)
4590    {
4591       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildBWPUlDedSrsCfg");
4592       return RFAILED;
4593    }
4594
4595    if(BuildSrsRsrcAddModList(srsCfg->srs_ResourceToAddModList) != ROK)
4596    {
4597       return RFAILED;
4598    }
4599
4600    srsCfg->tpc_Accumulation = NULLP;
4601
4602    return ROK;
4603 }
4604
4605
4606
4607 /*******************************************************************
4608  *
4609  * @brief Builds Pusch Serving cell Config
4610  *
4611  * @details
4612  *
4613  *    Function : BuildPuschSrvCellCfg
4614  *
4615  *    Functionality: Builds Pusch Serving cell Config
4616  *
4617  * @params[in] struct UplinkConfig__pusch_ServingCellConfig *puschCfg
4618  *
4619  * @return ROK     - success
4620  *         RFAILED - failure
4621  *
4622  * ****************************************************************/
4623 uint8_t BuildPuschSrvCellCfg(struct UplinkConfig__pusch_ServingCellConfig *puschCfg)
4624 {
4625    puschCfg->present = UplinkConfig__pusch_ServingCellConfig_PR_setup;
4626    puschCfg->choice.setup = NULLP;
4627    DU_ALLOC(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
4628    if(!puschCfg->choice.setup)
4629    {
4630       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4631       return RFAILED;
4632    }
4633
4634    puschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4635    puschCfg->choice.setup->rateMatching = NULLP;
4636    puschCfg->choice.setup->xOverhead = NULLP;
4637    puschCfg->choice.setup->ext1 = NULLP;
4638    DU_ALLOC(puschCfg->choice.setup->ext1, sizeof(struct PUSCH_ServingCellConfig__ext1));
4639    if(!puschCfg->choice.setup->ext1)
4640    {
4641       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4642       return RFAILED;
4643    }
4644
4645    puschCfg->choice.setup->ext1->maxMIMO_Layers = NULLP;
4646    DU_ALLOC(puschCfg->choice.setup->ext1->maxMIMO_Layers, sizeof(long));
4647    if(!puschCfg->choice.setup->ext1->maxMIMO_Layers)
4648    {
4649       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4650       return RFAILED;
4651    }
4652    *(puschCfg->choice.setup->ext1->maxMIMO_Layers) = PUSCH_MAX_MIMO_LAYERS;
4653
4654    puschCfg->choice.setup->ext1->processingType2Enabled= NULLP;
4655    DU_ALLOC(puschCfg->choice.setup->ext1->processingType2Enabled,sizeof(BOOLEAN_t));
4656    if(!puschCfg->choice.setup->ext1->processingType2Enabled)
4657    {
4658       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPuschSrvCellCfg");
4659       return RFAILED;
4660    }
4661    *(puschCfg->choice.setup->ext1->processingType2Enabled) = PUSCH_PROCESS_TYPE2_ENABLED;
4662    return ROK;
4663 }
4664
4665 /*******************************************************************
4666  *
4667  * @brief Builds inital UL BWP
4668  *
4669  * @details
4670  *
4671  *    Function : BuildInitialUlBWP
4672  *
4673  *    Functionality: Builds initial UL BWP
4674  *
4675  * @params[in] BWP_UplinkDedicated_t *ulBwp
4676  * @return ROK     - success
4677  *         RFAILED - failure
4678  *
4679  * ****************************************************************/
4680 uint8_t BuildInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
4681 {
4682    ulBwp->pucch_Config = NULLP;
4683    DU_ALLOC(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
4684    if(!ulBwp->pucch_Config)
4685    {
4686       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4687       return RFAILED;
4688    }
4689
4690    ulBwp->pucch_Config->present = BWP_UplinkDedicated__pucch_Config_PR_setup;
4691    ulBwp->pucch_Config->choice.setup = NULLP;
4692    DU_ALLOC(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
4693    if(!ulBwp->pucch_Config->choice.setup)
4694    {
4695       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4696       return RFAILED;
4697    }
4698
4699    if(BuildBWPUlDedPucchCfg(ulBwp->pucch_Config->choice.setup) != ROK)
4700    {
4701       return RFAILED;
4702    }
4703
4704    /* Fill BWP UL dedicated PUSCH config */
4705    ulBwp->pusch_Config = NULLP;
4706    DU_ALLOC(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
4707    if(!ulBwp->pusch_Config)
4708    {
4709       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4710       return RFAILED;
4711    }
4712
4713    ulBwp->pusch_Config->present = BWP_UplinkDedicated__pusch_Config_PR_setup;
4714    ulBwp->pusch_Config->choice.setup = NULLP;
4715    DU_ALLOC(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
4716    if(!ulBwp->pusch_Config->choice.setup)
4717    {
4718       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4719       return RFAILED;
4720    }
4721
4722    if(BuildBWPUlDedPuschCfg(ulBwp->pusch_Config->choice.setup) != ROK)
4723    {
4724       return RFAILED;
4725    }
4726
4727    ulBwp->configuredGrantConfig = NULLP;
4728
4729    /* Fill BPW UL dedicated SRS config */
4730    ulBwp->srs_Config = NULLP;
4731    DU_ALLOC(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
4732    if(!ulBwp->srs_Config)
4733    {
4734       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4735       return RFAILED;
4736    }
4737
4738    ulBwp->srs_Config->present = BWP_UplinkDedicated__srs_Config_PR_setup;
4739    ulBwp->srs_Config->choice.setup = NULLP;
4740    DU_ALLOC(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
4741    if(!ulBwp->srs_Config->choice.setup)
4742    {
4743       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildInitialUlBWP");
4744       return RFAILED;
4745    }
4746
4747    if(BuildBWPUlDedSrsCfg(ulBwp->srs_Config->choice.setup) != ROK)
4748    {
4749       return RFAILED;
4750    }
4751
4752    ulBwp->beamFailureRecoveryConfig = NULLP;
4753
4754    return ROK;
4755 }
4756
4757 /*******************************************************************
4758  *
4759  * @brief Builds UL config
4760  * @details
4761  *
4762  *    Function : BuildUlCfg
4763  *
4764  *    Functionality: Builds UL config in spCellCfgDed
4765  *
4766  * @params[in] UplinkConfig_t *ulCfg
4767  *
4768  * @return ROK     - success
4769  *         RFAILED - failure
4770  *
4771  * ****************************************************************/
4772 uint8_t BuildUlCfg(UplinkConfig_t *ulCfg)
4773 {
4774    ulCfg->initialUplinkBWP = NULLP;
4775    DU_ALLOC(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
4776    if(!ulCfg->initialUplinkBWP)
4777    {
4778       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4779       return RFAILED;
4780    }
4781
4782    if(BuildInitialUlBWP(ulCfg->initialUplinkBWP) != ROK)
4783    {
4784       return RFAILED;
4785    }
4786
4787    ulCfg->uplinkBWP_ToReleaseList = NULLP;
4788    ulCfg->uplinkBWP_ToAddModList = NULLP;
4789    ulCfg->firstActiveUplinkBWP_Id = NULLP;
4790    DU_ALLOC(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
4791    if(!ulCfg->firstActiveUplinkBWP_Id)
4792    {
4793       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4794       return RFAILED;
4795    }
4796    *(ulCfg->firstActiveUplinkBWP_Id) = ACTIVE_UL_BWP_ID;
4797
4798    ulCfg->pusch_ServingCellConfig = NULLP;
4799    DU_ALLOC(ulCfg->pusch_ServingCellConfig, \
4800          sizeof(struct UplinkConfig__pusch_ServingCellConfig));
4801    if(!ulCfg->pusch_ServingCellConfig)
4802    {
4803       DU_LOG("\nERROR  -->  F1AP : Memory Allocation failed in BuildUlCfg");
4804       return RFAILED;
4805    }
4806
4807    if(BuildPuschSrvCellCfg(ulCfg->pusch_ServingCellConfig) != ROK)
4808    {
4809       return RFAILED;
4810    }
4811
4812    ulCfg->carrierSwitching = NULLP;
4813    ulCfg->ext1 = NULLP;
4814    return ROK;
4815 }
4816
4817 /*******************************************************************
4818  *
4819  * @brief Builds PDSCH serving cell config
4820  * @details
4821  *
4822  *    Function : BuildPdschSrvCellCfg
4823  *
4824  *    Functionality: Builds PDSCH serving cell config in spCellCfgDed
4825  *
4826  * @params[in] struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg
4827  *
4828  * @return ROK     - success
4829  *         RFAILED - failure
4830  *
4831  * ****************************************************************/
4832 uint8_t BuildPdschSrvCellCfg(struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg)
4833 {
4834    pdschCfg->present =  ServingCellConfig__pdsch_ServingCellConfig_PR_setup;
4835    pdschCfg->choice.setup = NULLP;
4836    DU_ALLOC(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
4837    if(!pdschCfg->choice.setup)
4838    {
4839       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4840       return RFAILED;
4841    }
4842
4843    pdschCfg->choice.setup->codeBlockGroupTransmission = NULLP;
4844    pdschCfg->choice.setup->xOverhead = NULLP;
4845    pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH = NULLP;
4846    DU_ALLOC(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH, sizeof(long));
4847    if(!pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)
4848    {
4849       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildPdschSrvCellCfg");
4850       return RFAILED;
4851    }
4852    *(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH)= PDSCH_NUM_HARQ_PROC;
4853    pdschCfg->choice.setup->pucch_Cell = NULLP;
4854    pdschCfg->choice.setup->ext1 = NULLP;
4855
4856    return ROK;
4857 }
4858
4859 /*******************************************************************
4860  *
4861  * @brief Builds CSI Meas config
4862  * @details
4863  *
4864  *    Function : BuildCsiMeasCfg
4865  *
4866  *    Functionality: Builds CSI Meas config in spCellCfgDed
4867  *
4868  * @params[in] struct ServingCellConfig__csi_MeasConfig *csiMeasCfg
4869  *
4870  * @return ROK     - success
4871  *         RFAILED - failure
4872  *
4873  * ****************************************************************/
4874 uint8_t BuildCsiMeasCfg(struct ServingCellConfig__csi_MeasConfig *csiMeasCfg)
4875 {
4876
4877    return ROK;
4878 }
4879
4880 /*******************************************************************
4881  *
4882  * @brief Builds Spcell config dedicated
4883  * @details
4884  *
4885  *    Function : BuildSpCellCfgDed
4886  *
4887  *    Functionality: Builds sp cell config dedicated in spCellCfg
4888  *
4889  * @params[in] ServingCellConfig_t srvCellCfg
4890  *
4891  * @return ROK     - success
4892  *         RFAILED - failure
4893  *
4894  * ****************************************************************/
4895 uint8_t BuildSpCellCfgDed(ServingCellConfig_t *srvCellCfg)
4896 {
4897    srvCellCfg->tdd_UL_DL_ConfigurationDedicated = NULLP;
4898    DU_ALLOC(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
4899    if(!srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
4900    {
4901       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4902       return RFAILED;
4903    }
4904
4905    srvCellCfg->initialDownlinkBWP = NULLP;
4906    DU_ALLOC(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
4907    if(!srvCellCfg->initialDownlinkBWP)
4908    {
4909       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4910       return RFAILED;
4911    }
4912
4913    if(BuildInitialDlBWP(srvCellCfg->initialDownlinkBWP) != ROK)
4914    {
4915       DU_LOG("\nERROR  -->  F1AP : BuildInitialDlBWP failed");
4916       return RFAILED;
4917    }
4918    srvCellCfg->downlinkBWP_ToReleaseList = NULLP;
4919    srvCellCfg->downlinkBWP_ToAddModList = NULLP;
4920
4921    srvCellCfg->firstActiveDownlinkBWP_Id = NULLP;
4922    DU_ALLOC(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
4923    if(!srvCellCfg->firstActiveDownlinkBWP_Id)
4924    {
4925       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4926       return RFAILED;
4927    }
4928    *(srvCellCfg->firstActiveDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4929
4930    srvCellCfg->bwp_InactivityTimer = NULLP;
4931
4932    srvCellCfg->defaultDownlinkBWP_Id = NULLP;
4933    DU_ALLOC(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
4934    if(!srvCellCfg->defaultDownlinkBWP_Id)
4935    {
4936       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4937       return RFAILED;
4938    }
4939    *(srvCellCfg->defaultDownlinkBWP_Id) = ACTIVE_DL_BWP_ID;
4940
4941    srvCellCfg->uplinkConfig = NULLP;
4942    DU_ALLOC(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
4943    if(!srvCellCfg->uplinkConfig)
4944    {
4945       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4946       return RFAILED;
4947    }
4948
4949    if(BuildUlCfg(srvCellCfg->uplinkConfig) != ROK)
4950    {
4951       DU_LOG("\nERROR  -->  F1AP : BuildUlCfg failed");
4952       return RFAILED;
4953    }
4954    srvCellCfg->supplementaryUplink = NULLP;
4955    srvCellCfg->pdcch_ServingCellConfig = NULLP;
4956
4957    srvCellCfg->pdsch_ServingCellConfig = NULLP;
4958    DU_ALLOC(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct  ServingCellConfig__pdsch_ServingCellConfig));
4959    if(!srvCellCfg->pdsch_ServingCellConfig)
4960    {
4961       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4962       return RFAILED;
4963    }
4964
4965    if(BuildPdschSrvCellCfg(srvCellCfg->pdsch_ServingCellConfig) != ROK)
4966    {
4967       DU_LOG("\nERROR  -->  F1AP : BuildPdschSrvCellCfg failed");
4968       return RFAILED;
4969    }
4970
4971    srvCellCfg->csi_MeasConfig = NULLP;
4972 #if 0
4973    DU_ALLOC(srvCellCfg->csi_MeasConfig, sizeof(struct   ServingCellConfig__csi_MeasConfig))
4974       if(!srvCellCfg->csi_MeasConfig)
4975       {
4976          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfgDed");
4977          return RFAILED;
4978       }
4979
4980    if(BuildCsiMeasCfg(srvCellCfg->csi_MeasConfig) != ROK)
4981    {
4982       DU_LOG("\nF1AP : BuildCsiMeasCfg failed");
4983       return RFAILED;
4984    }
4985 #endif
4986    srvCellCfg->sCellDeactivationTimer = NULLP;
4987    srvCellCfg->crossCarrierSchedulingConfig = NULLP;
4988    srvCellCfg->tag_Id = TAG_ID;
4989    srvCellCfg->dummy = NULLP;
4990    srvCellCfg->pathlossReferenceLinking = NULLP;
4991    srvCellCfg->servingCellMO = NULLP;
4992    srvCellCfg->ext1 = NULLP;
4993
4994    return ROK;
4995 }
4996 /*******************************************************************
4997  *
4998  * @brief Builds Spcell config
4999  *
5000  * @details
5001  *
5002  *    Function : BuildSpCellCfg
5003  *
5004  *    Functionality: Builds sp cell config in DuToCuRrcContainer
5005  *
5006  * @params[in] SpCellConfig_t spCellCfg
5007  *
5008  * @return ROK     - success
5009  *         RFAILED - failure
5010  *
5011  * ****************************************************************/
5012 uint8_t BuildSpCellCfg(SpCellConfig_t *spCellCfg)
5013 {
5014
5015    spCellCfg->servCellIndex = NULLP;
5016    DU_ALLOC(spCellCfg->servCellIndex, sizeof(long));
5017    if(!spCellCfg->servCellIndex)
5018    {
5019       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5020       return RFAILED;
5021    }
5022    *(spCellCfg->servCellIndex) = SERV_CELL_IDX;
5023
5024    spCellCfg->reconfigurationWithSync = NULLP;
5025    spCellCfg->rlf_TimersAndConstants = NULLP;
5026    spCellCfg->rlmInSyncOutOfSyncThreshold = NULLP;
5027    DU_ALLOC(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5028    if(!spCellCfg->rlmInSyncOutOfSyncThreshold)
5029    {
5030       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5031       return RFAILED;
5032    }
5033    *(spCellCfg->rlmInSyncOutOfSyncThreshold) = RLM_SYNC_OUT_SYNC_THRESHOLD;
5034
5035    spCellCfg->spCellConfigDedicated = NULLP;
5036    DU_ALLOC(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5037    if(!spCellCfg->spCellConfigDedicated)
5038    {
5039       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildSpCellCfg");
5040       return RFAILED;
5041    }
5042    if(BuildSpCellCfgDed(spCellCfg->spCellConfigDedicated) != ROK)
5043    {
5044       DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfgDed failed");
5045       return RFAILED;
5046    }
5047    return ROK;
5048 }
5049 /*******************************************************************
5050  *
5051  * @brief Builds Phy cell group config
5052  *
5053  * @details
5054  *
5055  *    Function : BuildPhyCellGrpCfg
5056  *
5057  *    Functionality: Builds Phy cell group config in DuToCuRrcContainer
5058  *
5059  * @params[in] PhysicalCellGroupConfig_t *phyCellGrpCfg
5060  *
5061  * @return ROK     - success
5062  *         RFAILED - failure
5063  *
5064  * ****************************************************************/
5065 uint8_t BuildPhyCellGrpCfg(PhysicalCellGroupConfig_t *phyCellGrpCfg)
5066 {
5067    phyCellGrpCfg->harq_ACK_SpatialBundlingPUCCH = NULLP;
5068    phyCellGrpCfg->harq_ACK_SpatialBundlingPUSCH = NULLP;
5069
5070    phyCellGrpCfg->p_NR_FR1 = NULLP;
5071    DU_ALLOC(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5072    if(!phyCellGrpCfg->p_NR_FR1)
5073    {
5074       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildPhyCellGrpCfg");
5075       return RFAILED;
5076    }
5077    *(phyCellGrpCfg->p_NR_FR1)             = P_NR_FR1;
5078    phyCellGrpCfg->pdsch_HARQ_ACK_Codebook = PDSCH_HARQ_ACK_CODEBOOK;
5079    phyCellGrpCfg->tpc_SRS_RNTI = NULLP;
5080    phyCellGrpCfg->tpc_PUCCH_RNTI = NULLP;
5081    phyCellGrpCfg->tpc_PUSCH_RNTI = NULLP;
5082    phyCellGrpCfg->sp_CSI_RNTI = NULLP;
5083    phyCellGrpCfg->cs_RNTI = NULLP;
5084    phyCellGrpCfg->ext1 = NULLP;
5085    phyCellGrpCfg->ext2 = NULLP;
5086
5087    return ROK;
5088 }
5089 /*******************************************************************
5090  *
5091  * @brief Builds Mac cell group config
5092  *
5093  * @details
5094  *
5095  *    Function : BuildMacCellGrpCfg
5096  *
5097  *    Functionality: Builds Mac cell group config in DuToCuRrcContainer
5098  *
5099  * @params[in] MAC_CellGroupConfig_t *macCellGrpCfg
5100  *
5101  * @return ROK     - success
5102  *         RFAILED - failure
5103  *
5104  * ****************************************************************/
5105 uint8_t BuildMacCellGrpCfg(MAC_CellGroupConfig_t *macCellGrpCfg)
5106 {
5107    macCellGrpCfg->drx_Config = NULLP;
5108    macCellGrpCfg->schedulingRequestConfig = NULLP;
5109    DU_ALLOC(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5110    if(!macCellGrpCfg->schedulingRequestConfig)
5111    {
5112       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5113       return RFAILED;
5114    }
5115
5116    if(BuildSchedulingReqConfig(macCellGrpCfg->schedulingRequestConfig) != ROK)
5117    {
5118       DU_LOG("\nERROR  -->  F1AP : BuildSchedulingReqConfig failed");
5119       return RFAILED;
5120    }
5121
5122    macCellGrpCfg->bsr_Config = NULLP;
5123    DU_ALLOC(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5124    if(!macCellGrpCfg->bsr_Config)
5125    {
5126       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5127       return RFAILED;
5128    }
5129
5130    if(BuildBsrConfig(macCellGrpCfg->bsr_Config) != ROK)
5131    {
5132       DU_LOG("\nERROR  -->  F1AP : BuildBsrConfig failed");
5133       return RFAILED;
5134    }
5135
5136    macCellGrpCfg->tag_Config = NULLP;
5137    DU_ALLOC(macCellGrpCfg->tag_Config, sizeof(struct TAG_Config));
5138    if(!macCellGrpCfg->tag_Config)
5139    {
5140       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5141       return RFAILED;
5142    }
5143
5144    if(BuildTagConfig(macCellGrpCfg->tag_Config) != ROK)
5145    {
5146       DU_LOG("\nERROR  -->  F1AP : BuildTagConfig failed");
5147       return RFAILED;
5148    }
5149
5150    macCellGrpCfg->phr_Config = NULLP;
5151    DU_ALLOC(macCellGrpCfg->phr_Config, sizeof(struct MAC_CellGroupConfig__phr_Config));
5152    if(!macCellGrpCfg->phr_Config)
5153    {
5154       DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildMacCellGrpCfg");
5155       return RFAILED;
5156    }
5157
5158    if(BuildPhrConfig(macCellGrpCfg->phr_Config) != ROK)
5159    {
5160       DU_LOG("\nERROR  -->  F1AP : BuildPhrConfig failed");
5161       return RFAILED;
5162    }
5163
5164    macCellGrpCfg->skipUplinkTxDynamic = false;
5165    macCellGrpCfg->ext1 = NULLP;
5166
5167    return ROK;
5168 }
5169 /*******************************************************************
5170  *
5171  * @brief Frees memeory allocated for SearchSpcToAddModList
5172  *
5173  * @details
5174  *
5175  *    Function : FreeSearchSpcToAddModList
5176  *
5177  *    Functionality: Deallocating memory of SearchSpcToAddModList
5178  *
5179  * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
5180  *
5181  * @return void
5182  *
5183  4221 * ****************************************************************/
5184 void FreeSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
5185 {
5186    uint8_t idx1=0;
5187    uint8_t idx2=0;
5188    struct  SearchSpace *searchSpc=NULLP;
5189
5190    if(searchSpcList->list.array)
5191    {
5192       if(searchSpcList->list.array[idx2])
5193       {
5194          searchSpc = searchSpcList->list.array[idx2];
5195          if(searchSpc->controlResourceSetId)
5196          {
5197             if(searchSpc->monitoringSlotPeriodicityAndOffset)
5198             {
5199                if(searchSpc->monitoringSymbolsWithinSlot)
5200                {
5201                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
5202                   {
5203                      if(searchSpc->nrofCandidates)
5204                      {
5205                         if(searchSpc->searchSpaceType)
5206                         {
5207                            DU_FREE(searchSpc->searchSpaceType->choice.ue_Specific,\
5208                                  sizeof(struct SearchSpace__searchSpaceType__ue_Specific));
5209                            DU_FREE(searchSpc->searchSpaceType, sizeof(struct
5210                                     SearchSpace__searchSpaceType));
5211                         }
5212                         DU_FREE(searchSpc->nrofCandidates,
5213                               sizeof(struct SearchSpace__nrofCandidates));
5214                      }
5215                      DU_FREE(searchSpc->monitoringSymbolsWithinSlot->buf, \
5216                            searchSpc->monitoringSymbolsWithinSlot->size);
5217                   }
5218                   DU_FREE(searchSpc->monitoringSymbolsWithinSlot,
5219                         sizeof(BIT_STRING_t));
5220                }
5221                DU_FREE(searchSpc->monitoringSlotPeriodicityAndOffset, \
5222                      sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
5223             }
5224             DU_FREE(searchSpc->controlResourceSetId,
5225                   sizeof(ControlResourceSetId_t));
5226          }
5227       }
5228       for(idx1 = 0; idx1 < searchSpcList->list.count; idx1++)
5229       {
5230          DU_FREE(searchSpcList->list.array[idx1],
5231                sizeof(struct SearchSpace));
5232       }
5233       DU_FREE(searchSpcList->list.array,searchSpcList->list.size);
5234    }
5235 }
5236 /*******************************************************************
5237  *
5238  * @brief Frees memory allocated for PdschTimeDomAllocList
5239  *
5240  * @details
5241  *
5242  *    Function : FreePdschTimeDomAllocList
5243  *
5244  *    Functionality: Deallocating memory of PdschTimeDomAllocList
5245  *
5246  * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
5247  *
5248  * @return void
5249  *
5250  * ****************************************************************/
5251 void FreePdschTimeDomAllocList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
5252 {
5253    uint8_t idx1=0;
5254
5255    if(timeDomAllocList->choice.setup)
5256    {
5257       if(timeDomAllocList->choice.setup->list.array)
5258       {
5259          for(idx1 = 0; idx1 <timeDomAllocList->choice.setup->list.count ; idx1++)
5260          {
5261             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1]->k0, sizeof(long));
5262             DU_FREE(timeDomAllocList->choice.setup->list.array[idx1],
5263                   sizeof(struct PDSCH_TimeDomainResourceAllocation));
5264          }
5265          DU_FREE(timeDomAllocList->choice.setup->list.array, \
5266                timeDomAllocList->choice.setup->list.size);
5267       }
5268       DU_FREE(timeDomAllocList->choice.setup,\
5269             sizeof(struct PDSCH_TimeDomainResourceAllocationList));
5270    }
5271 }
5272 /*******************************************************************
5273  *
5274  * @brief Frees memory allocated for PuschTimeDomAllocList
5275  *
5276  *@details
5277  *
5278  *    Function : FreePuschTimeDomAllocList
5279  *
5280  *    Functionality: Deallocating memory of PuschTimeDomAllocList
5281  *
5282  * @params[in] PUSCH_Config_t *puschCfg
5283  *
5284  * @return void
5285  *
5286  * ****************************************************************/
5287 void FreePuschTimeDomAllocList(PUSCH_Config_t *puschCfg)
5288 {
5289    uint8_t rsrcListIdx=0;
5290    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
5291
5292    if(puschCfg->pusch_TimeDomainAllocationList)
5293    {
5294       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
5295       if(timeDomAllocList_t->choice.setup)
5296       {
5297          if(timeDomAllocList_t->choice.setup->list.array)
5298          {
5299             for(rsrcListIdx = 0; rsrcListIdx<timeDomAllocList_t->choice.setup->list.count; rsrcListIdx++)
5300             {
5301                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx]->k2, sizeof(long));
5302                DU_FREE(timeDomAllocList_t->choice.setup->list.array[rsrcListIdx],\
5303                      sizeof(PUSCH_TimeDomainResourceAllocation_t));
5304             }
5305             DU_FREE(timeDomAllocList_t->choice.setup->list.array, \
5306                   timeDomAllocList_t->choice.setup->list.size);
5307          }
5308          DU_FREE(timeDomAllocList_t->choice.setup, \
5309                sizeof(struct PUSCH_TimeDomainResourceAllocationList));
5310       }
5311       DU_FREE(puschCfg->transformPrecoder, sizeof(long));
5312       DU_FREE(puschCfg->pusch_TimeDomainAllocationList, \
5313             sizeof(struct PUSCH_Config__pusch_TimeDomainAllocationList));
5314    }
5315
5316 }
5317 /*******************************************************************
5318  *
5319  * @brief Frees memory allocated for InitialUlBWP
5320  *
5321  * @details
5322  *
5323  *    Function : FreeInitialUlBWP
5324  *
5325  *    Functionality: Deallocating memory of InitialUlBWP
5326  *
5327  * @params[in] BWP_UplinkDedicated_t *ulBwp
5328  *
5329  * @return void
5330  *
5331  * ****************************************************************/
5332 void FreeInitialUlBWP(BWP_UplinkDedicated_t *ulBwp)
5333 {
5334    uint8_t  rSetIdx, rsrcIdx, k1Idx;
5335    SRS_Config_t   *srsCfg = NULLP;
5336    PUSCH_Config_t *puschCfg = NULLP;
5337    PUCCH_Config_t *pucchCfg = NULLP;
5338    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
5339    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
5340    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
5341    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
5342
5343    if(ulBwp->pucch_Config)
5344    {
5345       if(ulBwp->pucch_Config->choice.setup)
5346       {
5347           pucchCfg = ulBwp->pucch_Config->choice.setup;
5348           if(pucchCfg->dl_DataToUL_ACK)
5349           {
5350              if(pucchCfg->dl_DataToUL_ACK->list.array)
5351              {
5352                 for(k1Idx = 0; k1Idx < pucchCfg->dl_DataToUL_ACK->list.count; k1Idx++)
5353                 {
5354                    DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array[k1Idx], sizeof(long));
5355                 }
5356                 DU_FREE(pucchCfg->dl_DataToUL_ACK->list.array, pucchCfg->dl_DataToUL_ACK->list.size);
5357              }
5358              DU_FREE(pucchCfg->dl_DataToUL_ACK, sizeof(struct PUCCH_Config__dl_DataToUL_ACK));
5359           }
5360           DU_FREE(ulBwp->pucch_Config->choice.setup, sizeof(PUCCH_Config_t));
5361       }
5362       DU_FREE(ulBwp->pucch_Config, sizeof(struct BWP_UplinkDedicated__pucch_Config));
5363    }
5364
5365    if(ulBwp->pusch_Config)
5366    {
5367       if(ulBwp->pusch_Config->choice.setup)
5368       {
5369          puschCfg=ulBwp->pusch_Config->choice.setup;
5370          if(puschCfg->dataScramblingIdentityPUSCH)
5371          {
5372             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
5373             {
5374                FreePuschTimeDomAllocList(puschCfg);
5375                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
5376                if(dmrsUlCfg->choice.setup)
5377                {
5378                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
5379                   {
5380                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
5381                      {
5382                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0,\
5383                               sizeof(long));
5384                         DU_FREE(dmrsUlCfg->choice.setup->transformPrecodingDisabled,
5385                               sizeof(struct DMRS_UplinkConfig__transformPrecodingDisabled));
5386                      }
5387                      DU_FREE(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition,
5388                            sizeof(long));
5389                   }
5390                   DU_FREE(dmrsUlCfg->choice.setup,sizeof(DMRS_UplinkConfig_t));
5391                }
5392                DU_FREE(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA, \
5393                      sizeof(struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA));
5394             }
5395             DU_FREE(puschCfg->dataScramblingIdentityPUSCH, sizeof(long));
5396          }
5397          DU_FREE(ulBwp->pusch_Config->choice.setup, sizeof(PUSCH_Config_t));
5398       }
5399       DU_FREE(ulBwp->pusch_Config, sizeof(struct BWP_UplinkDedicated__pusch_Config));
5400
5401       /* Free SRS-Config */
5402       if(ulBwp->srs_Config)
5403       {
5404          if(ulBwp->srs_Config->choice.setup)
5405          {
5406             srsCfg = ulBwp->srs_Config->choice.setup;
5407
5408             /* Free Resource Set to add/mod list */
5409             if(srsCfg->srs_ResourceSetToAddModList)
5410             {
5411                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
5412                if(rsrcSetList->list.array)
5413                {
5414                   rSetIdx = 0;
5415
5416                   /* Free SRS resource Id list in this SRS resource set */
5417                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
5418                   {
5419                      rsrcIdList = rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
5420
5421                      if(rsrcIdList->list.array)
5422                      {
5423                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count; rsrcIdx++)
5424                         {
5425                            DU_FREE(rsrcIdList->list.array[rsrcIdx], sizeof(SRS_ResourceId_t));
5426                         }
5427                         DU_FREE(rsrcIdList->list.array, rsrcIdList->list.size);
5428                      }
5429                      DU_FREE(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList,\
5430                            sizeof(struct SRS_ResourceSet__srs_ResourceIdList));
5431                   }
5432
5433                   /* Free resource type info for this SRS resource set */
5434                   DU_FREE(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic, \
5435                         sizeof(struct SRS_ResourceSet__resourceType__aperiodic));
5436
5437                   /* Free memory for each resource set */
5438                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
5439                   {
5440                      DU_FREE(rsrcSetList->list.array[rSetIdx], sizeof(SRS_ResourceSet_t));
5441                   }
5442                   DU_FREE(rsrcSetList->list.array, rsrcSetList->list.size);
5443                }
5444                DU_FREE(srsCfg->srs_ResourceSetToAddModList, \
5445                      sizeof(struct SRS_Config__srs_ResourceSetToAddModList));
5446             }
5447
5448             /* Free resource to add/modd list */
5449             if(srsCfg->srs_ResourceToAddModList)
5450             {
5451                resourceList = srsCfg->srs_ResourceToAddModList;
5452                if(resourceList->list.array)
5453                {
5454                   rsrcIdx = 0;
5455                   DU_FREE(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2,\
5456                         sizeof(struct SRS_Resource__transmissionComb__n2));
5457                   DU_FREE(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic,\
5458                         sizeof(struct SRS_Resource__resourceType__aperiodic));
5459
5460                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
5461                   {
5462                      DU_FREE(resourceList->list.array[rsrcIdx], sizeof(SRS_Resource_t));
5463                   }
5464                   DU_FREE(resourceList->list.array, resourceList->list.size);
5465                }
5466                DU_FREE(srsCfg->srs_ResourceToAddModList, \
5467                      sizeof(struct SRS_Config__srs_ResourceToAddModList));
5468             }
5469
5470             DU_FREE(ulBwp->srs_Config->choice.setup, sizeof(SRS_Config_t));
5471          }
5472          DU_FREE(ulBwp->srs_Config, sizeof(struct BWP_UplinkDedicated__srs_Config));
5473       }
5474    }
5475 }
5476 /*******************************************************************
5477  *
5478  * @brief Frees memory allocated for initialUplinkBWP
5479  *
5480  * @details
5481  *
5482  *    Function : FreeinitialUplinkBWP
5483  *
5484  *    Functionality: Deallocating memory of initialUplinkBWP
5485  *
5486  * @params[in] UplinkConfig_t *ulCfg
5487  *
5488  * @return void
5489  *
5490  *
5491  * ****************************************************************/
5492 void FreeinitialUplinkBWP(UplinkConfig_t *ulCfg)
5493 {
5494    BWP_UplinkDedicated_t *ulBwp=NULLP;
5495    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
5496
5497    if(ulCfg->initialUplinkBWP)
5498    {
5499       ulBwp=ulCfg->initialUplinkBWP;
5500       if(ulCfg->firstActiveUplinkBWP_Id)
5501       {
5502          if(ulCfg->pusch_ServingCellConfig)
5503          {
5504             puschCfg=ulCfg->pusch_ServingCellConfig;
5505             if(puschCfg->choice.setup)
5506             {
5507                if(puschCfg->choice.setup->ext1)
5508                {
5509                   DU_FREE(puschCfg->choice.setup->ext1->\
5510                         processingType2Enabled,sizeof(BOOLEAN_t));
5511                   DU_FREE(puschCfg->choice.setup->ext1->\
5512                         maxMIMO_Layers,sizeof(long));
5513                   DU_FREE(puschCfg->choice.setup->ext1, \
5514                         sizeof(struct PUSCH_ServingCellConfig__ext1));
5515                }
5516                DU_FREE(puschCfg->choice.setup, sizeof(struct PUSCH_ServingCellConfig));
5517             }
5518             DU_FREE(ulCfg->pusch_ServingCellConfig, sizeof(struct UplinkConfig__pusch_ServingCellConfig));
5519          }
5520          DU_FREE(ulCfg->firstActiveUplinkBWP_Id, sizeof(BWP_Id_t));
5521       }
5522       FreeInitialUlBWP(ulBwp);
5523       DU_FREE(ulCfg->initialUplinkBWP, sizeof(BWP_UplinkDedicated_t));
5524    }
5525 }
5526 /*******************************************************************
5527  *
5528  * @brief Frees emmory allocated for BWPDlDedPdschCfg
5529  *
5530  * @details
5531  *
5532  *    Function : FreeBWPDlDedPdschCfg
5533  *
5534  *    Functionality: Deallocating memory of BWPDlDedPdschCfg
5535  *
5536  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5537  *
5538  * @return void
5539  *
5540  *
5541  * ****************************************************************/
5542 void FreeBWPDlDedPdschCfg(BWP_DownlinkDedicated_t *dlBwp)
5543 {
5544    struct PDSCH_Config *pdschCfg=NULLP;
5545    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
5546    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
5547    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
5548
5549    if(dlBwp->pdsch_Config->choice.setup)
5550    {
5551       pdschCfg=dlBwp->pdsch_Config->choice.setup;
5552       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
5553       {
5554          if(pdschCfg->pdsch_TimeDomainAllocationList)
5555          {
5556             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
5557             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
5558             {
5559                prbBndlType=&pdschCfg->prb_BundlingType;
5560                DU_FREE(prbBndlType->choice.staticBundling,\
5561                      sizeof(struct PDSCH_Config__prb_BundlingType__staticBundling));
5562                DU_FREE(pdschCfg->maxNrofCodeWordsScheduledByDCI, sizeof(long));
5563             }
5564             FreePdschTimeDomAllocList(timeDomAllocList);
5565             DU_FREE(pdschCfg->pdsch_TimeDomainAllocationList, \
5566                   sizeof(struct PDSCH_Config__pdsch_TimeDomainAllocationList));
5567          }
5568          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
5569          if(dmrsDlCfg->choice.setup)
5570          {
5571             DU_FREE(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition,
5572                   sizeof(long));
5573             DU_FREE(dmrsDlCfg->choice.setup, sizeof(struct DMRS_DownlinkConfig));
5574          }
5575          DU_FREE(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA, \
5576                sizeof(struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA));
5577       }
5578       DU_FREE(dlBwp->pdsch_Config->choice.setup, sizeof(struct PDSCH_Config));
5579    }
5580 }
5581 /*******************************************************************
5582  *
5583  * @brief Frees emmory allocated for BWPDlDedPdcchCfg
5584  *
5585  * @details
5586  *
5587  *    Function : FreeBWPDlDedPdcchCfg
5588  *
5589  *    Functionality: Deallocating memory of BWPDlDedPdcchCfg
5590  *
5591  * @params[in] BWP_DownlinkDedicated_t *dlBwp
5592  *
5593  * @return void
5594  *
5595  *
5596  * ****************************************************************/
5597 void FreeBWPDlDedPdcchCfg(BWP_DownlinkDedicated_t *dlBwp)
5598 {
5599    uint8_t idx1=0;
5600    uint8_t idx2=0;
5601    struct PDCCH_Config *pdcchCfg=NULLP;
5602    struct ControlResourceSet *controlRSet=NULLP;
5603    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
5604
5605    if(dlBwp->pdcch_Config->choice.setup)
5606    {
5607       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
5608       if(pdcchCfg->controlResourceSetToAddModList)
5609       {
5610          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
5611          if(controlRSetList->list.array)
5612          {
5613             controlRSet = controlRSetList->list.array[idx2];
5614             if(controlRSet)
5615             {
5616                if(controlRSet->frequencyDomainResources.buf)
5617                {
5618                   if(controlRSet->pdcch_DMRS_ScramblingID)
5619                   {
5620                      if(pdcchCfg->searchSpacesToAddModList)
5621                      {
5622                         FreeSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
5623                         DU_FREE(pdcchCfg->searchSpacesToAddModList, \
5624                               sizeof(struct PDCCH_Config__searchSpacesToAddModList));
5625                      }
5626                      DU_FREE(controlRSet->pdcch_DMRS_ScramblingID, sizeof(long));
5627                   }
5628                   DU_FREE(controlRSet->frequencyDomainResources.buf, \
5629                         controlRSet->frequencyDomainResources.size);
5630                }
5631             }
5632             for(idx1 = 0; idx1 <controlRSetList->list.count; idx1++)
5633             {
5634                DU_FREE(controlRSetList->list.array[idx1], sizeof(struct ControlResourceSet));
5635             }
5636             DU_FREE(controlRSetList->list.array, controlRSetList->list.size);
5637          }
5638          DU_FREE(pdcchCfg->controlResourceSetToAddModList, \
5639                sizeof(struct PDCCH_Config__controlResourceSetToAddModList));
5640       }
5641       DU_FREE(dlBwp->pdcch_Config->choice.setup, sizeof(struct PDCCH_Config));
5642    }
5643 }
5644
5645 /*******************************************************************
5646  *
5647  * @brief Frees emmory allocated for DUToCURRCContainer
5648  *
5649  * @details
5650  *
5651  *    Function : FreeMemDuToCuRrcCont
5652  *
5653  *    Functionality: Deallocating memory of DuToCuRrcContainer
5654  *
5655  * @params[in] DuToCuRRCContainer, DuToCuRRCContainer
5656  *
5657  * @return ROK     - success
5658  *         RFAILED - failure
5659  *
5660  * ****************************************************************/
5661 uint8_t FreeMemDuToCuRrcCont(CellGroupConfigRrc_t *cellGrpCfg)
5662 {
5663    uint8_t idx=0;
5664    SpCellConfig_t *spCellCfg=NULLP;
5665    ServingCellConfig_t *srvCellCfg=NULLP;
5666    BWP_DownlinkDedicated_t *dlBwp=NULLP;
5667    MAC_CellGroupConfig_t *macCellGrpCfg=NULLP;
5668    PhysicalCellGroupConfig_t *phyCellGrpCfg=NULLP;
5669    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList=NULLP;
5670    struct RLC_Config *rlcConfig=NULLP;
5671    struct LogicalChannelConfig *macLcConfig=NULLP;
5672    struct SchedulingRequestConfig *schedulingRequestConfig=NULLP;
5673    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList=NULLP;
5674    struct TAG_Config *tagConfig=NULLP;
5675    struct TAG_Config__tag_ToAddModList *tagList=NULLP;
5676    struct MAC_CellGroupConfig__phr_Config *phrConfig=NULLP;
5677    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg=NULLP;
5678
5679    rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
5680    if(rlcBearerList)
5681    {
5682       if(rlcBearerList->list.array)
5683       {
5684          for(idx=0; idx<rlcBearerList->list.count; idx++)
5685          {
5686             if(rlcBearerList->list.array[idx])
5687             {
5688                rlcConfig   = rlcBearerList->list.array[idx]->rlc_Config;
5689                macLcConfig = rlcBearerList->list.array[idx]->mac_LogicalChannelConfig;
5690                if(rlcConfig)
5691                {
5692                   if(rlcConfig->choice.am)
5693                   {
5694                      DU_FREE(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5695                      DU_FREE(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength, sizeof(SN_FieldLengthAM_t));
5696                      DU_FREE(rlcConfig->choice.am, sizeof(struct RLC_Config__am));
5697                   }
5698                   DU_FREE(rlcConfig, sizeof(struct RLC_Config));
5699                }
5700                DU_FREE(rlcBearerList->list.array[idx]->servedRadioBearer, sizeof(struct RLC_BearerConfig__servedRadioBearer));
5701                if(macLcConfig)
5702                {
5703                   if(macLcConfig->ul_SpecificParameters)
5704                   {
5705                      DU_FREE(macLcConfig->ul_SpecificParameters->schedulingRequestID,   sizeof(SchedulingRequestId_t));
5706                      DU_FREE(macLcConfig->ul_SpecificParameters->logicalChannelGroup,   sizeof(long));
5707                      DU_FREE(macLcConfig->ul_SpecificParameters, sizeof(struct LogicalChannelConfig__ul_SpecificParameters));
5708                   }
5709                   DU_FREE(rlcBearerList->list.array[idx]->mac_LogicalChannelConfig, sizeof(struct LogicalChannelConfig));
5710                }
5711                DU_FREE(rlcBearerList->list.array[idx], sizeof(struct RLC_BearerConfig));
5712             }
5713          }
5714          DU_FREE(rlcBearerList->list.array, rlcBearerList->list.size);
5715       }
5716       DU_FREE(cellGrpCfg->rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5717    }
5718
5719    macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
5720    if(macCellGrpCfg)
5721    {
5722       schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
5723       if(schedulingRequestConfig)
5724       {
5725          schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
5726          if(schReqList)
5727          {
5728             if(schReqList->list.array)
5729             {
5730                for(idx=0;idx<schReqList->list.count; idx++)
5731                {
5732                   if(schReqList->list.array[idx])
5733                   {
5734                      DU_FREE(schReqList->list.array[idx]->sr_ProhibitTimer, sizeof(long));
5735                      DU_FREE(schReqList->list.array[idx], sizeof(struct SchedulingRequestToAddMod));
5736                   }
5737                }
5738                DU_FREE(schReqList->list.array, schReqList->list.size);
5739             }
5740             DU_FREE(schedulingRequestConfig->schedulingRequestToAddModList,\
5741                   sizeof(struct SchedulingRequestConfig__schedulingRequestToAddModList));    }
5742             DU_FREE(macCellGrpCfg->schedulingRequestConfig, sizeof(struct SchedulingRequestConfig));
5743       }
5744       if(macCellGrpCfg->bsr_Config)
5745       {
5746          DU_FREE(macCellGrpCfg->bsr_Config, sizeof(struct BSR_Config));
5747       }
5748       tagConfig = macCellGrpCfg->tag_Config;
5749       if(tagConfig)
5750       {
5751          tagList = tagConfig->tag_ToAddModList;
5752          if(tagList)
5753          {
5754             if(tagList->list.array)
5755             {
5756                for(idx=0; idx<tagList->list.count; idx++)
5757                {
5758                   DU_FREE(tagList->list.array[idx], sizeof(struct TAG));
5759                }
5760                DU_FREE(tagList->list.array, tagList->list.size);
5761             }
5762             DU_FREE(tagConfig->tag_ToAddModList, sizeof(struct TAG_Config__tag_ToAddModList));
5763          }
5764          DU_FREE(tagConfig, sizeof(struct TAG_Config));
5765       }
5766
5767       phrConfig = macCellGrpCfg->phr_Config;
5768       if(phrConfig)
5769       {
5770          DU_FREE(phrConfig->choice.setup, sizeof(struct PHR_Config));
5771          DU_FREE(phrConfig, sizeof(struct MAC_CellGroupConfig__phr_Config));
5772       }
5773
5774       DU_FREE(macCellGrpCfg, sizeof(MAC_CellGroupConfig_t));
5775    }
5776
5777    phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
5778    if(phyCellGrpCfg)
5779    {
5780       DU_FREE(phyCellGrpCfg->p_NR_FR1, sizeof(long));
5781       DU_FREE(phyCellGrpCfg, sizeof(PhysicalCellGroupConfig_t));
5782    }
5783
5784    spCellCfg = cellGrpCfg->spCellConfig;
5785    if(spCellCfg)
5786    {
5787       if(spCellCfg->servCellIndex)
5788       {
5789          if(spCellCfg->rlmInSyncOutOfSyncThreshold)
5790          {
5791             if(spCellCfg->spCellConfigDedicated)
5792             {
5793                srvCellCfg = spCellCfg->spCellConfigDedicated;
5794                if(srvCellCfg->tdd_UL_DL_ConfigurationDedicated)
5795                {
5796                   if(srvCellCfg->initialDownlinkBWP)
5797                   {
5798                      dlBwp = srvCellCfg->initialDownlinkBWP;
5799                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
5800                      {
5801                         if(srvCellCfg->defaultDownlinkBWP_Id)
5802                         {
5803                            if(srvCellCfg->uplinkConfig)
5804                            {
5805                               if(srvCellCfg->pdsch_ServingCellConfig)
5806                               {
5807                                  pdschCfg= srvCellCfg->pdsch_ServingCellConfig;
5808                                  if(pdschCfg->choice.setup)
5809                                  {
5810                                     DU_FREE(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH,sizeof(long));
5811                                     DU_FREE(pdschCfg->choice.setup, sizeof( struct PDSCH_ServingCellConfig));
5812                                  }
5813                                  DU_FREE(srvCellCfg->pdsch_ServingCellConfig, sizeof(struct
5814                                           ServingCellConfig__pdsch_ServingCellConfig));
5815                               }
5816                               FreeinitialUplinkBWP(srvCellCfg->uplinkConfig);
5817                               DU_FREE(srvCellCfg->uplinkConfig, sizeof(UplinkConfig_t));
5818                            }
5819                            DU_FREE(srvCellCfg->defaultDownlinkBWP_Id, sizeof(long));
5820                         }
5821                         DU_FREE(srvCellCfg->firstActiveDownlinkBWP_Id, sizeof(long));
5822                      }
5823                      if(dlBwp->pdcch_Config)
5824                      {
5825                         if(dlBwp->pdsch_Config)
5826                         {
5827                            FreeBWPDlDedPdschCfg(dlBwp);
5828                            DU_FREE(dlBwp->pdsch_Config, sizeof(struct BWP_DownlinkDedicated__pdsch_Config));
5829                         }
5830                         FreeBWPDlDedPdcchCfg(dlBwp);
5831                         DU_FREE(dlBwp->pdcch_Config, sizeof(struct BWP_DownlinkDedicated__pdcch_Config));
5832                      }
5833                      DU_FREE(srvCellCfg->initialDownlinkBWP, sizeof(BWP_DownlinkDedicated_t));
5834                   }
5835                   DU_FREE(srvCellCfg->tdd_UL_DL_ConfigurationDedicated, sizeof(TDD_UL_DL_ConfigDedicated_t));
5836                }
5837                DU_FREE(spCellCfg->spCellConfigDedicated, sizeof(ServingCellConfig_t));
5838             }
5839             DU_FREE(spCellCfg->rlmInSyncOutOfSyncThreshold, sizeof(long));
5840          }
5841          DU_FREE(spCellCfg->servCellIndex, sizeof(long));
5842       }
5843       DU_FREE(spCellCfg,sizeof(SpCellConfig_t));
5844    }
5845    return ROK;
5846 }
5847 /*******************************************************************
5848  *
5849  * @brief Builds DU To CU RRC Container
5850  *
5851  * @details
5852  *
5853  *    Function : BuildDuToCuRrcContainer
5854  *
5855  *    Functionality: Builds DuToCuRrcContainer
5856  *
5857  * @params[in] idx, index in F1AP msg
5858  *             DuToCuRRCContainer, DuToCuRRCContainer
5859  *
5860  * @return ROK     - success
5861  *         RFAILED - failure
5862  *
5863  * ****************************************************************/
5864 uint8_t BuildDuToCuRrcContainer(DUtoCURRCContainer_t *duToCuRrcContainer)
5865 {
5866    uint8_t  ret = ROK;
5867    CellGroupConfigRrc_t  cellGrpCfg;
5868    asn_enc_rval_t        encRetVal;
5869    memset(&cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
5870    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
5871
5872    while(true)
5873    {
5874       cellGrpCfg.cellGroupId = CELL_GRP_ID;
5875
5876       cellGrpCfg.rlc_BearerToAddModList = NULLP;
5877       DU_ALLOC(cellGrpCfg.rlc_BearerToAddModList, sizeof(struct CellGroupConfigRrc__rlc_BearerToAddModList));
5878       if(!cellGrpCfg.rlc_BearerToAddModList)
5879       {
5880          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5881          ret = RFAILED;
5882          break;
5883       }
5884       if(BuildRlcBearerToAddModList(cellGrpCfg.rlc_BearerToAddModList) != ROK)
5885       {
5886          DU_LOG("\nERROR  -->  F1AP : BuildRlcBearerToAddModList failed");
5887          ret = RFAILED;
5888          break;
5889       }
5890
5891       cellGrpCfg.rlc_BearerToReleaseList = NULLP;
5892       cellGrpCfg.mac_CellGroupConfig = NULLP;
5893       DU_ALLOC(cellGrpCfg.mac_CellGroupConfig, sizeof(MAC_CellGroupConfig_t));
5894       if(!cellGrpCfg.mac_CellGroupConfig)
5895       {
5896          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5897          ret = RFAILED;
5898          break;
5899       }
5900       if(BuildMacCellGrpCfg(cellGrpCfg.mac_CellGroupConfig) != ROK)
5901       {
5902          DU_LOG("\nERROR  -->  F1AP : BuildMacCellGrpCfg failed");
5903          ret = RFAILED;
5904          break;
5905       }
5906
5907       cellGrpCfg.physicalCellGroupConfig = NULLP;
5908       DU_ALLOC(cellGrpCfg.physicalCellGroupConfig, sizeof(PhysicalCellGroupConfig_t));
5909       if(!cellGrpCfg.physicalCellGroupConfig)
5910       {
5911          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5912          ret = RFAILED;
5913          break;
5914       }
5915       if(BuildPhyCellGrpCfg(cellGrpCfg.physicalCellGroupConfig) != ROK)
5916       {
5917          DU_LOG("\nERROR  -->  F1AP : BuildPhyCellGrpCfg failed");
5918          ret = RFAILED;
5919          break;
5920       }
5921
5922       cellGrpCfg.spCellConfig = NULLP;
5923       DU_ALLOC(cellGrpCfg.spCellConfig, sizeof(SpCellConfig_t));
5924       if(!cellGrpCfg.spCellConfig)
5925       {
5926          DU_LOG("\nERROR  -->  F1AP : Memory allocation failure in BuildDuToCuRrcContainer");
5927          ret = RFAILED;
5928          break;
5929       }
5930       if(BuildSpCellCfg(cellGrpCfg.spCellConfig) != ROK)
5931       {
5932          DU_LOG("\nERROR  -->  F1AP : BuildSpCellCfg failed");
5933          ret = RFAILED;
5934          break;
5935       }
5936
5937       cellGrpCfg.sCellToAddModList = NULLP;
5938       cellGrpCfg.sCellToReleaseList = NULLP;
5939       cellGrpCfg.ext1 = NULLP;
5940
5941       /* encode cellGrpCfg into duToCuRrcContainer */
5942       xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, &cellGrpCfg);
5943       memset(encBuf, 0, ENC_BUF_MAX_LEN);
5944       encBufSize = 0;
5945       encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, &cellGrpCfg, PrepFinalEncBuf, encBuf);
5946       /* Encode results */
5947       if(encRetVal.encoded == ENCODE_FAIL)
5948       {
5949          DU_LOG( "\nERROR  --> F1AP : Could not encode DuToCuRrcContainer (at %s)\n",\
5950                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
5951          ret = RFAILED;
5952          break;
5953       }
5954       else
5955       {
5956          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for DuToCuRrcContainer\n");
5957          for(int i=0; i< encBufSize; i++)
5958          {
5959             printf("%x",encBuf[i]);
5960          }
5961       }
5962
5963       duToCuRrcContainer->size = encBufSize;
5964       DU_ALLOC(duToCuRrcContainer->buf, duToCuRrcContainer->size);
5965       if(!duToCuRrcContainer->buf)
5966       {
5967          DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDuToCuRrcContainer");
5968          ret = RFAILED;
5969          break;
5970       }
5971       if(ret == ROK)
5972       {
5973          memcpy(duToCuRrcContainer->buf, encBuf, duToCuRrcContainer->size);
5974       }
5975       break;
5976    }
5977    FreeMemDuToCuRrcCont(&cellGrpCfg);
5978    return ret;
5979 }
5980
5981 /*******************************************************************
5982  *
5983  * @brief Free memory allocated in InitialULRRCMessage
5984  *
5985  * @details
5986  *
5987  *    Function : freeInitUlRrcMsgTransfer
5988  *
5989  *    Functionality: Free memory allocated in InitialULRRCMessage
5990  *
5991  * @params[in]F1AP_PDU_t  *f1apMsg)
5992  *
5993  * @return ROK     - success
5994  *         RFAILED - failure
5995  *
5996  * ****************************************************************/
5997
5998 uint8_t freeInitUlRrcMsgTransfer(F1AP_PDU_t  *f1apMsg)
5999 {
6000    uint8_t ieIdx, arrIdx;
6001    InitialULRRCMessageTransfer_t *initULRRCMsg=NULLP;
6002
6003    if(f1apMsg)
6004    {
6005       if(f1apMsg->choice.initiatingMessage)
6006       {
6007          initULRRCMsg = &f1apMsg->choice.initiatingMessage->value.\
6008             choice.InitialULRRCMessageTransfer;
6009          if(initULRRCMsg->protocolIEs.list.array)
6010          {
6011             for(ieIdx = 0; ieIdx < initULRRCMsg->protocolIEs.list.count; ieIdx++)
6012             {
6013                switch(initULRRCMsg->protocolIEs.list.array[ieIdx]->id)
6014                {
6015                   case ProtocolIE_ID_id_NRCGI:
6016                   {
6017                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf)
6018                      {
6019                         if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf)
6020                         {
6021                            DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.buf,\
6022                            initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.nRCellIdentity.size);
6023                         }
6024                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.buf,\
6025                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI.pLMN_Identity.size);
6026                      }
6027                      break;
6028                   }
6029                   case ProtocolIE_ID_id_RRCContainer:
6030                   {
6031                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
6032                      {
6033                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,\
6034                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
6035                      }
6036                      break;
6037                   }
6038                   case ProtocolIE_ID_id_DUtoCURRCContainer:
6039                   {
6040                      if(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf)
6041                      {
6042                         DU_FREE(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.buf,
6043                         initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer.size);
6044                      }
6045                      break;
6046                   }
6047                   default:
6048                      break;
6049                }
6050              }
6051              for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
6052              {
6053                 if(initULRRCMsg->protocolIEs.list.array[arrIdx])
6054                 {
6055                    DU_FREE(initULRRCMsg->protocolIEs.list.array[arrIdx],\
6056                       sizeof(InitialULRRCMessageTransferIEs_t));
6057                 }
6058              }
6059              DU_FREE(initULRRCMsg->protocolIEs.list.array, initULRRCMsg->protocolIEs.list.size);
6060           }
6061          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
6062       }
6063       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
6064    }
6065    else
6066    {
6067       DU_LOG("\nERROR  -->  DU_APP : Recevied F1ap Pdu is null at freeInitUlRrcMsgTransfer()");
6068       return RFAILED;
6069    }
6070    return ROK;
6071 }
6072
6073 /*******************************************************************
6074  *
6075  * @brief Builds and sends the InitialULRRCMessage
6076  *
6077  * @details
6078  *
6079  *    Function : BuildAndSendInitialRrcMsgTransfer
6080  *
6081  *    Functionality: Constructs the Initial UL RRC Message Transfer and sends
6082  *                   it to the CU through SCTP.
6083  *
6084  * @params[in]
6085  *
6086  * @return ROK     - success
6087  *         RFAILED - failure
6088  *
6089  * ****************************************************************/
6090 uint8_t BuildAndSendInitialRrcMsgTransfer(uint32_t gnbDuUeF1apId, uint16_t crnti,
6091       uint16_t rrcContSize, uint8_t *rrcContainer)
6092 {
6093    uint8_t   ret;
6094    uint8_t   elementCnt;
6095    uint8_t   ieIdx;
6096    asn_enc_rval_t  encRetVal;
6097    F1AP_PDU_t  *f1apMsg = NULLP;
6098    InitialULRRCMessageTransfer_t *initULRRCMsg = NULLP;
6099    memset(&encRetVal, 0, sizeof(asn_enc_rval_t));
6100
6101    while(true)
6102    {
6103       DU_LOG("\n INFO   -->  F1AP : Building RRC Setup Request\n");
6104       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
6105       if(f1apMsg == NULLP)
6106       {
6107          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
6108          break;
6109       }
6110       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
6111       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
6112       if(f1apMsg->choice.initiatingMessage == NULLP)
6113       {
6114          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU failed");
6115          break;
6116       }
6117       f1apMsg->choice.initiatingMessage->procedureCode =\
6118                                                         ProcedureCode_id_InitialULRRCMessageTransfer;
6119       f1apMsg->choice.initiatingMessage->criticality = Criticality_ignore;
6120       f1apMsg->choice.initiatingMessage->value.present = \
6121                                                          InitiatingMessage__value_PR_InitialULRRCMessageTransfer;
6122       initULRRCMsg =\
6123                     &f1apMsg->choice.initiatingMessage->value.choice.InitialULRRCMessageTransfer;
6124       elementCnt = 5;
6125       initULRRCMsg->protocolIEs.list.count = elementCnt;
6126       initULRRCMsg->protocolIEs.list.size = \
6127                                             elementCnt * sizeof(InitialULRRCMessageTransferIEs_t *);
6128       /* Initialize the F1Setup members */
6129       DU_ALLOC(initULRRCMsg->protocolIEs.list.array,initULRRCMsg->protocolIEs.list.size);
6130       if(initULRRCMsg->protocolIEs.list.array == NULLP)
6131       {
6132          DU_LOG(" ERROR  -->  F1AP : Memory allocation for\
6133                RRCSetupRequestMessageTransferIEs failed");
6134          break;
6135       }
6136       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
6137       {
6138          DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx],\
6139                sizeof(InitialULRRCMessageTransferIEs_t));
6140          if(initULRRCMsg->protocolIEs.list.array[ieIdx] == NULLP)
6141          {
6142             break;
6143          }
6144       }
6145       ieIdx = 0;
6146       /*GNB DU UE F1AP ID*/
6147       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6148                                                         ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
6149       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  = Criticality_reject;
6150       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
6151                                                                   InitialULRRCMessageTransferIEs__value_PR_GNB_DU_UE_F1AP_ID;
6152       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
6153
6154
6155       /*NRCGI*/
6156       ieIdx++;
6157       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6158                                                         ProtocolIE_ID_id_NRCGI;
6159       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality  =Criticality_reject;
6160       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present = \
6161                                                                   InitialULRRCMessageTransferIEs__value_PR_NRCGI;
6162
6163       ret =\
6164            BuildNrcgi(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
6165       if(ret!=ROK)
6166       {
6167          break;
6168       }
6169
6170       /*CRNTI*/
6171       ieIdx++;
6172       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6173                                                         ProtocolIE_ID_id_C_RNTI;
6174       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6175       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6176                                                                  InitialULRRCMessageTransferIEs__value_PR_C_RNTI;
6177       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.C_RNTI = crnti;
6178
6179       /*RRCContainer*/
6180       ieIdx++;
6181       initULRRCMsg->protocolIEs.list.array[ieIdx]->id  = \
6182                                                         ProtocolIE_ID_id_RRCContainer;
6183       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6184       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6185                                                                  InitialULRRCMessageTransferIEs__value_PR_RRCContainer;
6186
6187       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size = rrcContSize;
6188       DU_ALLOC(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf,
6189             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size)
6190       if(!initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
6191       {
6192          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRCSetupRequestMessageTransferIEs failed");
6193          break;
6194
6195       }
6196       memcpy(initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf, rrcContainer,
6197             initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.size);
6198
6199
6200       /*DUtoCURRCContainer*/
6201       ieIdx++;
6202       initULRRCMsg->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DUtoCURRCContainer;
6203       initULRRCMsg->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
6204       initULRRCMsg->protocolIEs.list.array[ieIdx]->value.present =\
6205                                                                  InitialULRRCMessageTransferIEs__value_PR_DUtoCURRCContainer;
6206
6207       ret = BuildDuToCuRrcContainer(&initULRRCMsg->protocolIEs.list.array[ieIdx]->value.choice.DUtoCURRCContainer);
6208       if(ret != ROK)
6209       {
6210          break;
6211       }
6212
6213       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
6214
6215       /* Encode the F1SetupRequest type as APER */
6216       memset(encBuf, 0, ENC_BUF_MAX_LEN);
6217       encBufSize = 0;
6218       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
6219       /* Encode results */
6220       if(encRetVal.encoded == ENCODE_FAIL)
6221       {
6222          DU_LOG( "\nERROR  --> F1AP : Could not encode Initial UL RRC Message Transfer\
6223                structure (at %s)\n",encRetVal.failed_type ? \
6224                encRetVal.failed_type->name : "unknown");
6225          ret = RFAILED;
6226          break;
6227       }
6228       else
6229       {
6230
6231          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for Initial UL RRC\
6232                Message transfer\n");
6233          for(int i=0; i< encBufSize; i++)
6234          {
6235             printf("%x",encBuf[i]);
6236          }
6237       }
6238       /* Sending  msg  */
6239       if(sendF1APMsg() != ROK)
6240       {
6241          DU_LOG("\nERROR  -->  F1AP : Sending Initial UL RRC Message Transfer Failed");
6242          ret = RFAILED;
6243          break;
6244       }
6245       break;
6246    }
6247    freeInitUlRrcMsgTransfer(f1apMsg);
6248    return ret;
6249 }/* End of BuildAndSendInitialRrcMsgTransfer*/
6250
6251 /*****  UE SETUP REQUEST *****/
6252
6253 /*******************************************************************
6254  *
6255  * @brief Free Qos And Snssai Drb Info
6256  *
6257  * @details
6258  *
6259  *    Function : freeDrbQosAndSnssaiInfo
6260  *
6261  *    Functionality: Free Qos And Snssai Drb Info
6262  *
6263  * @params[in] LcCfg *lcCfg,
6264  * @return void
6265  *
6266  * ****************************************************************/
6267 void freeDrbQosAndSnssaiInfo(LcCfg *lcCfg)
6268 {
6269    if(lcCfg->snssai)
6270    {
6271       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6272    }
6273    if(lcCfg->drbQos)
6274    {
6275       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
6276    }
6277 }
6278
6279 /******************************************************************
6280 *
6281 * @brief Function to delete the RLC Lc cfg from UE APP DB
6282 *
6283 * @details
6284 *
6285 *  Function : freeRlcLcCfg
6286 *
6287 *  Functionality: Function to delete the RLC Lc cfg from UE APP DB
6288 *
6289 *
6290  *****************************************************************/
6291
6292 void freeRlcLcCfg(RlcBearerCfg *lcCfg)
6293 {
6294    switch(lcCfg->rlcMode)
6295    {
6296       case RLC_AM :
6297          {
6298             if(lcCfg->u.amCfg)
6299             {
6300                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.amCfg, sizeof(AmBearerCfg));
6301             }
6302             break;
6303          }
6304       case RLC_UM_BI_DIRECTIONAL :
6305          {
6306             if(lcCfg->u.umBiDirCfg)
6307             {
6308                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
6309             }
6310             break;
6311          }
6312       case RLC_UM_UNI_DIRECTIONAL_UL :
6313          {
6314             if(lcCfg->u.umUniDirUlCfg)
6315             {
6316                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
6317             }
6318             break;
6319
6320          }
6321       case RLC_UM_UNI_DIRECTIONAL_DL :
6322          {
6323             if(lcCfg->u.umUniDirDlCfg)
6324             {
6325                DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
6326             }
6327             break;
6328          }
6329       default:
6330          DU_LOG("\nERROR  -->  DU_APP: Invalid Rlc Mode %d at freeRlcLcCfg()", lcCfg->rlcMode);
6331          break;
6332    }
6333 }
6334
6335 /*******************************************************************
6336  *
6337  * @brief Function to free MacLcCfg
6338  *
6339  * @details
6340  *
6341  *    Function : freeMacLcCfg
6342  *
6343  *    Functionality: Function to free MacLcCfg
6344  *
6345  * @params[in] LcCfg *lcCfg,
6346  * @return void
6347  *
6348  * ****************************************************************/
6349
6350 void  freeMacLcCfg(LcCfg *lcCfg)
6351 {
6352     /* Deleting DRBQOS */
6353    if(lcCfg->drbQos)
6354    {
6355       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->drbQos, sizeof(DrbQosInfo));
6356    }
6357    /* Deleting SNSSAI */
6358    if(lcCfg->snssai)
6359    {
6360       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, lcCfg->snssai, sizeof(Snssai));
6361    }
6362 }
6363 /*******************************************************************
6364  *
6365  * @brief Free UE NR Capability received in UE Context setup request
6366  *
6367  * @details
6368  *
6369  *    Function : freeAperDecodeUeNrCapability
6370  *
6371  *    Functionality:
6372  *       Free UE NR Capability received in UE Context setup request
6373  *
6374  * @params[in]
6375  * @return ROK     - success
6376  *         RFAILED - failure
6377  *
6378  * ****************************************************************/
6379 void freeAperDecodeUeNrCapability(void *ueNrCapability)
6380 {
6381    uint8_t arrIdx =0;
6382    FeatureSets_t *featureSets =NULLP;
6383    UE_NR_Capability_t *ueNrCap = (UE_NR_Capability_t *)ueNrCapability;
6384
6385    if(ueNrCap->rf_Parameters.supportedBandListNR.list.array)
6386    {
6387       for(arrIdx = 0; arrIdx < ueNrCap->rf_Parameters.supportedBandListNR.list.count; arrIdx++)
6388       {
6389          if(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx])
6390             free(ueNrCap->rf_Parameters.supportedBandListNR.list.array[arrIdx]);
6391       }
6392       free(ueNrCap->rf_Parameters.supportedBandListNR.list.array);
6393    }
6394
6395    if(ueNrCap->featureSets)
6396    {
6397       featureSets = ueNrCap->featureSets;
6398       if(featureSets->featureSetsDownlinkPerCC)
6399       {
6400          if(featureSets->featureSetsDownlinkPerCC->list.array)
6401          {
6402             for(arrIdx = 0; arrIdx < featureSets->featureSetsDownlinkPerCC->list.count; arrIdx++)
6403             {
6404                if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx])
6405                {
6406                   if(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL)
6407                      free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]->supportedModulationOrderDL);
6408                   free(featureSets->featureSetsDownlinkPerCC->list.array[arrIdx]);
6409                }
6410             }
6411             free(featureSets->featureSetsDownlinkPerCC->list.array);
6412          }
6413          free(featureSets->featureSetsDownlinkPerCC);
6414       }
6415       if(featureSets->featureSetsUplinkPerCC)
6416       {
6417          if(featureSets->featureSetsUplinkPerCC->list.array)
6418          {
6419             for(arrIdx = 0; arrIdx < featureSets->featureSetsUplinkPerCC->list.count; arrIdx++)
6420             {
6421                if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx])
6422                {
6423                   if(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL)
6424                      free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]->supportedModulationOrderUL);
6425                   free(featureSets->featureSetsUplinkPerCC->list.array[arrIdx]);
6426                }
6427             }
6428             free(featureSets->featureSetsUplinkPerCC->list.array);
6429          }
6430          free(featureSets->featureSetsUplinkPerCC);
6431       }
6432       free(ueNrCap->featureSets);
6433    }
6434 }
6435
6436 /*******************************************************************
6437 *
6438 * @brief Function to free PdcchSearchSpcToAddModList
6439          where memory allocated by aper_decoder
6440 *
6441 * @details
6442 *
6443 *    Function : freeAperDecodePdcchSearchSpcToAddModList
6444 *
6445 *    Functionality: Function to free PdcchSearchSpcToAddModList
6446 *
6447 * @params[in] struct PDCCH_Config__searchSpacesToAddModList *searchSpcList
6448 * @return void
6449 *
6450 * ****************************************************************/
6451
6452 void freeAperDecodePdcchSearchSpcToAddModList(struct PDCCH_Config__searchSpacesToAddModList *searchSpcList)
6453 {
6454    uint8_t searchSpcArrIdx=0;
6455    uint8_t searchSpcArrIdx1=0;
6456    struct  SearchSpace *searchSpc=NULLP;
6457
6458
6459    if(searchSpcList->list.array)
6460    {
6461       if(searchSpcList->list.array[searchSpcArrIdx1])
6462       {
6463          searchSpc = searchSpcList->list.array[searchSpcArrIdx1];
6464          if(searchSpc->controlResourceSetId)
6465          {
6466             if(searchSpc->monitoringSlotPeriodicityAndOffset)
6467             {
6468                if(searchSpc->monitoringSymbolsWithinSlot)
6469                {
6470                   if(searchSpc->monitoringSymbolsWithinSlot->buf)
6471                   {
6472                      if(searchSpc->nrofCandidates)
6473                      {
6474                         if(searchSpc->searchSpaceType)
6475                         {
6476                            free(searchSpc->searchSpaceType->choice.ue_Specific);
6477                            free(searchSpc->searchSpaceType);
6478                         }
6479                         free(searchSpc->nrofCandidates);
6480                      }
6481                      free(searchSpc->monitoringSymbolsWithinSlot->buf);
6482                   }
6483                   free(searchSpc->monitoringSymbolsWithinSlot);
6484                }
6485                free(searchSpc->monitoringSlotPeriodicityAndOffset);
6486             }
6487             free(searchSpc->controlResourceSetId);
6488          }
6489       }
6490       for(searchSpcArrIdx = 0; searchSpcArrIdx < searchSpcList->list.count; searchSpcArrIdx++)
6491       {
6492          free(searchSpcList->list.array[searchSpcArrIdx]);
6493       }
6494       free(searchSpcList->list.array);
6495    }
6496 }
6497 /*******************************************************************
6498 *
6499 * @brief Function for free part for the memory allocated by aper_decoder
6500 *
6501 * @details
6502 *
6503 *    Function : freeAperDecodeBWPDlDedPdcchConfig
6504 *
6505 *    Functionality: Function to free BWPDlDedPdcchConfig
6506 *
6507 * @params[in]
6508 * @return void
6509 *
6510 * ****************************************************************/
6511
6512
6513 void freeAperDecodeBWPDlDedPdcchConfig(BWP_DownlinkDedicated_t *dlBwp)
6514 {
6515    uint8_t arrIdx1=0;
6516    uint8_t arrIdx2=0;
6517    struct PDCCH_Config *pdcchCfg=NULLP;
6518    struct ControlResourceSet *controlRSet=NULLP;
6519    struct PDCCH_Config__controlResourceSetToAddModList *controlRSetList=NULLP;
6520
6521    if(dlBwp->pdcch_Config->choice.setup)
6522    {
6523       pdcchCfg=dlBwp->pdcch_Config->choice.setup;
6524       if(pdcchCfg->controlResourceSetToAddModList)
6525       {
6526          controlRSetList = pdcchCfg->controlResourceSetToAddModList;
6527          if(controlRSetList->list.array)
6528          {
6529             controlRSet = controlRSetList->list.array[arrIdx2];
6530             if(controlRSet)
6531             {
6532                if(controlRSet->frequencyDomainResources.buf)
6533                {
6534                   if(controlRSet->pdcch_DMRS_ScramblingID)
6535                   {
6536                      if(pdcchCfg->searchSpacesToAddModList)
6537                      {
6538                         freeAperDecodePdcchSearchSpcToAddModList(pdcchCfg->searchSpacesToAddModList);
6539                         free(pdcchCfg->searchSpacesToAddModList);
6540                      }
6541                      free(controlRSet->pdcch_DMRS_ScramblingID);
6542                   }
6543                   free(controlRSet->frequencyDomainResources.buf);
6544                }
6545             }
6546             for(arrIdx1 = 0; arrIdx1 <controlRSetList->list.count; arrIdx1++)
6547             {
6548                free(controlRSetList->list.array[arrIdx1]);
6549             }
6550             free(controlRSetList->list.array);
6551          }
6552          free(pdcchCfg->controlResourceSetToAddModList);
6553       }
6554       free(dlBwp->pdcch_Config->choice.setup);
6555    }
6556 }
6557 /*******************************************************************
6558 *
6559 * @brief Function to free PdschTimeDomAllocationList
6560 *     where the memory allocated by aper_decoder
6561 *
6562 * @details
6563 *
6564 *    Function : freeAperDecodePdschTimeDomAllocationList
6565 *
6566 *    Functionality: Function to free PdschTimeDomAllocationList
6567 *
6568 * @params[in] struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList
6569 * @return void
6570 *
6571 * ****************************************************************/
6572
6573
6574 void freeAperDecodePdschTimeDomAllocationList( struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList)
6575 {
6576    uint8_t arrIdx=0;
6577
6578    if(timeDomAllocList->choice.setup)
6579    {
6580       if(timeDomAllocList->choice.setup->list.array)
6581       {
6582          for(arrIdx = 0; arrIdx <timeDomAllocList->choice.setup->list.count ; arrIdx++)
6583          {
6584             free(timeDomAllocList->choice.setup->list.array[arrIdx]);
6585          }
6586          free(timeDomAllocList->choice.setup->list.array);
6587       }
6588       free(timeDomAllocList->choice.setup);
6589    }
6590 }
6591
6592 /*******************************************************************
6593 *
6594 * @brief Function to free BWPDlDedPdschConfig
6595 *        where the memory allocated by aper_decoder
6596 *
6597 * @details
6598 *
6599 *    Function : freeAperDecodeBWPDlDedPdschConfig
6600 *
6601 *    Functionality: Function to free BWPDlDedPdschConfig
6602 *
6603 * @params[in] BWP_DownlinkDedicated_t *dlBwp
6604 * @return void
6605 *
6606 * ****************************************************************/
6607
6608
6609 void freeAperDecodeBWPDlDedPdschConfig(BWP_DownlinkDedicated_t *dlBwp)
6610 {
6611    struct PDSCH_Config *pdschCfg=NULLP;
6612    struct PDSCH_Config__prb_BundlingType *prbBndlType=NULLP;
6613    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAllocList=NULLP;
6614    struct PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA *dmrsDlCfg=NULLP;
6615
6616    if(dlBwp->pdsch_Config->choice.setup)
6617    {
6618       pdschCfg=dlBwp->pdsch_Config->choice.setup;
6619       if(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
6620       {
6621          if(pdschCfg->pdsch_TimeDomainAllocationList)
6622          {
6623             timeDomAllocList=pdschCfg->pdsch_TimeDomainAllocationList;
6624             if(pdschCfg->maxNrofCodeWordsScheduledByDCI)
6625             {
6626                prbBndlType=&pdschCfg->prb_BundlingType;
6627                free(prbBndlType->choice.staticBundling);
6628                free(pdschCfg->maxNrofCodeWordsScheduledByDCI);
6629             }
6630             freeAperDecodePdschTimeDomAllocationList(timeDomAllocList);
6631             free(pdschCfg->pdsch_TimeDomainAllocationList);
6632          }
6633          dmrsDlCfg=pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA;
6634          if(dmrsDlCfg->choice.setup)
6635          {
6636             free(dmrsDlCfg->choice.setup->dmrs_AdditionalPosition);
6637             free(dmrsDlCfg->choice.setup);
6638          }
6639          free(pdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA);
6640       }
6641       free(dlBwp->pdsch_Config->choice.setup);
6642    }
6643 }
6644 /*******************************************************************
6645 *
6646 * @brief Function to free PuschTimeDomAllocListCfg
6647                  where the memory allocated by aper_decoder
6648 *
6649 * @details
6650 *
6651 *    Function : freeAperDecodePuschTimeDomAllocListCfg
6652 *
6653 *    Functionality: Function to free PuschTimeDomAllocListCfg
6654 *
6655 * @params[in] PUSCH_Config_t *puschCfg
6656 * @return void
6657 *
6658 * ****************************************************************/
6659
6660
6661 void freeAperDecodePuschTimeDomAllocListCfg(PUSCH_Config_t *puschCfg)
6662 {
6663    uint8_t arrIdx=0;
6664    uint8_t arrIdx1=0;
6665    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList_t=NULLP;
6666
6667    if(puschCfg->pusch_TimeDomainAllocationList)
6668    {
6669       timeDomAllocList_t=puschCfg->pusch_TimeDomainAllocationList;
6670       if(timeDomAllocList_t->choice.setup)
6671       {
6672          if(timeDomAllocList_t->choice.setup->list.array)
6673          {
6674             free(timeDomAllocList_t->choice.setup->list.array[arrIdx1]->k2);
6675             for(arrIdx = 0; arrIdx<timeDomAllocList_t->choice.setup->list.count; arrIdx++)
6676             {
6677                free(timeDomAllocList_t->choice.setup->list.array[arrIdx]);
6678             }
6679             free(timeDomAllocList_t->choice.setup->list.array);
6680          }
6681          free(timeDomAllocList_t->choice.setup);
6682       }
6683       free(puschCfg->transformPrecoder);
6684       free(puschCfg->pusch_TimeDomainAllocationList);
6685    }
6686 }
6687 /*******************************************************************
6688 *
6689 * @brief Function to free InitialUlBWPConfig where memory allocated by aper_decoder
6690 *
6691 * @details
6692 *
6693 *    Function : freeAperDecodeInitialUlBWPConfig
6694 *
6695 *    Functionality: Function to free InitialUlBWPConfig
6696 *
6697 * @params[in]  BWP_UplinkDedicated_t *ulBwp
6698 * @return void
6699 *
6700 * ****************************************************************/
6701
6702
6703 void freeAperDecodeInitialUlBWPConfig(BWP_UplinkDedicated_t *ulBwp)
6704 {
6705    uint8_t  rSetIdx =0;
6706    uint8_t  rsrcIdx =0;
6707    SRS_Config_t   *srsCfg = NULLP;
6708    PUSCH_Config_t *puschCfg = NULLP;
6709    struct PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA *dmrsUlCfg = NULLP;
6710    struct SRS_Config__srs_ResourceSetToAddModList *rsrcSetList = NULLP;
6711    struct SRS_ResourceSet__srs_ResourceIdList *rsrcIdList = NULLP;
6712    struct SRS_Config__srs_ResourceToAddModList *resourceList = NULLP;
6713
6714    if(ulBwp->pusch_Config)
6715    {
6716       if(ulBwp->pusch_Config->choice.setup)
6717       {
6718          puschCfg=ulBwp->pusch_Config->choice.setup;
6719          if(puschCfg->dataScramblingIdentityPUSCH)
6720          {
6721             if(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA)
6722             {
6723                freeAperDecodePuschTimeDomAllocListCfg(puschCfg);
6724                dmrsUlCfg=puschCfg->dmrs_UplinkForPUSCH_MappingTypeA;
6725                if(dmrsUlCfg->choice.setup)
6726                {
6727                   if(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition)
6728                   {
6729                      if(dmrsUlCfg->choice.setup->transformPrecodingDisabled)
6730                      {
6731                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled->scramblingID0);
6732                         free(dmrsUlCfg->choice.setup->transformPrecodingDisabled);
6733                      }
6734                      free(dmrsUlCfg->choice.setup->dmrs_AdditionalPosition);
6735                   }
6736                   free(dmrsUlCfg->choice.setup);
6737                }
6738                free(puschCfg->dmrs_UplinkForPUSCH_MappingTypeA);
6739             }
6740             free(puschCfg->dataScramblingIdentityPUSCH);
6741          }
6742          free(ulBwp->pusch_Config->choice.setup);
6743       }
6744       free(ulBwp->pusch_Config);
6745
6746       /* Free SRS-Config */
6747       if(ulBwp->srs_Config)
6748       {
6749          if(ulBwp->srs_Config->choice.setup)
6750          {
6751             srsCfg = ulBwp->srs_Config->choice.setup;
6752
6753             /* Free Resource Set to add/mod list */
6754             if(srsCfg->srs_ResourceSetToAddModList)
6755             {
6756                rsrcSetList = srsCfg->srs_ResourceSetToAddModList;
6757                if(rsrcSetList->list.array)
6758                {
6759                   rSetIdx = 0;
6760
6761                   /* Free SRS resource Id list in this SRS resource set */
6762                   if(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList)
6763                   {
6764                      rsrcIdList =
6765                         rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList;
6766
6767                      if(rsrcIdList->list.array)
6768                      {
6769                         for(rsrcIdx = 0; rsrcIdx < rsrcIdList->list.count;
6770                               rsrcIdx++)
6771                         {
6772                            free(rsrcIdList->list.array[rsrcIdx]);
6773                         }
6774                         free(rsrcIdList->list.array);
6775                      }
6776                      free(rsrcSetList->list.array[rSetIdx]->srs_ResourceIdList);
6777                   }
6778
6779                   /* Free resource type info for this SRS resource set */
6780
6781                   free(rsrcSetList->list.array[rSetIdx]->resourceType.choice.aperiodic);
6782
6783                   /* Free memory for each resource set */
6784                   for(rSetIdx = 0; rSetIdx < rsrcSetList->list.count; rSetIdx++)
6785                   {
6786                      free(rsrcSetList->list.array[rSetIdx]);
6787                   }
6788                   free(rsrcSetList->list.array);
6789                }
6790                free(srsCfg->srs_ResourceSetToAddModList);
6791             }
6792
6793             /* Free resource to add/modd list */
6794             if(srsCfg->srs_ResourceToAddModList)
6795             {
6796                resourceList = srsCfg->srs_ResourceToAddModList;
6797                if(resourceList->list.array)
6798                {
6799                   rsrcIdx = 0;
6800
6801                   free(resourceList->list.array[rsrcIdx]->transmissionComb.choice.n2);
6802                   free(resourceList->list.array[rsrcIdx]->resourceType.choice.aperiodic);
6803
6804                   for(rsrcIdx = 0; rsrcIdx < resourceList->list.count; rsrcIdx++)
6805                   {
6806                      free(resourceList->list.array[rsrcIdx]);
6807                   }
6808                   free(resourceList->list.array);
6809                }
6810                free(srsCfg->srs_ResourceToAddModList);
6811             }
6812
6813             free(ulBwp->srs_Config->choice.setup);
6814          }
6815          free(ulBwp->srs_Config);
6816       }
6817    }
6818 }
6819 /*******************************************************************
6820 *
6821 * @brief Function to free initialUplinkBWPConfig where memory allocated by aper_decoder
6822 *
6823 * @details
6824 *
6825 *    Function : freeAperDecodeinitialUplinkBWPConfig
6826 *
6827 *    Functionality: Function to free initialUplinkBWPConfig
6828 *
6829 * @params[in] UplinkConfig_t *ulCfg
6830 * @return void
6831 *
6832 * ****************************************************************/
6833
6834
6835 void freeAperDecodeinitialUplinkBWPConfig(UplinkConfig_t *ulCfg)
6836 {
6837    BWP_UplinkDedicated_t *ulBwp=NULLP;
6838    struct UplinkConfig__pusch_ServingCellConfig *puschCfg=NULLP;
6839
6840    if(ulCfg->initialUplinkBWP)
6841    {
6842       ulBwp=ulCfg->initialUplinkBWP;
6843       if(ulCfg->firstActiveUplinkBWP_Id)
6844       {
6845          if(ulCfg->pusch_ServingCellConfig)
6846          {
6847             puschCfg=ulCfg->pusch_ServingCellConfig;
6848             if(puschCfg->choice.setup)
6849             {
6850                if(puschCfg->choice.setup->ext1)
6851                {
6852                   free(puschCfg->choice.setup->ext1->processingType2Enabled);
6853                   free(puschCfg->choice.setup->ext1->maxMIMO_Layers);
6854                   free(puschCfg->choice.setup->ext1);
6855                }
6856                free(puschCfg->choice.setup);
6857             }
6858             free(ulCfg->pusch_ServingCellConfig);
6859          }
6860          free(ulCfg->firstActiveUplinkBWP_Id);
6861       }
6862       freeAperDecodeInitialUlBWPConfig(ulBwp);
6863       free(ulCfg->initialUplinkBWP);
6864    }
6865 }
6866
6867 /*******************************************************************
6868  *
6869  * @brief Function to free DuUeCfg
6870  *
6871  * @details
6872  *
6873  *    Function : freeDuUeCfg
6874  *
6875  *    Functionality: Function to free DuUeCfg
6876  *
6877  * @params[in] DuUeCfg *ueCfg
6878  * @return void
6879  *
6880  * ****************************************************************/
6881 void freeDuUeCfg(DuUeCfg *ueCfg)
6882 {
6883    uint8_t lcIdx = 0;
6884    uint8_t arrIdx = 0;
6885    SpCellConfig_t *spCellCfg = NULLP;
6886    ServingCellConfig_t *srvCellCfg = NULLP;
6887    BWP_DownlinkDedicated_t *dlBwp = NULLP;
6888    MAC_CellGroupConfig_t *macCellGrpCfg = NULLP;
6889    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
6890    struct CellGroupConfigRrc__rlc_BearerToAddModList *rlcBearerList = NULLP;
6891    struct RLC_Config *rlcConfig = NULLP;
6892    struct LogicalChannelConfig *macLcConfig = NULLP;
6893    struct SchedulingRequestConfig *schedulingRequestConfig = NULLP;
6894    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqList = NULLP;
6895    struct TAG_Config *tagConfig = NULLP;
6896    struct TAG_Config__tag_ToAddModList *tagList = NULLP;
6897    struct MAC_CellGroupConfig__phr_Config *phrConfig = NULLP;
6898    struct ServingCellConfig__pdsch_ServingCellConfig *pdschCfg = NULLP;
6899    CellGroupConfigRrc_t *cellGrpCfg = ueCfg->cellGrpCfg;
6900
6901    if(ueCfg->ueNrCapability)
6902    {
6903       freeAperDecodeUeNrCapability(ueCfg->ueNrCapability);
6904       DU_FREE(ueCfg->ueNrCapability, sizeof(UE_NR_Capability_t));
6905       ueCfg->ueNrCapability = NULLP;
6906    }
6907
6908    if(ueCfg->cellGrpCfg)
6909    {
6910
6911       rlcBearerList = cellGrpCfg->rlc_BearerToAddModList;
6912       if(rlcBearerList)
6913       {
6914          if(rlcBearerList->list.array)
6915          {
6916             for(arrIdx=0; arrIdx<rlcBearerList->list.count; arrIdx++)
6917             {
6918                if(rlcBearerList->list.array[arrIdx])
6919                {
6920                   rlcConfig   = rlcBearerList->list.array[arrIdx]->rlc_Config;
6921                   macLcConfig = rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig;
6922
6923                   if(rlcBearerList->list.array[arrIdx]->servedRadioBearer)
6924                   {
6925                      free(rlcBearerList->list.array[arrIdx]->servedRadioBearer);
6926                   }
6927                   if(rlcConfig)
6928                   {
6929                      if(rlcConfig->choice.am)
6930                      {
6931                         free(rlcConfig->choice.am->ul_AM_RLC.sn_FieldLength);
6932                         free(rlcConfig->choice.am->dl_AM_RLC.sn_FieldLength);
6933                         free(rlcConfig->choice.am);
6934                      }
6935                      free(rlcBearerList->list.array[arrIdx]->rlc_Config);
6936                   }
6937                   if(macLcConfig)
6938                   {
6939                      if(macLcConfig->ul_SpecificParameters)
6940                      {
6941                         free(macLcConfig->ul_SpecificParameters->schedulingRequestID);
6942                         free(macLcConfig->ul_SpecificParameters->logicalChannelGroup);
6943                         free(macLcConfig->ul_SpecificParameters);
6944                      }
6945                      free(rlcBearerList->list.array[arrIdx]->mac_LogicalChannelConfig);
6946                   }
6947                   free(rlcBearerList->list.array[arrIdx]);
6948                }
6949             }
6950             free(rlcBearerList->list.array);
6951          }
6952          free(cellGrpCfg->rlc_BearerToAddModList);
6953       }
6954
6955       macCellGrpCfg = cellGrpCfg->mac_CellGroupConfig;
6956       if(macCellGrpCfg)
6957       {
6958          schedulingRequestConfig = macCellGrpCfg->schedulingRequestConfig;
6959          if(schedulingRequestConfig)
6960          {
6961             schReqList = schedulingRequestConfig->schedulingRequestToAddModList;
6962             if(schReqList)
6963             {
6964                if(schReqList->list.array)
6965                {
6966                   for(arrIdx=0;arrIdx<schReqList->list.count; arrIdx++)
6967                   {
6968                      if(schReqList->list.array[arrIdx])
6969                      {
6970                         free(schReqList->list.array[arrIdx]->sr_ProhibitTimer);
6971                         free(schReqList->list.array[arrIdx]);
6972                      }
6973                   }
6974                   free(schReqList->list.array);
6975                }
6976                free(schedulingRequestConfig->schedulingRequestToAddModList);
6977             }
6978             free(macCellGrpCfg->schedulingRequestConfig);
6979          }
6980          if(macCellGrpCfg->bsr_Config)
6981          {
6982             free(macCellGrpCfg->bsr_Config);
6983          }
6984          tagConfig = macCellGrpCfg->tag_Config;
6985          if(tagConfig)
6986          {
6987             tagList = tagConfig->tag_ToAddModList;
6988             if(tagList)
6989             {
6990                if(tagList->list.array)
6991                {
6992                   for(arrIdx=0; arrIdx<tagList->list.count; arrIdx++)
6993                   {
6994                      free(tagList->list.array[arrIdx]);
6995                   }
6996                   free(tagList->list.array);
6997                }
6998                free(tagConfig->tag_ToAddModList);
6999             }
7000             free(tagConfig);
7001          }
7002
7003          phrConfig = macCellGrpCfg->phr_Config;
7004          if(phrConfig)
7005          {
7006             free(phrConfig->choice.setup);
7007             free(phrConfig);
7008          }
7009
7010          free(macCellGrpCfg);
7011       }
7012
7013       phyCellGrpCfg = cellGrpCfg->physicalCellGroupConfig;
7014       if(phyCellGrpCfg)
7015       {
7016          free(phyCellGrpCfg->p_NR_FR1);
7017          free(phyCellGrpCfg);
7018       }
7019
7020       spCellCfg = cellGrpCfg->spCellConfig;
7021       if(spCellCfg)
7022       {
7023          if(spCellCfg->servCellIndex)
7024          {
7025             if(spCellCfg->rlmInSyncOutOfSyncThreshold)
7026             {
7027                if(spCellCfg->spCellConfigDedicated)
7028                {
7029                   srvCellCfg = spCellCfg->spCellConfigDedicated;
7030                   if(srvCellCfg->initialDownlinkBWP)
7031                   {
7032                      dlBwp = srvCellCfg->initialDownlinkBWP;
7033                      if(srvCellCfg->firstActiveDownlinkBWP_Id)
7034                      {
7035                         if(srvCellCfg->defaultDownlinkBWP_Id)
7036                         {
7037                            if(srvCellCfg->uplinkConfig)
7038                            {
7039
7040                               if(srvCellCfg->pdsch_ServingCellConfig)
7041                               {
7042                                  pdschCfg=
7043                                     srvCellCfg->pdsch_ServingCellConfig;
7044                                  if(pdschCfg->choice.setup)
7045                                  {
7046
7047                                     free(pdschCfg->choice.setup->nrofHARQ_ProcessesForPDSCH);
7048                                     free(pdschCfg->choice.setup);
7049                                  }
7050
7051                                  free(srvCellCfg->pdsch_ServingCellConfig);
7052                               }
7053
7054                               freeAperDecodeinitialUplinkBWPConfig(srvCellCfg->uplinkConfig);
7055                               free(srvCellCfg->uplinkConfig);
7056                            }
7057                            free(srvCellCfg->defaultDownlinkBWP_Id);
7058                         }
7059
7060                         free(srvCellCfg->firstActiveDownlinkBWP_Id);
7061                      }
7062                      if(dlBwp->pdcch_Config)
7063                      {
7064                         if(dlBwp->pdsch_Config)
7065                         {
7066                            freeAperDecodeBWPDlDedPdschConfig(dlBwp);
7067                            free(dlBwp->pdsch_Config);
7068                         }
7069                         freeAperDecodeBWPDlDedPdcchConfig(dlBwp);
7070                         free(dlBwp->pdcch_Config);
7071                      }
7072                      free(srvCellCfg->initialDownlinkBWP);
7073                   }
7074
7075                   free(spCellCfg->spCellConfigDedicated);
7076                }
7077                free(spCellCfg->rlmInSyncOutOfSyncThreshold);
7078             }
7079             free(spCellCfg->servCellIndex);
7080          }
7081          free(spCellCfg);
7082       }
7083       DU_FREE(ueCfg->cellGrpCfg, sizeof(CellGroupConfigRrc_t));
7084       ueCfg->cellGrpCfg = NULLP;
7085    }
7086    if(ueCfg->ambrCfg)
7087    {
7088       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, ueCfg->ambrCfg, sizeof(AmbrCfg));
7089    }
7090    for(lcIdx = 0; lcIdx < ueCfg->numRlcLcs; lcIdx++)
7091    {
7092       freeRlcLcCfg(&ueCfg->rlcLcCfg[lcIdx]);
7093    }
7094    for(lcIdx = 0; lcIdx < ueCfg->numMacLcs; lcIdx++)
7095    {
7096       freeMacLcCfg(&ueCfg->macLcCfg[lcIdx]);
7097    }
7098    for(lcIdx = 0; lcIdx < ueCfg->numDrb; lcIdx++)
7099    {
7100       DU_FREE(ueCfg->upTnlInfo[lcIdx].tnlCfg1, sizeof(GtpTnlCfg));
7101    }
7102 }
7103
7104 /*******************************************************************
7105  *
7106  * @brief Function to free UecontextSetupDb
7107  *
7108  * @details
7109  *
7110  *    Function : freeF1UeDb
7111  *
7112  *    Functionality: Function to free UecontextSetupDb
7113  *
7114  * @params[in] UecontextSetupDb *
7115  * @return void
7116  *
7117  * ****************************************************************/
7118
7119 void freeF1UeDb(F1UeContextSetupDb *f1UeDb)
7120 {
7121
7122    if(f1UeDb->dlRrcMsg)
7123    {
7124       if(f1UeDb->dlRrcMsg->rrcMsgPdu)
7125       {
7126         //DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL,\
7127                f1UeDb->dlRrcMsg->rrcMsgPdu, f1UeDb->dlRrcMsg->rrcMsgSize);
7128       }
7129       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
7130    }
7131    freeDuUeCfg(&f1UeDb->duUeCfg);
7132    memset(f1UeDb, 0, sizeof(F1UeContextSetupDb));
7133    DU_FREE(f1UeDb, sizeof(F1UeContextSetupDb));
7134 }
7135
7136 /*******************************************************************
7137  *
7138  * @brief Function to build Am cfg Info
7139  *
7140  * @details
7141  *
7142  *    Function : extractRlcAmCfg
7143  *
7144  *    Functionality: Function to build Am cfg Info
7145  *
7146  * @params[in] AmBearerCfg *
7147  *             void *
7148  *
7149  * @return ROK/RFAILED
7150  *
7151  * ****************************************************************/
7152
7153 void extractRlcAmCfg(AmBearerCfg *amCfgToSet, struct RLC_Config__am *rlcAmCfg)
7154 {
7155    if(rlcAmCfg)
7156    {
7157       /* UL AM */
7158       if(rlcAmCfg->dl_AM_RLC.sn_FieldLength)
7159       {
7160          amCfgToSet->ulAmCfg.snLenUl = *(rlcAmCfg->dl_AM_RLC.sn_FieldLength);
7161          /*TODO: Check the timer value when sent by real CU */
7162          amCfgToSet->ulAmCfg.reAssemTmr = rlcAmCfg->dl_AM_RLC.t_Reassembly;
7163          amCfgToSet->ulAmCfg.statProhTmr = rlcAmCfg->dl_AM_RLC.t_StatusProhibit;
7164       }
7165
7166       /* DL AM */
7167       if(rlcAmCfg->ul_AM_RLC.sn_FieldLength)
7168       {
7169          amCfgToSet->dlAmCfg.snLenDl = *(rlcAmCfg->ul_AM_RLC.sn_FieldLength);
7170          amCfgToSet->dlAmCfg.pollRetxTmr = rlcAmCfg->ul_AM_RLC.t_PollRetransmit;
7171          amCfgToSet->dlAmCfg.pollPdu   = rlcAmCfg->ul_AM_RLC.pollPDU;
7172          amCfgToSet->dlAmCfg.pollByte  = rlcAmCfg->ul_AM_RLC.pollByte;
7173          amCfgToSet->dlAmCfg.maxRetxTh = rlcAmCfg->ul_AM_RLC.maxRetxThreshold;
7174       }
7175    }
7176 }
7177
7178 /*******************************************************************
7179  *
7180  * @brief Function to build Um Bi Info
7181  *
7182  * @details
7183  *
7184  *    Function : extractRlcUmBiCfg
7185  *
7186  *    Functionality: Function to build Um Bi Info
7187  *
7188  * @params[in] UmBiDirBearerCfg *
7189  *             void *
7190  *
7191  * @return ROK/RFAILED
7192  *
7193  * ****************************************************************/
7194
7195 void extractRlcUmBiCfg(UmBiDirBearerCfg *umBiCfgToSet, struct RLC_Config__um_Bi_Directional *rlcBiCfg)
7196 {
7197    if(rlcBiCfg)
7198    {
7199       /* UL UM BI DIR Cfg */
7200       if(rlcBiCfg->dl_UM_RLC.sn_FieldLength)
7201       {
7202          umBiCfgToSet->ulUmCfg.snLenUlUm  = *(rlcBiCfg->dl_UM_RLC.sn_FieldLength);
7203          umBiCfgToSet->ulUmCfg.reAssemTmr = rlcBiCfg->dl_UM_RLC.t_Reassembly;
7204       }
7205
7206       /* DL UM BI DIR Cfg */
7207       if(rlcBiCfg->ul_UM_RLC.sn_FieldLength)
7208          umBiCfgToSet->dlUmCfg.snLenDlUm  = *(rlcBiCfg->ul_UM_RLC.sn_FieldLength);
7209    }
7210 }
7211
7212 /*******************************************************************
7213  *
7214  * @brief Function to build Um Ul Info
7215  *
7216  * @details
7217  *
7218  *    Function : extractRlcUmUlCfg
7219  *
7220  *    Functionality: Function to build Um Ul Info
7221  *
7222  * @params[in] UmUniDirUlBearerCfg *
7223  *             void *
7224  *
7225  * @return ROK/RFAILED
7226  *
7227  * ****************************************************************/
7228
7229 void extractRlcUmUlCfg(UmUniDirUlBearerCfg *umUlCfgToSet, struct RLC_Config__um_Uni_Directional_DL *umUlCfg)
7230 {
7231    if(umUlCfg)
7232    {
7233       if(umUlCfg->dl_UM_RLC.sn_FieldLength)
7234       {
7235          umUlCfgToSet->ulUmCfg.snLenUlUm  = *(umUlCfg->dl_UM_RLC.sn_FieldLength);
7236          umUlCfgToSet->ulUmCfg.reAssemTmr = umUlCfg->dl_UM_RLC.t_Reassembly;
7237       }
7238    }
7239 }
7240
7241 /*******************************************************************
7242  *
7243  * @brief Function to build Um Uni Dl Info
7244  *
7245  * @details
7246  *
7247  *    Function : extractRlcUmDlCfg
7248  *
7249  *    Functionality: Function to build Um Uni Dl Info
7250  *
7251  * @params[in] UmUniDirDlBearerCfg *
7252  *             void *
7253  *
7254  * @return ROK/RFAILED
7255  *
7256  * ****************************************************************/
7257 void extractRlcUmDlCfg(UmUniDirDlBearerCfg *umDlCfgToSet, struct RLC_Config__um_Uni_Directional_UL *umDlCfg)
7258 {
7259    if(umDlCfg)
7260    {
7261       if(umDlCfg->ul_UM_RLC.sn_FieldLength)
7262          umDlCfgToSet->dlUmCfg.snLenDlUm  = *(umDlCfg->ul_UM_RLC.sn_FieldLength);
7263    }
7264 }
7265
7266 /*******************************************************************
7267  *
7268  * @brief Function to extractRlcModeCfg
7269  *
7270  * @details
7271  *
7272  *    Function : extractRlcModeCfg
7273  *
7274  *    Functionality: Function to extractRlcModeCfg
7275  *
7276  * @params[in] RLC_Config_t *
7277  *             RlcBearerCfg *
7278  *             void  *
7279  * @return ROK/RFAILED
7280  *
7281  * ****************************************************************/
7282 void extractRlcModeCfg(uint8_t rlcMode, RlcBearerCfg *rlcDbCfg, RLC_Config_t *lcCfg)
7283 {
7284    if(lcCfg)
7285    {
7286       switch(rlcMode)
7287       {
7288          case RLC_AM :
7289             {
7290                if(lcCfg->choice.am)
7291                {
7292                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.amCfg, sizeof(AmBearerCfg));
7293                   if(rlcDbCfg->u.amCfg)
7294                      extractRlcAmCfg(rlcDbCfg->u.amCfg, lcCfg->choice.am);
7295                }
7296                break;
7297             }
7298          case RLC_UM_BI_DIRECTIONAL :
7299             {
7300                if(lcCfg->choice.um_Bi_Directional)
7301                {
7302                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umBiDirCfg, sizeof(UmBiDirBearerCfg));
7303                   if(rlcDbCfg->u.umBiDirCfg)
7304                      extractRlcUmBiCfg(rlcDbCfg->u.umBiDirCfg, lcCfg->choice.um_Bi_Directional);
7305                }
7306                break;
7307             }
7308          case RLC_UM_UNI_DIRECTIONAL_UL :
7309             {
7310                if(lcCfg->choice.um_Uni_Directional_DL)
7311                {
7312                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirUlCfg, sizeof(UmUniDirUlBearerCfg));
7313                   if(rlcDbCfg->u.umUniDirUlCfg)
7314                      extractRlcUmUlCfg(rlcDbCfg->u.umUniDirUlCfg, lcCfg->choice.um_Uni_Directional_DL);
7315                }
7316                break;
7317             }
7318          case RLC_UM_UNI_DIRECTIONAL_DL :
7319             {
7320                if(lcCfg->choice.um_Uni_Directional_UL)
7321                {
7322                   DU_ALLOC_SHRABL_BUF(rlcDbCfg->u.umUniDirDlCfg, sizeof(UmUniDirDlBearerCfg));
7323                   if(rlcDbCfg->u.umUniDirDlCfg)
7324                      extractRlcUmDlCfg(rlcDbCfg->u.umUniDirDlCfg, lcCfg->choice.um_Uni_Directional_UL);
7325                }
7326                break;
7327             }
7328          default:
7329             DU_LOG("\nERROR  -->  DUAPP: Invalid rlcMode %d at extractRlcCfgToAddMod()", rlcMode);
7330             break;
7331       }
7332    }
7333 }
7334
7335 /*******************************************************************
7336  *
7337  * @brief Function to extract extractUlLcCfg
7338  *
7339  * @details
7340  *
7341  *    Function : extractUlLcCfg
7342  *
7343  *    Functionality: Function to extract extractUlLcCfg
7344  *
7345  * @params[in] UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg
7346  * @return void
7347  *
7348  * ****************************************************************/
7349
7350 void extractUlLcCfg(UlLcCfg *f1UlLcCfg, LogicalChannelConfig_t *ulLcCfg)
7351 {
7352    if(ulLcCfg)
7353    {
7354       if(ulLcCfg->ul_SpecificParameters)
7355       {
7356          f1UlLcCfg->priority = \
7357             ulLcCfg->ul_SpecificParameters->priority;
7358       if(ulLcCfg->ul_SpecificParameters->logicalChannelGroup)
7359       {
7360          f1UlLcCfg->lcGroup = \
7361            *(ulLcCfg->ul_SpecificParameters->logicalChannelGroup);
7362       }
7363       if(ulLcCfg->ul_SpecificParameters->schedulingRequestID)
7364       {
7365          f1UlLcCfg->schReqId = \
7366            *(ulLcCfg->ul_SpecificParameters->schedulingRequestID);
7367       }
7368       f1UlLcCfg->pbr = \
7369          ulLcCfg->ul_SpecificParameters->prioritisedBitRate;
7370       f1UlLcCfg->bsd = \
7371          ulLcCfg->ul_SpecificParameters->bucketSizeDuration;
7372       }
7373    }
7374 }
7375
7376 /*******************************************************************
7377  *
7378  * @brief Function to procRlcLcCfg
7379  *
7380  * @details
7381  *
7382  *    Function : procRlcLcCfg
7383  *
7384  *    Functionality: Function to procRlcLcCfg
7385  *
7386  * @params[in] rbId, lcId, rbType, rlcMod
7387  *             RLC_Config_t *, RlcBearerCfg * ,
7388  * @return void
7389  *
7390  * ****************************************************************/
7391
7392 void procRlcLcCfg(uint8_t rbId, uint8_t lcId, uint8_t rbType, uint8_t rlcMode,\
7393    uint8_t configType, RLC_Config_t *f1RlcCfg, RlcBearerCfg *lcCfg)
7394 {
7395
7396    lcCfg->rbId   = rbId;
7397    lcCfg->configType = configType;
7398
7399    if(rbType == RB_TYPE_SRB)
7400    {
7401       lcCfg->rbType = RB_TYPE_SRB;
7402       lcCfg->lcId   = rbId;
7403       lcCfg->lcType = LCH_DCCH;
7404       lcCfg->rlcMode = RLC_AM;
7405    }
7406    else if(rbType == RB_TYPE_DRB)
7407    {
7408       lcCfg->rbType = RB_TYPE_DRB;
7409       lcCfg->lcId   = lcId;
7410       lcCfg->lcType = LCH_DTCH;
7411       lcCfg->rlcMode = rlcMode;
7412    }
7413    if(f1RlcCfg) /* rlc mode config recived */
7414    {
7415       extractRlcModeCfg(lcCfg->rlcMode, lcCfg, f1RlcCfg);
7416    }
7417 }
7418
7419
7420
7421 /*******************************************************************
7422  *
7423  * @brief Fills DrbQos Info received by CU
7424  *
7425  * @details
7426  *
7427  *    Function : extractQosInfo
7428  *
7429  *    Functionality: Fills DrbQos Info received  by CU
7430  *
7431  * @params[in] DrbQosInfo *qosToAdd,
7432  *             QoSFlowLevelQoSParameters_t *qosFlowCfg
7433  * @return void
7434  *
7435  * ****************************************************************/
7436
7437 void extractQosInfo(DrbQosInfo *qosToAdd, QoSFlowLevelQoSParameters_t *qosFlowCfg)
7438 {
7439    uint8_t qosCntIdx = 0;
7440    ProtocolExtensionContainer_4624P74_t *qosIeExt = NULLP;
7441
7442    qosToAdd->fiveQiType = qosFlowCfg->qoS_Characteristics.present;
7443    qosToAdd->u.nonDyn5Qi.fiveQi     =\
7444                                      qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->fiveQI;
7445    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow)
7446    {
7447       qosToAdd->u.nonDyn5Qi.avgWindow = \
7448                                         *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
7449    }
7450    qosToAdd->u.nonDyn5Qi.maxDataBurstVol = \
7451                                            *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
7452    if(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel)
7453    {
7454       qosToAdd->u.nonDyn5Qi.priorLevel = \
7455                                          *(qosFlowCfg->qoS_Characteristics.choice.non_Dynamic_5QI->qoSPriorityLevel);
7456    }
7457    qosToAdd->ngRanRetPri.priorityLevel = \
7458                                          qosFlowCfg->nGRANallocationRetentionPriority.priorityLevel;
7459    qosToAdd->ngRanRetPri.preEmptionCap = \
7460                                          qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionCapability;
7461    qosToAdd->ngRanRetPri.preEmptionVul = \
7462                                          qosFlowCfg->nGRANallocationRetentionPriority.pre_emptionVulnerability;
7463    if(qosFlowCfg->gBR_QoS_Flow_Information)
7464    {
7465       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateDl, \
7466             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.buf, \
7467             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateDownlink.size);
7468       memcpy(&qosToAdd->grbQosInfo.maxFlowBitRateUl, \
7469             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.buf, \
7470             qosFlowCfg->gBR_QoS_Flow_Information->maxFlowBitRateUplink.size);
7471       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateDl,\
7472             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.buf, \
7473             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateDownlink.size);
7474       memcpy(&qosToAdd->grbQosInfo.guarFlowBitRateUl,\
7475             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.buf, \
7476             qosFlowCfg->gBR_QoS_Flow_Information->guaranteedFlowBitRateUplink.size);
7477    }
7478    /*Extracting PDU_SESSION_ID*/
7479    qosIeExt = (ProtocolExtensionContainer_4624P74_t *)qosFlowCfg->iE_Extensions;
7480    if(qosIeExt)
7481    {
7482       for(qosCntIdx = 0; qosCntIdx < qosIeExt->list.count; qosCntIdx++)
7483       {
7484          if(qosIeExt->list.array[qosCntIdx]->extensionValue.present == \
7485                QoSFlowLevelQoSParameters_ExtIEs__extensionValue_PR_PDUSessionID)
7486          {
7487             qosToAdd->pduSessionId = qosIeExt->list.array[qosCntIdx]->extensionValue.choice.PDUSessionID;
7488             DU_LOG("\nDEBUG -->  DU_F1AP : extractQosInfo: PDU SessionID:%d",qosToAdd->pduSessionId);
7489          }
7490       }
7491    }
7492    qosToAdd->ulPduSessAggMaxBitRate = 0;
7493 }
7494
7495 /*******************************************************************
7496  *
7497  * @brief Function to extract GTP Tunnel Info from CU
7498  *
7499  * @details
7500  *
7501  *    Function : extractUpTnlInfo
7502  *
7503  *    Functionality: Function to extract GTP Tunnel Info from CU
7504  *
7505  * @params[in] F1AP message
7506  * @return ROK/RFAILED
7507  *
7508  * ****************************************************************/
7509
7510 uint8_t extractUpTnlInfo(uint8_t drbId, uint8_t configType,\
7511    ULUPTNLInformation_ToBeSetup_List_t *tnlInfo, UpTnlCfg *upTnlInfo)
7512 {
7513    uint8_t tnlIdx;
7514    uint32_t ipv4_du = 0;
7515    GTPTunnel_t *gtpTunnel = NULLP;
7516
7517    upTnlInfo->drbId = drbId;
7518    upTnlInfo->configType = configType;
7519 #ifdef O1_ENABLE
7520    cmInetAddr((S8*)g_cfg.DU_IPV4_Addr, &ipv4_du);
7521 #else
7522    cmInetAddr((char *)DU_IP_V4_ADDR, &ipv4_du);
7523 #endif
7524
7525    for(tnlIdx=0; tnlIdx < tnlInfo->list.count; tnlIdx++)
7526    {
7527       if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.present == UPTransportLayerInformation_PR_gTPTunnel)
7528       {
7529          if(tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel)
7530          {
7531             gtpTunnel = tnlInfo->list.array[tnlIdx]->uLUPTNLInformation.choice.gTPTunnel;
7532             DU_ALLOC(upTnlInfo->tnlCfg1, sizeof(GtpTnlCfg));
7533             if(upTnlInfo->tnlCfg1 == NULLP)
7534             {
7535                DU_LOG("\nERROR  -->  F1AP : extractUpTnlInfo: Failed to allocate mmeory for tunnel cfg 1");
7536                return RFAILED;
7537             }
7538             bitStringToInt(&gtpTunnel->transportLayerAddress, &upTnlInfo->tnlCfg1->ulTnlAddress);
7539             upTnlInfo->tnlCfg1->dlTnlAddress = ipv4_du;
7540             if(gtpTunnel->gTP_TEID.size > 0)
7541             {
7542                teIdStringToInt(gtpTunnel->gTP_TEID.buf, &upTnlInfo->tnlCfg1->teId);
7543             }
7544          }
7545          break;
7546       }
7547    }
7548    return ROK;
7549 }
7550 /*******************************************************************
7551 *
7552 * @brief Function to extract Drb Qos Cfg Info from CU
7553 *
7554 * @details
7555 *
7556 *    Function : extractDrbQosCfg
7557 *
7558 *    Functionality: Function to extract Drb Qos Cfg Info from CU
7559 *
7560 * @params[in] DRB_Information_t *drbInfo, LcCfg *macLcToAdd
7561 * @return ROK/RFAILED
7562 *
7563 * ****************************************************************/
7564
7565 uint8_t extractDrbQosCfg(DRB_Information_t *drbInfo, LcCfg *macLcToAdd )
7566 {
7567    if(!macLcToAdd->drbQos)
7568    {
7569       DU_ALLOC_SHRABL_BUF(macLcToAdd->drbQos, sizeof(DrbQosInfo));
7570       if(macLcToAdd->drbQos == NULLP)
7571       {
7572          DU_LOG("\nERROR  -->  DUAPP:Memory failed at allocating DrbQos at extractDrbQosCfg()");
7573          return RFAILED;
7574       }
7575
7576    }
7577    if(drbInfo->dRB_QoS.qoS_Characteristics.present == QoS_Characteristics_PR_non_Dynamic_5QI)
7578    {
7579       extractQosInfo(macLcToAdd->drbQos, &drbInfo->dRB_QoS);
7580       macLcToAdd->dlLcCfg.lcp = macLcToAdd->drbQos->ngRanRetPri.priorityLevel;
7581    }
7582    if(!macLcToAdd->snssai)
7583    {
7584       DU_ALLOC_SHRABL_BUF(macLcToAdd->snssai, sizeof(Snssai));
7585       if(macLcToAdd->snssai == NULLP)
7586       {
7587          DU_LOG("\nERROR  -->  DUAPP : Memory failed at allocating SNSSAI at extractDrbQosCfg()");
7588          return RFAILED;
7589       }
7590    }
7591    memcpy(&macLcToAdd->snssai->sst, drbInfo->sNSSAI.sST.buf, \
7592          drbInfo->sNSSAI.sST.size);
7593    if(drbInfo->sNSSAI.sD)
7594    {
7595       memcpy(macLcToAdd->snssai->sd, drbInfo->sNSSAI.sD->buf, \
7596             drbInfo->sNSSAI.sD->size);
7597    }
7598    return ROK;
7599 }
7600 /*******************************************************************
7601  *
7602  * @brief Function to extract DRB info received from CU
7603  *
7604  * @details
7605  *
7606  *    Function : extractDrbCfg
7607  *
7608  *    Functionality: Function to extract DRB info received from CU
7609  *
7610  * @params[in] F1AP message
7611  * @return void
7612  *
7613  * ****************************************************************/
7614 uint8_t extractDrbCfg(DRBs_ToBeSetup_Item_t *drbItem, DRBs_ToBeSetupMod_Item_t *drbSetupModItem,\
7615 DRBs_ToBeModified_Item_t *drbModItem,  LcCfg *macLcToAdd, UpTnlCfg *upTnlInfo)
7616 {
7617    DRB_Information_t *drbInfo = NULLP;
7618
7619    if(drbItem != NULLP)
7620    {
7621       if(extractUpTnlInfo(drbItem->dRBID, CONFIG_ADD, &drbItem->uLUPTNLInformation_ToBeSetup_List, upTnlInfo) != ROK)
7622       {
7623          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7624          return RFAILED;
7625       }
7626       if(drbItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7627       {
7628          if(drbItem->qoSInformation.choice.choice_extension->value.present == QoSInformation_ExtIEs__value_PR_DRB_Information)
7629          {
7630             drbInfo = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7631             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7632             {
7633                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7634                return RFAILED;
7635             }
7636          }
7637       }
7638    }
7639    else if(drbSetupModItem != NULLP)
7640    {
7641       if(extractUpTnlInfo(drbSetupModItem->dRBID, CONFIG_ADD, &drbSetupModItem->uLUPTNLInformation_ToBeSetup_List,\
7642       upTnlInfo) != ROK)
7643       {
7644          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7645          return RFAILED;
7646       }
7647       if(drbSetupModItem->qoSInformation.present == QoSInformation_PR_choice_extension)
7648       {
7649          if(drbSetupModItem->qoSInformation.choice.choice_extension->value.present ==\
7650          QoSInformation_ExtIEs__value_PR_DRB_Information)
7651          {
7652             drbInfo = &drbSetupModItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information;
7653             if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7654             {
7655                DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7656                return RFAILED;
7657             }
7658
7659          }
7660       }
7661    }
7662    else if(drbModItem != NULLP)
7663    {
7664       if(extractUpTnlInfo(drbModItem->dRBID, CONFIG_MOD, &drbModItem->uLUPTNLInformation_ToBeSetup_List,\
7665       upTnlInfo) != ROK)
7666       {
7667          DU_LOG("\nERROR  -->  DUAPP : Failed to extract tunnel Cfg at extractDrbCfg()");
7668          return RFAILED;
7669       }
7670       if(drbModItem->qoSInformation != NULLP)
7671       {
7672          if(drbModItem->qoSInformation->present == QoSInformation_PR_choice_extension)
7673          {
7674             if(drbModItem->qoSInformation->choice.choice_extension->value.present ==\
7675                   QoSInformation_ExtIEs__value_PR_DRB_Information)
7676             {
7677                drbInfo = &drbModItem->qoSInformation->choice.choice_extension->value.choice.DRB_Information;
7678                if(extractDrbQosCfg(drbInfo , macLcToAdd) != ROK)
7679                {
7680                   DU_LOG("\nERROR  -->  DUAPP : Failed to extract qos Cfg at extractDrbCfg()");
7681                   return RFAILED;
7682                }
7683
7684             }
7685          }
7686       }
7687    }
7688    return ROK;
7689 }
7690
7691 /*******************************************************************
7692  *
7693  * @brief Function to extract RB info received from CU
7694  *
7695  * @details
7696  *
7697  *    Function : extractMacRbCfg
7698  *
7699  *    Functionality: Function to extract RB info received from CU
7700  *
7701  * @params[in] F1AP message
7702  * @return ROK/RFAILED
7703  *
7704  * ****************************************************************/
7705
7706 uint8_t extractMacRbCfg(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbCfg,\
7707 DRBs_ToBeSetupMod_Item_t *drbSetupModCfg,  DRBs_ToBeModified_Item_t *drbModCfg, LogicalChannelConfig_t *ulLcCfg, LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7708 {
7709    if(drbCfg != NULLP)
7710    {
7711       if(extractDrbCfg(drbCfg, NULL, NULL, lcCfg, upTnlInfo) != ROK)
7712       {
7713          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7714          return RFAILED;
7715       }
7716    }
7717    else if(drbSetupModCfg != NULLP)
7718    {
7719       if(extractDrbCfg(NULL, drbSetupModCfg, NULL, lcCfg, upTnlInfo) != ROK)
7720       {
7721          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7722          return RFAILED;
7723       }
7724    }
7725    else if(drbModCfg != NULLP)
7726    {
7727       if(extractDrbCfg(NULL, NULL, drbModCfg, lcCfg, upTnlInfo) != ROK)
7728       {
7729          DU_LOG("ERROR  -->  F1AP : Failed to build Drb Qos at extractMacRbCfg()");
7730          return RFAILED;
7731       }
7732    }
7733    else
7734    {
7735       lcCfg->drbQos = NULLP;
7736       lcCfg->snssai = NULLP;
7737       if(lcCfg->lcId == SRB2_LCID)
7738          lcCfg->dlLcCfg.lcp = LC_PRIORITY_3;
7739       else
7740          lcCfg->dlLcCfg.lcp = LC_PRIORITY_1;
7741    }
7742    if(ulLcCfg)
7743    {
7744       lcCfg->ulLcCfgPres = true;
7745       extractUlLcCfg(&lcCfg->ulLcCfg, ulLcCfg);
7746    }
7747    else
7748       lcCfg->ulLcCfgPres = false;
7749    return ROK;
7750 }
7751
7752 /*******************************************************************
7753  *
7754  * @brief Function processing LC config info received from CU
7755  *
7756  * @details
7757  *
7758  *    Function : procMacLcCfg
7759  *
7760  *    Functionality: Function processing LC config info received from CU
7761  *
7762  * @params[in] F1AP message
7763  * @return ROK/RFAILED
7764  *
7765  * ****************************************************************/
7766
7767 uint8_t procMacLcCfg(uint8_t lcId, uint8_t rbType, uint8_t configType, DRBs_ToBeSetup_Item_t *drbItem,\
7768 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, LogicalChannelConfig_t *ulLcCfg,\
7769 LcCfg *lcCfg, UpTnlCfg *upTnlInfo)
7770 {
7771    uint8_t ret = ROK;
7772
7773    lcCfg->lcId = lcId;
7774    lcCfg->configType = configType;
7775    if(rbType == RB_TYPE_SRB)
7776    {
7777       ret = extractMacRbCfg(lcId, NULL, NULL, NULL, ulLcCfg, lcCfg, NULL);
7778    }
7779    else if(rbType == RB_TYPE_DRB)
7780    {
7781       if(drbItem != NULL)
7782         ret = extractMacRbCfg(lcId, drbItem, NULL, NULL, ulLcCfg, lcCfg, upTnlInfo);
7783       else if(drbSetupModItem != NULL)
7784         ret = extractMacRbCfg(lcId, NULL, drbSetupModItem, NULL, ulLcCfg, lcCfg, upTnlInfo);
7785       else if(drbModItem != NULL)
7786         ret = extractMacRbCfg(lcId, NULL, NULL, drbModItem, ulLcCfg, lcCfg, upTnlInfo);
7787    }
7788    return ret;
7789 }
7790
7791 /*******************************************************************
7792  *
7793  * @brief Function to extract Rlc cfg To Add/Mod in CellGrp Info
7794  *
7795  * @details
7796  *
7797  *    Function : extractRlcCfgToAddMod
7798  *
7799  *    Functionality: Function to extract Rlc cfg To Add/Mod in CellGrp Info
7800  *
7801  * @params[in] CellGroupConfigRrc__rlc_BearerTo pointer
7802  *             DuUeCfg Pointer
7803  * @return ROK/RFAILED
7804  *
7805  * ****************************************************************/
7806
7807 uint8_t extractRlcCfgToAddMod(struct CellGroupConfigRrc__rlc_BearerToAddModList *lcCfg, DuUeCfg *ueCfgDb)
7808 {
7809   uint8_t idx, rbId, lcId, rlcMode, rbType;
7810   RLC_Config_t *f1RlcCfg = NULLP;
7811   LogicalChannelConfig_t *macUlLcCfg = NULLP;
7812
7813   for(idx = 0; idx < lcCfg->list.count; idx++)
7814   {
7815      lcId = lcCfg->list.array[idx]->logicalChannelIdentity;
7816      if(lcCfg->list.array[idx]->servedRadioBearer)
7817      {
7818         /* RadioBearer for SRB/DRB */
7819         if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7820         RLC_BearerConfig__servedRadioBearer_PR_srb_Identity)
7821         {
7822            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.srb_Identity;
7823            rbType = RB_TYPE_SRB;
7824         }
7825         else if(lcCfg->list.array[idx]->servedRadioBearer->present ==\
7826         RLC_BearerConfig__servedRadioBearer_PR_drb_Identity)
7827         {
7828            rbId = lcCfg->list.array[idx]->servedRadioBearer->choice.drb_Identity;
7829            rbType = RB_TYPE_DRB;
7830         }
7831         else
7832         {
7833            DU_LOG("\nERROR  -->  No components present in Bearer config to ADD/MOD");
7834            return RFAILED;
7835         }
7836         /* MAC UL LC Config */
7837         if(lcCfg->list.array[idx]->mac_LogicalChannelConfig)
7838         {
7839            macUlLcCfg = lcCfg->list.array[idx]->mac_LogicalChannelConfig;
7840         }
7841      }
7842      else
7843      {
7844         DU_LOG("\nERROR  -->  DUAPP: Received RadioBearer config is NULL");
7845         return RFAILED;
7846      }
7847      /* RLC Mode Config */
7848      if(lcCfg->list.array[idx]->rlc_Config)
7849      {
7850         rlcMode  = lcCfg->list.array[idx]->rlc_Config->present;
7851         f1RlcCfg = lcCfg->list.array[idx]->rlc_Config;
7852      }
7853
7854      /* Filling RLC/MAC Config*/
7855      memset(&ueCfgDb->macLcCfg[idx], 0, sizeof(LcCfg));
7856      memset(&ueCfgDb->rlcLcCfg[idx], 0, sizeof(RlcBearerCfg));
7857      procRlcLcCfg(rbId, lcId, rbType, rlcMode, CONFIG_UNKNOWN, f1RlcCfg, &(ueCfgDb->rlcLcCfg[idx]));
7858      if(procMacLcCfg(lcId, rbType, CONFIG_UNKNOWN, NULL, NULL, NULL, macUlLcCfg, &ueCfgDb->macLcCfg[idx], NULL) != ROK)
7859      {
7860         DU_LOG("\nERROR  -->  DU APP : Failed while filling MAC LC config at extractRlcCfgToAddMod()");
7861         return RFAILED;
7862      }
7863      (ueCfgDb->numRlcLcs)++;
7864      (ueCfgDb->numMacLcs)++;
7865          DU_LOG("\nDEBUG  -> DUAPP: extractRlcCfgToAddMod:RBType:%d, DrbID: %d,lcId:%d, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
7866                             rbType, rbId, lcId, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
7867   }
7868   //TODO: To send the failure cause in UeContextSetupRsp
7869   return ROK;
7870 }
7871
7872 /*******************************************************************
7873  *
7874  * @brief DeAlloc pdsch serv cell config info
7875  *
7876  * @details
7877  *
7878  *    Function : freeMacPdschServCellInfo
7879  *
7880  *    Functionality: DeAlloc pdsch serv cell config info
7881  *
7882  * @params[in] PdschServCellCfg pointer
7883  * @return void
7884  *
7885  * ****************************************************************/
7886
7887 void freeMacPdschServCellInfo(PdschServCellCfg *pdsch)
7888 {
7889    if(pdsch->xOverhead)
7890    {
7891       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->xOverhead, sizeof(PdschXOverhead));
7892    }
7893    if(pdsch->codeBlkGrpFlushInd)
7894    {
7895       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->codeBlkGrpFlushInd, sizeof(bool));
7896    }
7897    if(pdsch->maxCodeBlkGrpPerTb)
7898    {
7899       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
7900    }
7901    if(pdsch->maxMimoLayers)
7902    {
7903       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, pdsch->maxMimoLayers, sizeof(uint8_t));
7904    }
7905 }
7906
7907 /*******************************************************************
7908  *
7909  * @brief Free Serving cell Info
7910  *
7911  * @details
7912  *
7913  *    Function : freeMacServingCellInfo
7914  *
7915  *    Functionality: Free Serving cell Info
7916  *
7917  * @params[in] ServCellCfgInfo *srvCellCfg
7918  * @return void
7919  *
7920  * ****************************************************************/
7921 void freeMacServingCellInfo(ServCellCfgInfo *srvCellCfg)
7922 {
7923    uint8_t timeDomRsrcIdx;
7924
7925    if(srvCellCfg->initDlBwp.pdschPresent)
7926    {
7927       for(timeDomRsrcIdx = 0; timeDomRsrcIdx < srvCellCfg->initDlBwp.pdschCfg.numTimeDomRsrcAlloc; timeDomRsrcIdx++)
7928       {
7929          DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, \
7930             srvCellCfg->initDlBwp.pdschCfg.timeDomRsrcAllociList[timeDomRsrcIdx].k0, sizeof(uint8_t));
7931       }
7932    }
7933
7934    freeMacPdschServCellInfo(&srvCellCfg->pdschServCellCfg);
7935    if(srvCellCfg->bwpInactivityTmr)
7936    {
7937       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
7938    }
7939
7940    if(srvCellCfg->initUlBwp.pucchPresent)
7941    {
7942       DU_FREE_SHRABL_BUF(DU_APP_MEM_REGION, DU_POOL, srvCellCfg->initUlBwp.pucchCfg.dlDataToUlAck, sizeof(PucchDlDataToUlAck));
7943    }
7944 }
7945
7946 /*******************************************************************
7947  *
7948  * @brief Free cell Grp Cfg Info
7949  *
7950  * @details
7951  *
7952  *    Function : freeUeReCfgCellGrpInfo
7953  *
7954  *    Functionality: Free cell Grp Cfg Info
7955  *
7956  * @params[in] MacUeCfg*  duUeCfg
7957  * @return void
7958  *
7959  * ****************************************************************/
7960
7961 void freeUeReCfgCellGrpInfo(MacUeCfg *macUeCfg)
7962 {
7963    freeMacServingCellInfo(&macUeCfg->spCellCfg.servCellCfg);
7964 }
7965
7966 /*******************************************************************
7967  *
7968  * @brief Fills Reconfig SchReqReConfig
7969  *
7970  * @details
7971  *
7972  *    Function : extractSchReqReConfig
7973  *
7974  *    Functionality: Fills Reconfig SchReqReConfig
7975  *
7976  * @params[in] SchedulingRequestConfig_t *cuSchedReq
7977  *             SchedReqCfg*  macSchedReq
7978  * @return void
7979  *
7980  * ****************************************************************/
7981 void extractSchReqReConfig(SchedulingRequestConfig_t *cuSchedReq, SchedReqCfg *macSchedReq)
7982 {
7983    uint8_t schReqIdx = 0;
7984    struct SchedulingRequestConfig__schedulingRequestToAddModList *schReqListToAdd = NULLP;
7985    struct SchedulingRequestConfig__schedulingRequestToReleaseList *schReqListToRel = NULLP;
7986
7987    if(cuSchedReq->schedulingRequestToAddModList)
7988    {
7989       schReqListToAdd = cuSchedReq->schedulingRequestToAddModList;
7990       if(schReqListToAdd->list.count)
7991       {
7992          macSchedReq->addModListCount = schReqListToAdd->list.count;
7993          for(schReqIdx = 0; schReqIdx < schReqListToAdd->list.count; schReqIdx++)
7994          {
7995             macSchedReq->addModList[schReqIdx].schedReqId = \
7996                schReqListToAdd->list.array[schReqIdx]->schedulingRequestId;
7997             macSchedReq->addModList[schReqIdx].srProhibitTmr = \
7998                *(schReqListToAdd->list.array[schReqIdx]->sr_ProhibitTimer);
7999             macSchedReq->addModList[schReqIdx].srTransMax    =\
8000                schReqListToAdd->list.array[schReqIdx]->sr_TransMax;
8001          }
8002       }
8003    }
8004    /* Scheduling Req To release */
8005    if(cuSchedReq->schedulingRequestToReleaseList)
8006    {
8007       schReqListToRel = cuSchedReq->schedulingRequestToReleaseList;
8008       if(schReqListToRel->list.count)
8009       {
8010          macSchedReq->relListCount = schReqListToRel->list.count;
8011          for(schReqIdx = 0; schReqIdx < schReqListToRel->list.count; schReqIdx++)
8012          {
8013             macSchedReq->relList[schReqIdx] = \
8014                *schReqListToRel->list.array[schReqIdx];
8015          }
8016       }
8017    }
8018 }
8019
8020 /*******************************************************************
8021  *
8022  * @brief Fills TagReconfig
8023  *
8024  * @details
8025  *
8026  *    Function : extractTagReconfig
8027  *
8028  *    Functionality: Fills extractTagReconfig
8029  *
8030  * @params[in] TAG_Config_t *cuTagCfg
8031  *             TagCfg *macTagCfg
8032  * @return void
8033  *
8034  * ****************************************************************/
8035
8036 void extractTagReconfig(TAG_Config_t *cuTagCfg, TagCfg *macTagCfg)
8037 {
8038   uint8_t tagIdx = 0;
8039   struct TAG_Config__tag_ToAddModList  *tagListToAddMod = NULLP;
8040   struct TAG_Config__tag_ToReleaseList *tagListToRel = NULLP;
8041
8042   /* Tag config to AddMod */
8043   if(cuTagCfg->tag_ToAddModList)
8044   {
8045      tagListToAddMod = cuTagCfg->tag_ToAddModList;
8046      if(tagListToAddMod->list.count)
8047      {
8048         macTagCfg->addModListCount = tagListToAddMod->list.count;
8049         for(tagIdx = 0; tagIdx < tagListToAddMod->list.count; tagIdx++)
8050         {
8051            macTagCfg->addModList[tagIdx].tagId =\
8052               tagListToAddMod->list.array[tagIdx]->tag_Id;
8053            macTagCfg->addModList[tagIdx].timeAlignTimer = \
8054
8055               tagListToAddMod->list.array[tagIdx]->timeAlignmentTimer;
8056         }
8057      }
8058   }
8059   /* Tag config to release */
8060   if(cuTagCfg->tag_ToReleaseList)
8061   {
8062      tagListToRel = cuTagCfg->tag_ToReleaseList;
8063      if(tagListToRel->list.count)
8064      {
8065         macTagCfg->relListCount = tagListToRel->list.count;
8066         for(tagIdx = 0; tagIdx < tagListToRel->list.count; tagIdx++)
8067         {
8068            macTagCfg->relList[tagIdx] = *tagListToRel->list.array[tagIdx];
8069         }
8070      }
8071   }
8072 }
8073
8074 /*******************************************************************
8075  *
8076  * @brief Fills PdcchCfg received by CU
8077  *
8078  * @details
8079  *
8080  *    Function : extractPdcchCfg
8081  *
8082  *    Functionality: Fills PdcchCfg received  by CU
8083  *
8084  * @params[in] PDCCH_Config_t *cuPdcchCfg,
8085  *             PdcchConfig *duPdcchCfg
8086  * @return void
8087  *
8088  * ****************************************************************/
8089
8090 void extractPdcchCfg(PDCCH_Config_t *cuPdcchCfg, PdcchConfig *macPdcchCfg)
8091 {
8092    uint8_t cRsetIdx = 0;
8093    uint8_t srchSpcIdx = 0;
8094
8095    struct PDCCH_Config__controlResourceSetToAddModList *cRsetToAddModList = NULLP;
8096    struct PDCCH_Config__controlResourceSetToReleaseList *cRsetToRelList = NULLP;
8097    struct PDCCH_Config__searchSpacesToAddModList *srchSpcToAddModList = NULLP;
8098    struct PDCCH_Config__searchSpacesToReleaseList *srchSpcToRelList = NULLP;
8099
8100
8101    /* Control Resource Set To Add/Mod List */
8102    if(cuPdcchCfg->controlResourceSetToAddModList)
8103    {
8104       cRsetToAddModList = cuPdcchCfg->controlResourceSetToAddModList;
8105       if(cRsetToAddModList->list.count)
8106       {
8107          macPdcchCfg->numCRsetToAddMod = cRsetToAddModList->list.count;
8108          for(cRsetIdx = 0; cRsetIdx < cRsetToAddModList->list.count; cRsetIdx++)
8109          {
8110             macPdcchCfg->cRSetToAddModList[cRsetIdx].cRSetId = \
8111                cRsetToAddModList->list.array[cRsetIdx]->controlResourceSetId;
8112             //freqDomRsrcBitStringToInt(&cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources,\
8113                   macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc);
8114             memcpy(macPdcchCfg->cRSetToAddModList[cRsetIdx].freqDomainRsrc, \
8115                cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources.buf,
8116                cRsetToAddModList->list.array[cRsetIdx]->frequencyDomainResources.size);
8117
8118             macPdcchCfg->cRSetToAddModList[cRsetIdx].duration = \
8119                 cRsetToAddModList->list.array[cRsetIdx]->duration;
8120
8121             macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType = \
8122                cRsetToAddModList->list.array[cRsetIdx]->cce_REG_MappingType.present;
8123             if(macPdcchCfg->cRSetToAddModList[cRsetIdx].cceRegMappingType == CCE_REG_MAPPINGTYPE_PR_INTERLEAVED)
8124             {
8125                //TODO: handle the case for Interleaved
8126             }
8127             macPdcchCfg->cRSetToAddModList[cRsetIdx].precoderGranularity = \
8128                 cRsetToAddModList->list.array[cRsetIdx]->precoderGranularity;
8129             if(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID)
8130             {
8131                macPdcchCfg->cRSetToAddModList[cRsetIdx].dmrsScramblingId= \
8132                   *(cRsetToAddModList->list.array[cRsetIdx]->pdcch_DMRS_ScramblingID);
8133             }
8134          }
8135       }
8136    }
8137    /* Control Resource Set To Release List */
8138    if(cuPdcchCfg->controlResourceSetToReleaseList)
8139    {
8140       cRsetToRelList = cuPdcchCfg->controlResourceSetToReleaseList;
8141       if(cRsetToRelList->list.count)
8142       {
8143          macPdcchCfg->numCRsetToRel = cRsetToRelList->list.count;
8144          for(cRsetIdx = 0; cRsetIdx < cRsetToRelList->list.count; cRsetIdx++)
8145          {
8146             macPdcchCfg->cRSetToRelList[cRsetIdx] = *(cRsetToRelList->list.array[cRsetIdx]);
8147          }
8148       }
8149    }
8150
8151    /* Search space To Add/Mod List */
8152    if(cuPdcchCfg->searchSpacesToAddModList)
8153    {
8154       srchSpcToAddModList = cuPdcchCfg->searchSpacesToAddModList;
8155       if(srchSpcToAddModList->list.count)
8156       {
8157          macPdcchCfg->numSearchSpcToAddMod = srchSpcToAddModList->list.count;
8158          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToAddModList->list.count; srchSpcIdx++)
8159          {
8160             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceId =\
8161                                                                           srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceId;
8162             macPdcchCfg->searchSpcToAddModList[srchSpcIdx].cRSetId =\
8163                                                                     *(srchSpcToAddModList->list.array[srchSpcIdx]->controlResourceSetId);
8164             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset)
8165             {
8166                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSlotPeriodicityAndOffset =\
8167                                                                                          srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSlotPeriodicityAndOffset->present;
8168             }
8169             if(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot)
8170             {
8171                bitStringToInt(srchSpcToAddModList->list.array[srchSpcIdx]->monitoringSymbolsWithinSlot,\
8172                      macPdcchCfg->searchSpcToAddModList[srchSpcIdx].mSymbolsWithinSlot);
8173             }
8174             if(srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates)
8175             {
8176                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel1 = \
8177                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel1;
8178                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel2 = \
8179                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel2;
8180                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel4 = \
8181                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel4;
8182
8183                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel8 = \
8184                                                                                        srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel8;
8185
8186                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].numCandidatesAggLevel16 = \
8187                                                                                         srchSpcToAddModList->list.array[srchSpcIdx]->nrofCandidates->aggregationLevel16;
8188             }
8189             if(srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType)
8190             {
8191                macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType =\
8192                                                                                srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->present;
8193                if(macPdcchCfg->searchSpcToAddModList[srchSpcIdx].searchSpaceType == SEARCHSPACETYPE_PR_UE_SPECIFIC)
8194                {
8195                   macPdcchCfg->searchSpcToAddModList[srchSpcIdx].ueSpecificDciFormat =\
8196                                                                                       srchSpcToAddModList->list.array[srchSpcIdx]->searchSpaceType->choice.ue_Specific->dci_Formats;
8197                }
8198
8199             }
8200          }
8201       }
8202    }
8203    /* Search space To Rel List */
8204    if(cuPdcchCfg->searchSpacesToReleaseList)
8205    {
8206       srchSpcToRelList = cuPdcchCfg->searchSpacesToReleaseList;
8207       if(srchSpcToRelList->list.count)
8208       {
8209          macPdcchCfg->numSearchSpcToRel = srchSpcToRelList->list.count;
8210          for(srchSpcIdx = 0; srchSpcIdx < srchSpcToRelList->list.count; srchSpcIdx++)
8211          {
8212             macPdcchCfg->searchSpcToRelList[srchSpcIdx] =\
8213                                                          *(srchSpcToRelList->list.array[srchSpcIdx]);
8214          }
8215       }
8216    }
8217 }
8218
8219 /*******************************************************************
8220  *
8221  * @brief Fills PdschCfg received by CU
8222  *
8223  * @details
8224  *
8225  *    Function : extractPdschCfg
8226  *
8227  *    Functionality: Fills PdschCfg received  by CU
8228  *
8229  * @params[in] PDSCH_Config_t *cuPdschCfg = Information which is send by CU,
8230  *                   which we have stored in F1UeContextSetupDb,
8231  *             PdschConfig *macPdschCfg = Used to Store the information which
8232  *                   needs to send in other layer, as well as this can be the variable
8233  *                   which stores the information in DuCb,
8234  *             PdschConfig *storedPdschCfg =  Null in case of sending the
8235  *                   information to other layer else it will have stored pdsch
8236  *                   configuration in copyOfmacUeCfg.
8237  * @return void
8238  *
8239  * ****************************************************************/
8240
8241 void extractPdschCfg(PDSCH_Config_t *cuPdschCfg, PdschConfig *macPdschCfg, PdschConfig *storedPdschCfg)
8242 {
8243    uint8_t timeDomIdx;
8244    struct PDSCH_Config__pdsch_TimeDomainAllocationList *timeDomAlloc = NULLP;
8245
8246    if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA)
8247    {
8248       if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->present == \
8249             PDSCH_Config__dmrs_DownlinkForPDSCH_MappingTypeA_PR_setup)
8250       {
8251          if(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup)
8252          {
8253             macPdschCfg->dmrsDlCfgForPdschMapTypeA.addPos = \
8254                *(cuPdschCfg->dmrs_DownlinkForPDSCH_MappingTypeA->choice.setup->dmrs_AdditionalPosition);
8255          }
8256       }
8257    }
8258    macPdschCfg->resourceAllocType = cuPdschCfg->resourceAllocation;
8259    if(cuPdschCfg->pdsch_TimeDomainAllocationList)
8260    {
8261       timeDomAlloc = cuPdschCfg->pdsch_TimeDomainAllocationList;
8262       if(timeDomAlloc->present ==\
8263             PDSCH_Config__pdsch_TimeDomainAllocationList_PR_setup)
8264       {
8265          if(timeDomAlloc->choice.setup)
8266          {
8267             macPdschCfg->numTimeDomRsrcAlloc  = timeDomAlloc->choice.setup->list.count;
8268             for(timeDomIdx = 0; timeDomIdx < timeDomAlloc->choice.setup->list.count; timeDomIdx++)
8269             {
8270                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 = NULLP;
8271                if(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0)
8272                {
8273                   if(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 == NULL)
8274                   {
8275                      if(storedPdschCfg)
8276                      {
8277                         if(storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
8278                         {
8279                            macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0 =\
8280                            storedPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0;
8281                         }
8282                         else
8283                         {
8284                            DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
8285                         }
8286                      }
8287                      else
8288                      {
8289                         DU_ALLOC_SHRABL_BUF(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0, sizeof(uint8_t));
8290                      }
8291                      if(!macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0)
8292                      {
8293                         DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for k0 at extractPdschCfg()");
8294                         return RFAILED;
8295                      }
8296                   }
8297                   *(macPdschCfg->timeDomRsrcAllociList[timeDomIdx].k0) = \
8298                   *(timeDomAlloc->choice.setup->list.array[timeDomIdx]->k0);
8299                }
8300                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].mappingType = \
8301                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->mappingType;
8302                macPdschCfg->timeDomRsrcAllociList[timeDomIdx].startSymbolAndLength = \
8303                   timeDomAlloc->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8304             }
8305          }
8306       }
8307    }
8308    macPdschCfg->rbgSize = cuPdschCfg->rbg_Size;
8309    if(cuPdschCfg->maxNrofCodeWordsScheduledByDCI)
8310       macPdschCfg->numCodeWordsSchByDci = *(cuPdschCfg->maxNrofCodeWordsScheduledByDCI);
8311    if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_staticBundling)
8312    {
8313       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
8314       if(cuPdschCfg->prb_BundlingType.choice.staticBundling)
8315       {
8316          if(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize)
8317          {
8318             macPdschCfg->bundlingInfo.StaticBundling.size = \
8319                *(cuPdschCfg->prb_BundlingType.choice.staticBundling->bundleSize);
8320          }
8321       }
8322    }
8323    else if(cuPdschCfg->prb_BundlingType.present == PDSCH_Config__prb_BundlingType_PR_dynamicBundling)
8324    {
8325       macPdschCfg->bundlingType = cuPdschCfg->prb_BundlingType.present;
8326    }
8327
8328 }
8329
8330 /*******************************************************************
8331  *
8332  * @brief Fills PdschServingCellCfg received by CU
8333  *
8334  * @details
8335  *
8336  *    Function : extractPdschServingCellCfg
8337  *
8338  *    Functionality: Fills PdschCfg received  by CU
8339  *
8340  * @params[in] PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg,
8341  *             PdschServCellCfg *macUePdschSrvCellCfg
8342  * @return ROK/RFAILED
8343  *
8344  * ****************************************************************/
8345
8346 uint8_t extractPdschServingCellCfg(PDSCH_ServingCellConfig_t *cuPdschSrvCellCfg, PdschServCellCfg *macUePdschSrvCellCfg)
8347 {
8348    if(cuPdschSrvCellCfg->codeBlockGroupTransmission)
8349    {
8350       if(cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup)
8351       {
8352          if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
8353          {
8354             *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
8355                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
8356          }
8357          else
8358          {
8359             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb, sizeof(MaxCodeBlkGrpPerTB));
8360             if(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)
8361             {
8362                *(macUePdschSrvCellCfg->maxCodeBlkGrpPerTb)  = \
8363                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->maxCodeBlockGroupsPerTransportBlock;
8364             }
8365             else
8366             {
8367                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxCodeBlkGrpPerTb at extractPdschServingCellCfg()");
8368                return RFAILED;
8369             }
8370          }
8371          if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
8372          {
8373             *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
8374                cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
8375          }
8376          else
8377          {
8378             DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->codeBlkGrpFlushInd , sizeof(bool));
8379             if(macUePdschSrvCellCfg->codeBlkGrpFlushInd)
8380             {
8381                *(macUePdschSrvCellCfg->codeBlkGrpFlushInd)  = \
8382                   cuPdschSrvCellCfg->codeBlockGroupTransmission->choice.setup->codeBlockGroupFlushIndicator;
8383             }
8384             else
8385             {
8386                DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for codeBlkGrpFlushInd at extractPdschServingCellCfg()");
8387                return RFAILED;
8388             }
8389          }
8390       }
8391    }
8392    if(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH)
8393    {
8394       macUePdschSrvCellCfg->numHarqProcForPdsch = *(cuPdschSrvCellCfg->nrofHARQ_ProcessesForPDSCH);
8395    }
8396    if(cuPdschSrvCellCfg->ext1)
8397    {
8398       if(cuPdschSrvCellCfg->ext1->maxMIMO_Layers)
8399       {
8400         if(macUePdschSrvCellCfg->maxMimoLayers)
8401         {
8402            *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
8403         }
8404         else
8405         {
8406            DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->maxMimoLayers, sizeof(uint8_t));
8407            if(macUePdschSrvCellCfg->maxMimoLayers)
8408            {
8409               *(macUePdschSrvCellCfg->maxMimoLayers)  = *(cuPdschSrvCellCfg->ext1->maxMIMO_Layers);
8410            }
8411            else
8412            {
8413               DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for maxMimoLayers at extractPdschServingCellCfg()");
8414               return RFAILED;
8415            }
8416         }
8417       }
8418    }
8419    if(cuPdschSrvCellCfg->xOverhead)
8420    {
8421       if(macUePdschSrvCellCfg->xOverhead)
8422       {
8423          *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
8424       }
8425       else
8426       {
8427          DU_ALLOC_SHRABL_BUF(macUePdschSrvCellCfg->xOverhead, sizeof(PdschXOverhead));
8428          if(macUePdschSrvCellCfg->xOverhead)
8429          {
8430             *(macUePdschSrvCellCfg->xOverhead)  = *(cuPdschSrvCellCfg->xOverhead);
8431          }
8432          else
8433          {
8434             DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for xOverhead at extractPdschServingCellCfg()");
8435             return RFAILED;
8436          }
8437       }
8438    }
8439    return ROK;
8440 }
8441
8442 /*******************************************************************
8443  *
8444  * @brief Fills PuschCfg received by CU
8445  *
8446  * @details
8447  *
8448  *    Function : extractPuschCfg
8449  *
8450  *    Functionality: Fills PuschCfg received  by CU
8451  *
8452  * @params[in] BWP_UplinkDedicated__pusch_Config *cuPuschCfg,
8453  *             PuschCfg *macPuschCfg
8454  * @return void
8455  *
8456  * ****************************************************************/
8457
8458 void extractPuschCfg(struct BWP_UplinkDedicated__pusch_Config *cuPuschCfg, PuschCfg *macPuschCfg)
8459 {
8460    uint8_t timeDomIdx = 0;
8461    DMRS_UplinkConfig_t *dmrsUlCfg = NULLP;
8462    struct PUSCH_Config__pusch_TimeDomainAllocationList *timeDomAllocList = NULLP;
8463
8464    if(cuPuschCfg->present == BWP_UplinkDedicated__pusch_Config_PR_setup)
8465    {
8466       if(cuPuschCfg->choice.setup)
8467       {
8468          if(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH)
8469          {
8470              macPuschCfg->dataScramblingId = \
8471                 *(cuPuschCfg->choice.setup->dataScramblingIdentityPUSCH);
8472          }
8473          if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA)
8474          {
8475             if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->present == PUSCH_Config__dmrs_UplinkForPUSCH_MappingTypeA_PR_setup)
8476             {
8477                if(cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup)
8478                {
8479                   dmrsUlCfg = (cuPuschCfg->choice.setup->dmrs_UplinkForPUSCH_MappingTypeA->choice.setup);
8480                   if(dmrsUlCfg->dmrs_AdditionalPosition)
8481                   {
8482                      macPuschCfg->dmrsUlCfgForPuschMapTypeA.addPos =\
8483                         *(dmrsUlCfg->dmrs_AdditionalPosition);
8484                   }
8485                   if(dmrsUlCfg->transformPrecodingDisabled)
8486                   {
8487                      if(dmrsUlCfg->transformPrecodingDisabled->scramblingID0)
8488                      {
8489                         macPuschCfg->dmrsUlCfgForPuschMapTypeA.transPrecodDisabled.scramblingId0 = \
8490                            *(dmrsUlCfg->transformPrecodingDisabled->scramblingID0);
8491                      }
8492                   }
8493                }
8494             }
8495          }
8496          /*Res Alloc Type for UL */
8497          if(cuPuschCfg->choice.setup->resourceAllocation)
8498          {
8499             macPuschCfg->resourceAllocType = \
8500                cuPuschCfg->choice.setup->resourceAllocation;
8501          }
8502          if(cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList)
8503          {
8504             timeDomAllocList = cuPuschCfg->choice.setup->pusch_TimeDomainAllocationList;
8505             if(timeDomAllocList->present == PUSCH_Config__pusch_TimeDomainAllocationList_PR_setup)
8506             {
8507                if(timeDomAllocList->choice.setup)
8508                {
8509                   macPuschCfg->numTimeDomRsrcAlloc = timeDomAllocList->choice.setup->list.count;
8510                   for(timeDomIdx = 0; timeDomIdx <timeDomAllocList->choice.setup->list.count; timeDomIdx++)
8511                   {
8512                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].k2 = \
8513                         *(timeDomAllocList->choice.setup->list.array[timeDomIdx]->k2);
8514                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].mappingType = \
8515                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->mappingType;
8516                      macPuschCfg->timeDomRsrcAllocList[timeDomIdx].startSymbolAndLength = \
8517                         timeDomAllocList->choice.setup->list.array[timeDomIdx]->startSymbolAndLength;
8518                   }
8519                }
8520             }
8521          }
8522          if(cuPuschCfg->choice.setup->transformPrecoder)
8523             macPuschCfg->transformPrecoder = *(cuPuschCfg->choice.setup->transformPrecoder);
8524       }
8525    }
8526 }
8527
8528 /*******************************************************************
8529  *
8530  * @brief Function to fill pucch Power Control
8531  *
8532  * @details
8533  *
8534  *    Function : extractPucchPowerControl
8535  *
8536  *    Functionality: Function to fill pucch Power Control
8537  *
8538  * @params[in] PucchPowerControl *pwrCtrl,
8539  *             struct PUCCH_PowerControl *cuPwrCtrlCfg
8540  * @return void
8541  *
8542  * ****************************************************************/
8543
8544 void extractPucchPowerControl(PucchPowerControl *pwrCtrl, struct PUCCH_PowerControl *cuPwrCtrlCfg)
8545 {
8546    uint8_t arrIdx;
8547
8548    if(cuPwrCtrlCfg->deltaF_PUCCH_f0)
8549       pwrCtrl->deltaF_Format0 = *cuPwrCtrlCfg->deltaF_PUCCH_f0;
8550    if(cuPwrCtrlCfg->deltaF_PUCCH_f1)
8551       pwrCtrl->deltaF_Format1 = *cuPwrCtrlCfg->deltaF_PUCCH_f1;
8552    if(cuPwrCtrlCfg->deltaF_PUCCH_f2)
8553       pwrCtrl->deltaF_Format2 = *cuPwrCtrlCfg->deltaF_PUCCH_f2;
8554    if(cuPwrCtrlCfg->deltaF_PUCCH_f3)
8555       pwrCtrl->deltaF_Format3 = *cuPwrCtrlCfg->deltaF_PUCCH_f3;
8556    if(cuPwrCtrlCfg->deltaF_PUCCH_f4)
8557       pwrCtrl->deltaF_Format4 = *cuPwrCtrlCfg->deltaF_PUCCH_f4;
8558    if(cuPwrCtrlCfg->p0_Set)
8559    {
8560       pwrCtrl->p0SetCount = cuPwrCtrlCfg->p0_Set->list.count;
8561       for(arrIdx=0; arrIdx < pwrCtrl->p0SetCount; arrIdx++)
8562       {
8563          pwrCtrl->p0Set[arrIdx].p0PucchId =\
8564             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Id;
8565          pwrCtrl->p0Set[arrIdx].p0PucchVal =\
8566             cuPwrCtrlCfg->p0_Set->list.array[arrIdx]->p0_PUCCH_Value;
8567       }
8568    }
8569    if(cuPwrCtrlCfg->pathlossReferenceRSs)
8570    {
8571       pwrCtrl->pathLossRefRSListCount = cuPwrCtrlCfg->pathlossReferenceRSs->list.count;
8572       for(arrIdx = 0; arrIdx < pwrCtrl->pathLossRefRSListCount; arrIdx++)
8573       {
8574          pwrCtrl->pathLossRefRSList[arrIdx].pathLossRefRSId =\
8575             cuPwrCtrlCfg->pathlossReferenceRSs->list.array[arrIdx]->pucch_PathlossReferenceRS_Id;
8576       }
8577    }
8578 }
8579
8580  /*******************************************************************
8581  *
8582  * @brief Function to extractResrcSetToAddModList sent by CU
8583  *
8584  * @details
8585  *
8586  *    Function : extractResrcSetToAddModList
8587  *
8588  *    Functionality: Fucntion to extractResrcSetToAddModList
8589  *
8590  * @params[in] PucchResrcSetCfg pointer,
8591  *             struct PUCCH_Config__resourceSetToAddModList pointer
8592  * @return void
8593  *
8594  * ****************************************************************/
8595
8596 void extractResrcSetToAddModList(PucchResrcSetCfg *macRsrcSetList, struct PUCCH_Config__resourceSetToAddModList *cuRsrcSetList)
8597 {
8598    uint8_t arrIdx, rsrcListIdx;
8599
8600    macRsrcSetList->resrcSetToAddModListCount = cuRsrcSetList->list.count;
8601    for(arrIdx = 0; arrIdx < macRsrcSetList->resrcSetToAddModListCount; arrIdx++)
8602    {
8603       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcSetId     =\
8604          cuRsrcSetList->list.array[arrIdx]->pucch_ResourceSetId;
8605       macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount =\
8606          cuRsrcSetList->list.array[arrIdx]->resourceList.list.count;
8607       for(rsrcListIdx = 0; rsrcListIdx < macRsrcSetList->resrcSetToAddModList[arrIdx].resrcListCount; rsrcListIdx++)
8608       {
8609          macRsrcSetList->resrcSetToAddModList[arrIdx].resrcList[rsrcListIdx] =\
8610             *cuRsrcSetList->list.array[arrIdx]->resourceList.list.array[rsrcListIdx];
8611       }
8612       macRsrcSetList->resrcSetToAddModList[arrIdx].maxPayLoadSize =\
8613          *cuRsrcSetList->list.array[arrIdx]->maxPayloadMinus1;
8614    }
8615 }/* End of extractResrcSetToAddModList */
8616
8617 /*******************************************************************
8618  *
8619  * @brief Fills extractResrcToAddModList sent by CU
8620  *
8621  * @details
8622  *
8623  *    Function : extractResrcToAddModList
8624  *
8625  *    Functionality: Fills extractResrcToAddModList
8626  *
8627  * @params[in] PucchResrcCfg pointer,
8628  *             struct PUCCH_Config__resourceToAddModList pointer
8629  * @return ROk/RFAILED
8630  *
8631  * ****************************************************************/
8632
8633 uint8_t extractResrcToAddModList(PucchResrcCfg *macResrcList, struct PUCCH_Config__resourceToAddModList *cuResrcList)
8634 {
8635    uint8_t arrIdx;
8636
8637    macResrcList->resrcToAddModListCount = cuResrcList->list.count;
8638    for(arrIdx = 0; arrIdx < macResrcList->resrcToAddModListCount; arrIdx++)
8639    {
8640       macResrcList->resrcToAddModList[arrIdx].resrcId      =\
8641         cuResrcList->list.array[arrIdx]->pucch_ResourceId;
8642       macResrcList->resrcToAddModList[arrIdx].startPrb     =\
8643         cuResrcList->list.array[arrIdx]->startingPRB;
8644       if(cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping)
8645       {
8646          macResrcList->resrcToAddModList[arrIdx].intraFreqHop =\
8647            *cuResrcList->list.array[arrIdx]->intraSlotFrequencyHopping;
8648       }
8649       if(cuResrcList->list.array[arrIdx]->secondHopPRB)
8650       {
8651          macResrcList->resrcToAddModList[arrIdx].secondPrbHop =\
8652            *cuResrcList->list.array[arrIdx]->secondHopPRB;
8653       }
8654       /* PUCCH RSRC FORMAT */
8655       if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format0)
8656       {
8657          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_0;
8658          if(cuResrcList->list.array[arrIdx]->format.choice.format0)
8659          {
8660             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0, sizeof(PucchFormat0));
8661             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0 == NULLP)
8662             {
8663                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format0 in extractResrcToAddModList()");
8664                return RFAILED;
8665             }
8666             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->initialCyclicShift =\
8667                cuResrcList->list.array[arrIdx]->format.choice.format0->initialCyclicShift;
8668             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->numSymbols =\
8669                cuResrcList->list.array[arrIdx]->format.choice.format0->nrofSymbols;
8670             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format0->startSymbolIdx =\
8671                cuResrcList->list.array[arrIdx]->format.choice.format0->startingSymbolIndex;
8672          }
8673       }
8674       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format1)
8675       {
8676          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_1;
8677          if(cuResrcList->list.array[arrIdx]->format.choice.format1)
8678          {
8679             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1, sizeof(PucchFormat1));
8680             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1 == NULLP)
8681             {
8682                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format1 in extractResrcToAddModList()");
8683                return RFAILED;
8684             }
8685             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->initialCyclicShift =\
8686                 cuResrcList->list.array[arrIdx]->format.choice.format1->initialCyclicShift;
8687             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->numSymbols =\
8688                 cuResrcList->list.array[arrIdx]->format.choice.format1->nrofSymbols;
8689             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->startSymbolIdx =\
8690                 cuResrcList->list.array[arrIdx]->format.choice.format1->startingSymbolIndex;
8691             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format1->timeDomOCC =\
8692                 cuResrcList->list.array[arrIdx]->format.choice.format1->timeDomainOCC;
8693          }
8694       }
8695       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format2)
8696       {
8697          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_2;
8698          if(cuResrcList->list.array[arrIdx]->format.choice.format2)
8699          {
8700             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2, sizeof(PucchFormat2_3));
8701             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2 == NULLP)
8702             {
8703                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format2 in extractResrcToAddModList()");
8704                return RFAILED;
8705             }
8706             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numPrbs =\
8707                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofPRBs;
8708             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->numSymbols =\
8709                 cuResrcList->list.array[arrIdx]->format.choice.format2->nrofSymbols;
8710             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format2->startSymbolIdx =\
8711                 cuResrcList->list.array[arrIdx]->format.choice.format2->startingSymbolIndex;
8712          }
8713       }
8714       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format3)
8715       {
8716          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_3;
8717          if(cuResrcList->list.array[arrIdx]->format.choice.format3)
8718          {
8719             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3, sizeof(PucchFormat2_3));
8720             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3 == NULLP)
8721             {
8722                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format3 in extractResrcToAddModList()");
8723                return RFAILED;
8724             }
8725             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numPrbs =\
8726                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofPRBs;
8727             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->numSymbols =\
8728                 cuResrcList->list.array[arrIdx]->format.choice.format3->nrofSymbols;
8729             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format3->startSymbolIdx =\
8730                 cuResrcList->list.array[arrIdx]->format.choice.format3->startingSymbolIndex;
8731          }
8732       }
8733       else if(cuResrcList->list.array[arrIdx]->format.present == PUCCH_Resource__format_PR_format4)
8734       {
8735          macResrcList->resrcToAddModList[arrIdx].pucchFormat = PUCCH_FORMAT_4;
8736          if(cuResrcList->list.array[arrIdx]->format.choice.format4)
8737          {
8738             DU_ALLOC_SHRABL_BUF(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4, sizeof(PucchFormat4));
8739             if(macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4 == NULLP)
8740             {
8741                DU_LOG("\nERROR  --> F1AP : Failed to allocate memory for Format4 in extractResrcToAddModList()");
8742                return RFAILED;
8743             }
8744             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->numSymbols =\
8745                 cuResrcList->list.array[arrIdx]->format.choice.format4->nrofSymbols;
8746             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occLen =\
8747                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Length;
8748             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->occIdx =\
8749                 cuResrcList->list.array[arrIdx]->format.choice.format4->occ_Index;
8750             macResrcList->resrcToAddModList[arrIdx].PucchFormat.format4->startSymbolIdx =\
8751                 cuResrcList->list.array[arrIdx]->format.choice.format4->startingSymbolIndex;
8752          }
8753       }
8754    }
8755    return ROK;
8756
8757 }/* End of extractResrcToAddModList */
8758
8759 /*******************************************************************
8760  *
8761  * @brief Fills fillPucchSchedReqPeriodAndOffset sent by CU
8762  *
8763  * @details
8764  *
8765  *    Function : fillPucchSchedReqPeriodAndOffset
8766  *
8767  *    Functionality: To fillPucchSchedReqPeriodAndOffset
8768  *
8769  * @params[in] macPeriodicty,
8770  *     SchedulingRequestResourceConfig__periodicityAndOffset pointer
8771  * @return void
8772  *
8773  * ****************************************************************/
8774
8775 void fillPucchSchedReqPeriodAndOffset(uint8_t macPeriodicty, uint16_t  macOffset,\
8776    struct SchedulingRequestResourceConfig__periodicityAndOffset *cuPeriodicty)
8777 {
8778    macPeriodicty = cuPeriodicty->present;
8779    switch(macPeriodicty)
8780    {
8781       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym2:
8782          {
8783             macOffset     = cuPeriodicty->choice.sym2;
8784             break;
8785          }
8786       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sym6or7:
8787          {
8788             macOffset     = cuPeriodicty->choice.sym6or7;
8789             break;
8790          }
8791       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl1:
8792          {
8793             macOffset     = cuPeriodicty->choice.sl1;
8794             break;
8795          }
8796       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl2:
8797          {
8798             macOffset = cuPeriodicty->choice.sl2;
8799             break;
8800          }
8801       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl4:
8802          {
8803             macOffset = cuPeriodicty->choice.sl4;
8804             break;
8805          }
8806       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl5:
8807          {
8808             macOffset = cuPeriodicty->choice.sl5;
8809             break;
8810          }
8811       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl8:
8812          {
8813             macOffset = cuPeriodicty->choice.sl8;
8814             break;
8815          }
8816       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl10:
8817          {
8818             macOffset = cuPeriodicty->choice.sl10;
8819             break;
8820          }
8821       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl16:
8822          {
8823             macOffset = cuPeriodicty->choice.sl16;
8824             break;
8825          }
8826       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl20:
8827          {
8828             macOffset = cuPeriodicty->choice.sl20;
8829             break;
8830          }
8831       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl40:
8832          {
8833             macOffset = cuPeriodicty->choice.sl40;
8834             break;
8835          }
8836       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl80:
8837          {
8838             macOffset = cuPeriodicty->choice.sl80;
8839             break;
8840          }
8841       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl160:
8842          {
8843             macOffset = cuPeriodicty->choice.sl160;
8844             break;
8845          }
8846       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl320:
8847          {
8848             macOffset = cuPeriodicty->choice.sl320;
8849             break;
8850          }
8851       case SchedulingRequestResourceConfig__periodicityAndOffset_PR_sl640:
8852          {
8853             macOffset = cuPeriodicty->choice.sl640;
8854             break;
8855          }
8856       default :
8857          DU_LOG("\nERROR  -->  F1AP : Invalid periodicity %d", macPeriodicty);
8858    }
8859 }
8860
8861 /*******************************************************************
8862  *
8863  * @brief Function to extractPucchFormatCfg sent by CU
8864  *
8865  * @details
8866  *
8867  *    Function : extractPucchFormatCfg
8868  *
8869  *    Functionality: Function to extractPucchFormatCfg
8870  *
8871  * @params[in] PucchFormatCfg pointer,
8872  *             PUCCH_FormatConfig_t pointer
8873  * @return void
8874  *
8875  * ****************************************************************/
8876
8877 void extractPucchFormatCfg(PucchFormatCfg *macFormatCfg, PUCCH_FormatConfig_t *cuFormatCfg)
8878  {
8879     if(cuFormatCfg->interslotFrequencyHopping)
8880        macFormatCfg->interSlotFreqHop = *cuFormatCfg->interslotFrequencyHopping;
8881     if(cuFormatCfg->additionalDMRS)
8882        macFormatCfg->addDmrs = *cuFormatCfg->additionalDMRS;
8883     if(cuFormatCfg->maxCodeRate)
8884        macFormatCfg->maxCodeRate = *cuFormatCfg->maxCodeRate;
8885     if(cuFormatCfg->nrofSlots)
8886        macFormatCfg->numSlots = *cuFormatCfg->nrofSlots;
8887     if(cuFormatCfg->pi2BPSK)
8888        macFormatCfg->pi2BPSK = *cuFormatCfg->pi2BPSK;
8889     if(cuFormatCfg->simultaneousHARQ_ACK_CSI)
8890        macFormatCfg->harqAckCSI = *cuFormatCfg->simultaneousHARQ_ACK_CSI;
8891  }/* End of extractPucchFormatCfg */
8892
8893 /*******************************************************************
8894  *
8895  * @brief Function to extractSchedReqCfgToAddMod sent by CU
8896  *
8897  * @details
8898  *
8899  *    Function : extractSchedReqCfgToAddMod
8900  *
8901  *    Functionality: Function to extractSchedReqCfgToAddMod
8902  *
8903  * @params[in] PucchSchedReqCfg pointer,
8904  *      PUCCH_Config__schedulingRequestResourceToAddModList pointer
8905  * @return void
8906  *
8907  * ****************************************************************/
8908
8909 void extractSchedReqCfgToAddMod(PucchSchedReqCfg *macSchedReqCfg, struct PUCCH_Config__schedulingRequestResourceToAddModList *cuSchedReqList)
8910 {
8911    uint8_t arrIdx;
8912
8913    macSchedReqCfg->schedAddModListCount = cuSchedReqList->list.count;
8914    for(arrIdx = 0; arrIdx <  macSchedReqCfg->schedAddModListCount; arrIdx++)
8915    {
8916       macSchedReqCfg->schedAddModList[arrIdx].resrcId =\
8917          cuSchedReqList->list.array[arrIdx]->schedulingRequestResourceId;
8918       macSchedReqCfg->schedAddModList[arrIdx].requestId =\
8919          cuSchedReqList->list.array[arrIdx]->schedulingRequestID;
8920       if(cuSchedReqList->list.array[arrIdx]->periodicityAndOffset)
8921       {
8922          fillPucchSchedReqPeriodAndOffset(macSchedReqCfg->schedAddModList[arrIdx].periodicity,\
8923             macSchedReqCfg->schedAddModList[arrIdx].offset, cuSchedReqList->list.array[arrIdx]->periodicityAndOffset);
8924       }
8925       if(cuSchedReqList->list.array[arrIdx]->resource)
8926       {
8927          macSchedReqCfg->schedAddModList[arrIdx].resrc =\
8928             *cuSchedReqList->list.array[arrIdx]->resource;
8929       }
8930    }
8931
8932 }/* End of extractSchedReqCfgToAddMod */
8933
8934  /*******************************************************************
8935  *
8936  * @brief Fills PucchCfg received by CU
8937  *
8938  * @details
8939  *
8940  *    Function : extractPucchCfg
8941  *
8942  *    Functionality: Fills PucchCfg received  by CU
8943  *
8944  * @params[in] BWP_UplinkDedicated__pucch_Config *cuPucchCfg = Information which
8945  *                is send by CU, which we have stored in F1UeContextSetupDb,
8946  *             PucchCfg *macPucchCfg = Used to Store the information which
8947  *                needs to send in other layer, as well as this can be the variable
8948  *                which stores the information in DuCb,
8949  *             PucchCfg *storedPucchCfg = Null in case of sending the
8950  *                information to other layer else it will have Pucch Cfg which
8951  *                we have stored in copyOfmacUeCfg.
8952  * @return ROK/RFAILED
8953  *
8954  * ****************************************************************/
8955
8956 uint8_t extractPucchCfg(struct BWP_UplinkDedicated__pucch_Config *cuPucchCfg, PucchCfg *macPucchCfg,\
8957 PucchCfg *storedPucchCfg)
8958 {
8959    uint8_t arrIdx;
8960
8961    if(cuPucchCfg->present == BWP_UplinkDedicated__pucch_Config_PR_setup)
8962    {
8963       if(cuPucchCfg->choice.setup)
8964       {
8965          /* Resource Set Cfg */
8966          if(cuPucchCfg->choice.setup->resourceSetToAddModList)
8967          {
8968             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrcSet, sizeof(PucchResrcSetCfg));
8969             if(macPucchCfg->resrcSet == NULLP)
8970             {
8971                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc set List in extractPucchCfg()");
8972                return RFAILED;
8973             }
8974             memset(macPucchCfg->resrcSet, 0, sizeof(PucchResrcSetCfg));
8975             extractResrcSetToAddModList(macPucchCfg->resrcSet, cuPucchCfg->choice.setup->resourceSetToAddModList);
8976          }
8977
8978          /* Resource Cfg */
8979          if(cuPucchCfg->choice.setup->resourceToAddModList)
8980          {
8981             DU_ALLOC_SHRABL_BUF(macPucchCfg->resrc, sizeof(PucchResrcCfg));
8982             if(macPucchCfg->resrc == NULLP)
8983             {
8984                DU_LOG("\nERROR --> F1AP : Failed to extract Resrc List in extractPucchCfg()");
8985                return RFAILED;
8986             }
8987             memset(macPucchCfg->resrc, 0, sizeof(PucchResrcCfg));
8988             extractResrcToAddModList(macPucchCfg->resrc, cuPucchCfg->choice.setup->resourceToAddModList);
8989          }
8990
8991          /* Format 1 Cfg */
8992          if(cuPucchCfg->choice.setup->format1)
8993          {
8994             DU_ALLOC_SHRABL_BUF(macPucchCfg->format1, sizeof(PucchFormatCfg));
8995             if(macPucchCfg->format1 == NULLP)
8996             {
8997                DU_LOG("\nERROR --> F1AP : Failed to extract format 1 Cfg in  extractPucchCfg()");
8998                return RFAILED;
8999             }
9000             memset(macPucchCfg->format1, 0, sizeof(PucchFormatCfg));
9001             extractPucchFormatCfg(macPucchCfg->format1,\
9002                cuPucchCfg->choice.setup->format1->choice.setup);
9003          }
9004
9005          /* Format 2 Cfg */
9006          if(cuPucchCfg->choice.setup->format2)
9007          {
9008             DU_ALLOC_SHRABL_BUF(macPucchCfg->format2, sizeof(PucchFormatCfg));
9009             if(macPucchCfg->format2 == NULLP)
9010             {
9011                DU_LOG("\nERROR --> F1AP : Failed to extract format 2 Cfg in  extractPucchCfg()");
9012                return RFAILED;
9013             }
9014             memset(macPucchCfg->format2, 0, sizeof(PucchFormatCfg));
9015             extractPucchFormatCfg(macPucchCfg->format2,\
9016                cuPucchCfg->choice.setup->format2->choice.setup);
9017          }
9018
9019          /* Format 3 Cfg */
9020          if(cuPucchCfg->choice.setup->format3)
9021          {
9022             DU_ALLOC_SHRABL_BUF(macPucchCfg->format3, sizeof(PucchFormatCfg));
9023             if(macPucchCfg->format3 == NULLP)
9024             {
9025                DU_LOG("\nERROR --> F1AP : Failed to extract format 3 Cfg in  extractPucchCfg()");
9026                return RFAILED;
9027             }
9028             memset(macPucchCfg->format3, 0, sizeof(PucchFormatCfg));
9029             extractPucchFormatCfg(macPucchCfg->format3,\
9030                cuPucchCfg->choice.setup->format3->choice.setup);
9031          }
9032
9033          /* Format 4 Cfg */
9034          if(cuPucchCfg->choice.setup->format4)
9035          {
9036             DU_ALLOC_SHRABL_BUF(macPucchCfg->format4, sizeof(PucchFormatCfg));
9037             if(macPucchCfg->format4 == NULLP)
9038             {
9039                DU_LOG("\nERROR --> F1AP : Failed to extract format 4 Cfg in  extractPucchCfg()");
9040                return RFAILED;
9041             }
9042             memset(macPucchCfg->format4, 0, sizeof(PucchFormatCfg));
9043             extractPucchFormatCfg(macPucchCfg->format4,\
9044                cuPucchCfg->choice.setup->format4->choice.setup);
9045          }
9046
9047          /* Sched Req List */
9048          if(cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList)
9049          {
9050             DU_ALLOC_SHRABL_BUF(macPucchCfg->schedReq, sizeof(PucchSchedReqCfg));
9051             if(macPucchCfg->schedReq == NULLP)
9052             {
9053                DU_LOG("\nERROR --> F1AP : Failed to extract schedReqCfg in  extractPucchCfg()");
9054                return RFAILED;
9055             }
9056             memset(macPucchCfg->schedReq, 0, sizeof(PucchSchedReqCfg));
9057             extractSchedReqCfgToAddMod(macPucchCfg->schedReq,\
9058             cuPucchCfg->choice.setup->schedulingRequestResourceToAddModList);
9059          }
9060
9061          /*TODO: Add support for  Spatial Info */
9062
9063          /* MultiCsiCfg */
9064          if(cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList)
9065          {
9066             DU_ALLOC_SHRABL_BUF(macPucchCfg->multiCsiCfg, sizeof(PucchMultiCsiCfg));
9067             if(macPucchCfg->multiCsiCfg == NULLP)
9068             {
9069                DU_LOG("\nERROR --> F1AP : Failed to extract multiCsiCfg in  extractPucchCfg()");
9070                return RFAILED;
9071             }
9072             memset(macPucchCfg->multiCsiCfg, 0, sizeof(PucchMultiCsiCfg));
9073             macPucchCfg->multiCsiCfg->multiCsiResrcListCount = cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.count;
9074             for(arrIdx =0; arrIdx < macPucchCfg->multiCsiCfg->multiCsiResrcListCount; arrIdx++)
9075             {
9076                macPucchCfg->multiCsiCfg->multiCsiResrcList[arrIdx] =\
9077                  *cuPucchCfg->choice.setup->multi_CSI_PUCCH_ResourceList->list.array[arrIdx];
9078             }
9079          }
9080
9081          /* Dl_DataToUL_ACK */
9082          if(cuPucchCfg->choice.setup->dl_DataToUL_ACK)
9083     {
9084        if(storedPucchCfg)
9085        {
9086           if(storedPucchCfg->dlDataToUlAck)
9087           {
9088              macPucchCfg->dlDataToUlAck = storedPucchCfg->dlDataToUlAck;
9089           }
9090           else
9091           {
9092             DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
9093           }
9094        }
9095        else
9096        {
9097           DU_ALLOC_SHRABL_BUF(macPucchCfg->dlDataToUlAck, sizeof(PucchDlDataToUlAck));
9098        }
9099        if(macPucchCfg->dlDataToUlAck == NULLP)
9100        {
9101           DU_LOG("\nERROR --> F1AP : Failed to extract Dl_DataToUL_ACK in extractPucchCfg()");
9102           return RFAILED;
9103        }
9104        memset(macPucchCfg->dlDataToUlAck, 0, sizeof(PucchDlDataToUlAck));
9105        macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount = cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.count;
9106        for(arrIdx = 0; arrIdx < macPucchCfg->dlDataToUlAck->dlDataToUlAckListCount; arrIdx++)
9107        {
9108           macPucchCfg->dlDataToUlAck->dlDataToUlAckList[arrIdx] =\
9109           *cuPucchCfg->choice.setup->dl_DataToUL_ACK->list.array[arrIdx];
9110        }
9111          }
9112
9113          /* Power Control */
9114          if(cuPucchCfg->choice.setup->pucch_PowerControl)
9115          {
9116             DU_ALLOC_SHRABL_BUF(macPucchCfg->powerControl, sizeof(PucchPowerControl));
9117             if(macPucchCfg->powerControl == NULLP)
9118             {
9119                DU_LOG("\nERROR --> F1AP : Failed to extract power control in extractPucchCfg()");
9120                return RFAILED;
9121             }
9122             extractPucchPowerControl(macPucchCfg->powerControl,\
9123                cuPucchCfg->choice.setup->pucch_PowerControl);
9124          }
9125       }
9126    }
9127    return ROK;
9128 }
9129
9130 /*******************************************************************
9131  *
9132  * @brief Fills ServingCellReconfig received by CU
9133  *
9134  * @details
9135  *
9136  *    Function : extractSpCellDedicatedCfg
9137  *
9138  *    Functionality: Fills ServingCellReconfig received  by CU
9139  *
9140  * @params[in] ServingCellConfig_t *cuSrvCellCfg = Information which is send by
9141  *                  CU, which we have stored in F1UeContextSetupDb,
9142  *             ServCellCfgInfo *macSrvCellCfg = Used to Store the information
9143  *                  which  needs to send in other layer, as well as this can be the
9144  *                  variable which stores the information in DuCb,
9145  *             ServCellCfgInfo *storedSrvCellCfg = Null in case of sending the
9146  *                  information to other layer else it will have ServCellCfgInfo which
9147  *                  we have stored in copyOfmacUeCfg.
9148  * @return ROK/RFAILD
9149  *
9150  * ****************************************************************/
9151 uint8_t extractSpCellDedicatedCfg(ServingCellConfig_t *cuSrvCellCfg, ServCellCfgInfo *macSrvCellCfg,\
9152 ServCellCfgInfo *storedSrvCellCfg)
9153 {
9154    uint8_t ret = ROK;
9155    BWP_DownlinkDedicated_t *dlBwp = NULLP;
9156    BWP_UplinkDedicated_t   *ulBwp = NULLP;
9157
9158    if(cuSrvCellCfg->initialDownlinkBWP)
9159    {
9160       dlBwp = ((BWP_DownlinkDedicated_t *)(cuSrvCellCfg->initialDownlinkBWP));
9161       if(dlBwp->pdcch_Config)
9162       {
9163          if(dlBwp->pdcch_Config->choice.setup)
9164          {
9165             macSrvCellCfg->initDlBwp.pdcchPresent = true;
9166             if(storedSrvCellCfg)
9167             {
9168                if(!storedSrvCellCfg->initDlBwp.pdcchPresent)
9169                {
9170                   extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
9171                }
9172                else
9173                {
9174                   extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
9175                }
9176             }
9177             else
9178             {
9179                extractPdcchCfg(dlBwp->pdcch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdcchCfg);
9180             }
9181          }
9182       }
9183       if(dlBwp->pdsch_Config)
9184       {
9185          if(dlBwp->pdsch_Config->choice.setup)
9186          {
9187             macSrvCellCfg->initDlBwp.pdschPresent = true;
9188
9189             if(storedSrvCellCfg)
9190             {
9191                if(!storedSrvCellCfg->initDlBwp.pdschPresent)
9192                {
9193                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
9194                }
9195                else
9196                {
9197                   extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg,\
9198                         &storedSrvCellCfg->initDlBwp.pdschCfg);
9199                }
9200             }
9201             else
9202             {
9203                extractPdschCfg(dlBwp->pdsch_Config->choice.setup, &macSrvCellCfg->initDlBwp.pdschCfg, NULL);
9204             }
9205          }
9206       }
9207    }
9208    if(cuSrvCellCfg->firstActiveDownlinkBWP_Id)
9209       macSrvCellCfg->firstActvDlBwpId = *(cuSrvCellCfg->firstActiveDownlinkBWP_Id);
9210    if(cuSrvCellCfg->defaultDownlinkBWP_Id)
9211       macSrvCellCfg->defaultDlBwpId = *(cuSrvCellCfg->defaultDownlinkBWP_Id);
9212    if(cuSrvCellCfg->bwp_InactivityTimer)
9213    {
9214       if(macSrvCellCfg->bwpInactivityTmr)
9215       {
9216          memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
9217       }
9218       else
9219       {
9220          macSrvCellCfg->bwpInactivityTmr = NULLP;
9221          DU_ALLOC_SHRABL_BUF(macSrvCellCfg->bwpInactivityTmr, sizeof(uint8_t));
9222          if(macSrvCellCfg->bwpInactivityTmr)
9223          {
9224             memcpy(macSrvCellCfg->bwpInactivityTmr, cuSrvCellCfg->bwp_InactivityTimer, sizeof(uint8_t));
9225          }
9226          else
9227          {
9228             DU_LOG("\nERROR  --> F1AP : Memory Alloc failed for bwpInactivityTmr at extractSpCellDedicatedCfg()");
9229             return RFAILED;
9230          }
9231       }
9232    }
9233    if(cuSrvCellCfg->pdsch_ServingCellConfig)
9234    {
9235       if(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup)
9236       {
9237          ret = extractPdschServingCellCfg(cuSrvCellCfg->pdsch_ServingCellConfig->choice.setup, &macSrvCellCfg->pdschServCellCfg);
9238          if(ret == RFAILED)
9239          {
9240             DU_LOG("\nERROR --> F1AP : Failed at extractPdschServingCellCfg()");
9241             return RFAILED;
9242          }
9243       }
9244    }
9245    if(cuSrvCellCfg->uplinkConfig)
9246    {
9247       if(cuSrvCellCfg->uplinkConfig->initialUplinkBWP)
9248       {
9249          ulBwp = ((BWP_UplinkDedicated_t *)(cuSrvCellCfg->uplinkConfig->initialUplinkBWP));
9250          if(ulBwp->pusch_Config)
9251          {
9252             macSrvCellCfg->initUlBwp.puschPresent = true;
9253             extractPuschCfg(ulBwp->pusch_Config, &macSrvCellCfg->initUlBwp.puschCfg);
9254          }
9255          if(ulBwp->pucch_Config)
9256          {
9257             macSrvCellCfg->initUlBwp.pucchPresent = true;
9258             memset(&macSrvCellCfg->initUlBwp.pucchCfg, 0, sizeof(PucchCfg));
9259             if(storedSrvCellCfg)
9260             {
9261                if(!storedSrvCellCfg->initUlBwp.pucchPresent)
9262                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
9263                else
9264                   extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg,\
9265                   &storedSrvCellCfg->initUlBwp.pucchCfg);
9266             }
9267             else
9268             {
9269                extractPucchCfg(ulBwp->pucch_Config, &macSrvCellCfg->initUlBwp.pucchCfg, NULL);
9270             }
9271          }
9272       }
9273       if(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id)
9274          macSrvCellCfg->firstActvUlBwpId = *(cuSrvCellCfg->uplinkConfig->firstActiveUplinkBWP_Id);
9275    }
9276    return ret;
9277 }
9278 /*******************************************************************
9279  *
9280  * @brief Fills Reconfig Cell group Info received by CU
9281  *
9282  * @details
9283  *
9284  *    Function : extractUeReCfgCellInfo
9285  *
9286  *    Functionality: Fills Reconfig Cell group Info received by CU
9287  *
9288  * @params[in] CellGroupConfigRrc_t *cellGrp = CellGroupConfigRrc_t information which
9289  *                       is send by CU, which we have stored in F1UeContextSetupDb
9290  *             MacUeCfg *MacUeCfg = Used to Store the information,
9291  *                      which needs to send in other layer, as well as this can be
9292  *                      the variable which stores the information in DuCb,
9293  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
9294  *                      information to other layer else it will have copyOfmacUeCfg
9295  *                      which we have stored in F1UeContextSetupDb.
9296  *
9297  * @return ROK/RFAILED
9298  *
9299  * ****************************************************************/
9300 uint8_t extractUeReCfgCellInfo(CellGroupConfigRrc_t *cellGrp, MacUeCfg *macUeCfg, MacUeCfg *storedMacUeCfg)
9301 {
9302    uint8_t ret = ROK;
9303    MAC_CellGroupConfig_t     *macCellGroup = NULLP;
9304    PhysicalCellGroupConfig_t *phyCellGrpCfg = NULLP;
9305    SpCellConfig_t            *spcellCfg = NULLP;
9306    ServingCellConfig_t       *servCellCfg = NULLP;
9307
9308    if(cellGrp)
9309    {
9310       /* Fill MacCell Group Reconfig  */
9311       if(cellGrp->mac_CellGroupConfig)
9312       {
9313          macUeCfg->macCellGrpCfgPres = true;
9314          macCellGroup = ((MAC_CellGroupConfig_t *)(cellGrp->mac_CellGroupConfig));
9315          if(macCellGroup->schedulingRequestConfig)
9316          {
9317             extractSchReqReConfig(macCellGroup->schedulingRequestConfig, &macUeCfg->macCellGrpCfg.schReqCfg);
9318          }
9319          if(macCellGroup->tag_Config)
9320          {
9321             extractTagReconfig(macCellGroup->tag_Config, &macUeCfg->macCellGrpCfg.tagCfg);
9322          }
9323          if(macCellGroup->bsr_Config)
9324          {
9325             macUeCfg->macCellGrpCfg.bsrTmrCfg.periodicTimer = macCellGroup->bsr_Config->periodicBSR_Timer;
9326             macUeCfg->macCellGrpCfg.bsrTmrCfg.retxTimer     = macCellGroup->bsr_Config->retxBSR_Timer;
9327             if(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer)
9328             {
9329                macUeCfg->macCellGrpCfg.bsrTmrCfg.srDelayTimer  =\
9330                *(macCellGroup->bsr_Config->logicalChannelSR_DelayTimer);
9331             }
9332          }
9333          if(macCellGroup->phr_Config)
9334          {
9335             if(macCellGroup->phr_Config->present == MAC_CellGroupConfig__phr_Config_PR_setup)
9336             {
9337                macUeCfg->macCellGrpCfg.phrCfgSetupPres = true;
9338                if(macCellGroup->phr_Config->choice.setup)
9339                {
9340                   macUeCfg->macCellGrpCfg.phrCfg.periodicTimer     = \
9341                   macCellGroup->phr_Config->choice.setup->phr_PeriodicTimer;
9342                   macUeCfg->macCellGrpCfg.phrCfg.prohibitTimer     = \
9343                   macCellGroup->phr_Config->choice.setup->phr_ProhibitTimer;
9344                   macUeCfg->macCellGrpCfg.phrCfg.txPowerFactor     = \
9345                   macCellGroup->phr_Config->choice.setup->phr_Tx_PowerFactorChange;
9346                   macUeCfg->macCellGrpCfg.phrCfg.multiplePHR       = \
9347                   macCellGroup->phr_Config->choice.setup->multiplePHR;
9348                   macUeCfg->macCellGrpCfg.phrCfg.dummy             = \
9349                   macCellGroup->phr_Config->choice.setup->dummy;
9350                   macUeCfg->macCellGrpCfg.phrCfg.phrType2OtherCell = \
9351                   macCellGroup->phr_Config->choice.setup->phr_Type2OtherCell;
9352                   macUeCfg->macCellGrpCfg.phrCfg.phrOtherCG        = \
9353                   macCellGroup->phr_Config->choice.setup->phr_ModeOtherCG;
9354                }
9355             }
9356          }
9357       }
9358       /* Fill Physical Cell Group Reconfig */
9359       if(cellGrp->physicalCellGroupConfig)
9360       {
9361          macUeCfg->phyCellGrpCfgPres = true;
9362          phyCellGrpCfg = ((PhysicalCellGroupConfig_t *)(cellGrp->physicalCellGroupConfig));
9363          if(phyCellGrpCfg->p_NR_FR1)
9364          {
9365             if(*(phyCellGrpCfg->p_NR_FR1) != macUeCfg->phyCellGrpCfg.pNrFr1)
9366                macUeCfg->phyCellGrpCfg.pNrFr1 = *(phyCellGrpCfg->p_NR_FR1);
9367          }
9368          macUeCfg->phyCellGrpCfg.pdschHarqAckCodebook = phyCellGrpCfg->pdsch_HARQ_ACK_Codebook;
9369       }
9370       /* Fill SpCell Reconfig */
9371       if(cellGrp->spCellConfig)
9372       {
9373          macUeCfg->spCellCfgPres = true;
9374          spcellCfg = ((SpCellConfig_t *)(cellGrp->spCellConfig));
9375          if(spcellCfg->servCellIndex)
9376          {
9377             macUeCfg->spCellCfg.servCellIdx = *(spcellCfg->servCellIndex);
9378          }
9379          /* Fill Serving cell Reconfig info */
9380          if(cellGrp->spCellConfig->spCellConfigDedicated)
9381          {
9382             servCellCfg = ((ServingCellConfig_t *)(cellGrp->spCellConfig->spCellConfigDedicated));
9383             if(storedMacUeCfg)
9384             {
9385                if(!storedMacUeCfg->spCellCfgPres)
9386                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
9387                else
9388                   ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg,\
9389                         &storedMacUeCfg->spCellCfg.servCellCfg);
9390             }
9391             else
9392             {
9393                ret = extractSpCellDedicatedCfg(servCellCfg, &macUeCfg->spCellCfg.servCellCfg, NULL);
9394             }
9395             if(ret == RFAILED)
9396             {
9397                DU_LOG("\nERROR --> F1AP : Failed at extractSpCellDedicatedCfg()");
9398             }
9399          }
9400       }
9401    }
9402    return ret;
9403 }
9404 /*******************************************************************
9405 *
9406 * @brief free the memory allocated by decoder
9407 *
9408 * @details
9409 *
9410 *    Function : freeAperDecodeNrcgi
9411 *
9412 *    Functionality: Free Nrcgi values
9413 *
9414 * @params[in] NRCGI_t *nrcgi
9415 * @return void
9416 *
9417 * ****************************************************************/
9418
9419
9420 void freeAperDecodeNrcgi(NRCGI_t *nrcgi)
9421 {
9422     if(nrcgi->pLMN_Identity.buf != NULLP)
9423     {
9424        free(nrcgi->pLMN_Identity.buf);
9425     }
9426     if(nrcgi->nRCellIdentity.buf != NULLP)
9427     {
9428        free(nrcgi->nRCellIdentity.buf);
9429     }
9430 }
9431 /*******************************************************************
9432 *
9433 * @brief free the memory allocated by decoder
9434 *
9435 * @details
9436 *
9437 *    Function : freeAperDecodeCuToDuInfo
9438 *
9439 *    Functionality:  Free Cu To Du Information
9440 *
9441 * @params[in] CUtoDURRCInformation_t *rrcMsg
9442 * @return void
9443 *
9444 * ****************************************************************/
9445
9446
9447 void freeAperDecodeCuToDuInfo(CUtoDURRCInformation_t *rrcMsg)
9448 {
9449    uint8_t ieIdx =0;
9450    uint8_t arrIdx =0;
9451
9452    if(rrcMsg->uE_CapabilityRAT_ContainerList)
9453    {
9454       if(rrcMsg->uE_CapabilityRAT_ContainerList->buf)
9455          free(rrcMsg->uE_CapabilityRAT_ContainerList->buf);
9456       free(rrcMsg->uE_CapabilityRAT_ContainerList);
9457    }
9458
9459    if(rrcMsg->iE_Extensions)
9460    {
9461       if(rrcMsg->iE_Extensions->list.array)
9462       {
9463          for(ieIdx= 0; ieIdx < rrcMsg->iE_Extensions->list.count; ieIdx++)
9464          {
9465             if(rrcMsg->iE_Extensions->list.array[ieIdx])
9466             {
9467                switch(rrcMsg->iE_Extensions->list.array[ieIdx]->id)
9468                {
9469                   case ProtocolIE_ID_id_CellGroupConfig:
9470                      if(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf != NULLP)
9471                      {
9472                         free(rrcMsg->iE_Extensions->list.array[ieIdx]->extensionValue.choice.CellGroupConfig.buf);
9473                      }
9474                      break;
9475                   default:
9476                      DU_LOG("\nERROR  -->  F1AP : Invalid Event type %ld at FreeCuToDuInfo()", \
9477                            rrcMsg->iE_Extensions->list.array[ieIdx]->id);
9478                      break;
9479                }
9480             }
9481          }
9482          for(arrIdx = 0; arrIdx < ieIdx; arrIdx++)
9483          {
9484             free(rrcMsg->iE_Extensions->list.array[arrIdx]);
9485          }
9486          free(rrcMsg->iE_Extensions->list.array);
9487
9488       }
9489
9490       free(rrcMsg->iE_Extensions);
9491    }
9492 }
9493 /*******************************************************************
9494 *
9495 * @brief free the memory allocated by decoder
9496 *
9497 * @details
9498 *
9499 *    Function : freeAperDecodeSplCellList
9500 *
9501 *    Functionality: Free Spl Cell List
9502                     where memory allocated by aper_decoder
9503 *
9504 * @params[in]  SCell_ToBeSetup_List_t *spCellLst
9505 * @return void
9506 *
9507 * ****************************************************************/
9508
9509
9510 void freeAperDecodeSplCellList(SCell_ToBeSetup_List_t *spCellLst)
9511 {
9512     uint8_t  cellIdx =0;
9513
9514     if(spCellLst->list.array != NULLP)
9515     {
9516        for(cellIdx=0; cellIdx<spCellLst->list.count; cellIdx++)
9517        {
9518           if(cellIdx==0&&spCellLst->list.array[cellIdx]!=NULLP)
9519           {
9520              freeAperDecodeNrcgi(&spCellLst->list.array[cellIdx]->value.choice.SCell_ToBeSetup_Item.sCell_ID);
9521           }
9522           if(spCellLst->list.array[cellIdx]!=NULLP)
9523           {
9524              free(spCellLst->list.array[cellIdx]);
9525           }
9526        }
9527        free(spCellLst->list.array);
9528     }
9529 }
9530 /*******************************************************************
9531 *
9532 * @brief free the memory allocated by decoder
9533 *
9534 * @details
9535 *
9536 *    Function : freeAperDecodeSRBSetup
9537 *
9538 *    Functionality: added free part for the memory allocated by aper_decoder
9539 *
9540 * @params[in] SRBs_ToBeSetup_List_t *srbSet
9541 * @return void
9542 *
9543 ****************************************************************/
9544
9545
9546 void freeAperDecodeSRBSetup(SRBs_ToBeSetup_List_t *srbSet)
9547 {
9548     uint8_t srbIdx =0;
9549     if(srbSet->list.array != NULLP)
9550     {
9551        for(srbIdx=0; srbIdx<srbSet->list.count; srbIdx++)
9552        {
9553           if(srbSet->list.array[srbIdx]!=NULLP)
9554           {
9555              free(srbSet->list.array[srbIdx]);
9556           }
9557        }
9558        free(srbSet->list.array);
9559     }
9560 }
9561
9562 /*******************************************************************
9563 *
9564 * @brief free the memory allocated by decoder
9565 *
9566 * @details
9567 *
9568 *    Function : freeAperDecodeULTnlInfo
9569 *
9570 *    Functionality: added free part for the memory allocated by aper_decoder
9571 *
9572 * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
9573 * @return void
9574 *
9575 * ****************************************************************/
9576
9577
9578 void freeAperDecodeULTnlInfo(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
9579 {
9580    uint8_t ulIdx=0;
9581    if(ulInfo->list.array != NULLP)
9582    {
9583       for(ulIdx=0; ulIdx<ulInfo->list.count; ulIdx++)
9584       {
9585          if(ulIdx==0&&ulInfo->list.array[ulIdx]!=NULLP)
9586          {
9587             if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel!=NULLP)
9588             {
9589                if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9590                      transportLayerAddress.buf != NULLP)
9591                {
9592                   if(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf\
9593                         !=NULLP)
9594                   {
9595                      free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf);
9596                   }
9597                   free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel->\
9598                         transportLayerAddress.buf);
9599                }
9600                free(ulInfo->list.array[ulIdx]->uLUPTNLInformation.choice.gTPTunnel);
9601             }
9602          }
9603          if(ulInfo->list.array[ulIdx]!=NULLP)
9604          {
9605             free(ulInfo->list.array[ulIdx]);
9606          }
9607       }
9608       free(ulInfo->list.array);
9609    }
9610 }
9611 /*******************************************************************
9612 *
9613 * @brief free the memory allocated by decoder
9614 *
9615 * @details
9616 *
9617 *    Function : freeAperDecodeDRBSetup
9618 *
9619 *    Functionality: free DRBSetup which is allocated by decoder
9620 *
9621 * @params[in]  DRBs_ToBeSetup_List_t *drbSet
9622 * @return void
9623 *
9624 * ****************************************************************/
9625
9626 void freeAperDecodeDRBSetup(DRBs_ToBeSetup_List_t *drbSet)
9627 {
9628    DRBs_ToBeSetup_Item_t *drbSetItem = NULLP;
9629    uint8_t  flowIdx =0;
9630    uint8_t  drbIdx =0;
9631
9632    if(drbSet->list.array != NULLP)
9633    {
9634       for(drbIdx=0; drbIdx<drbSet->list.count; drbIdx++)
9635       {
9636          if(drbIdx==0&&drbSet->list.array[drbIdx] != NULLP)
9637          {
9638             drbSetItem =&drbSet->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
9639             if(drbSetItem->qoSInformation.choice.choice_extension != NULLP)
9640             {
9641                if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9642                      qoS_Characteristics.choice.non_Dynamic_5QI !=NULLP)
9643                {
9644                   if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9645                         qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9646                   {
9647                      if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9648                            qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9649                      {
9650
9651                         if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf!=NULLP)
9652                         {
9653
9654                            if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD!=NULLP)
9655                            {
9656
9657                               if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD->\
9658                                     buf!=NULLP)
9659                               {
9660
9661                                  if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.\
9662                                        flows_Mapped_To_DRB_List.list.array != NULLP)
9663                                  {
9664
9665                                     for(flowIdx=0;flowIdx<drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9666                                           DRB_Information.flows_Mapped_To_DRB_List.list.count; flowIdx++)
9667                                     {
9668
9669                                        if(flowIdx==0&&drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9670                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9671                                        {
9672                                           if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9673                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9674                                                 qoSFlowLevelQoSParameters.\
9675                                                 qoS_Characteristics.choice.non_Dynamic_5QI!=NULLP)
9676                                           {
9677                                              if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9678                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9679                                                    qoSFlowLevelQoSParameters.\
9680                                                    qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
9681                                              {
9682
9683                                                 if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9684                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9685                                                       qoSFlowLevelQoSParameters.\
9686                                                       qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
9687                                                 {
9688
9689
9690                                                    free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9691                                                          DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9692                                                          qoSFlowLevelQoSParameters.\
9693                                                          qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9694                                                 }
9695
9696                                                 free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9697                                                       DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9698                                                       qoSFlowLevelQoSParameters.\
9699                                                       qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9700                                              }
9701
9702                                              free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9703
9704                                                    DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]->\
9705                                                    qoSFlowLevelQoSParameters.\
9706                                                    qoS_Characteristics.choice.non_Dynamic_5QI);
9707                                           }
9708                                        }
9709                                        if(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9710                                              DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]!=NULLP)
9711                                        {
9712
9713                                           free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9714                                                 DRB_Information.flows_Mapped_To_DRB_List.list.array[flowIdx]);
9715                                        }
9716                                     }
9717
9718                                     free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9719                                           DRB_Information.flows_Mapped_To_DRB_List.list.array);
9720                                  }
9721
9722                                  free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.\
9723                                        DRB_Information.sNSSAI.sD->buf);
9724                               }
9725
9726                               free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sD);
9727                            }
9728
9729                            free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI.sST.buf);
9730
9731                         }
9732
9733                         free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9734
9735                               qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
9736                      }
9737
9738                      free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9739                            qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
9740                   }
9741
9742                   free(drbSetItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.dRB_QoS.\
9743                         qoS_Characteristics.choice.non_Dynamic_5QI);
9744                }
9745                free(drbSetItem->qoSInformation.choice.choice_extension);
9746             }
9747             freeAperDecodeULTnlInfo(&drbSetItem->uLUPTNLInformation_ToBeSetup_List);
9748             if(drbSetItem->uLConfiguration)
9749             {
9750                free(drbSetItem->uLConfiguration);
9751             }
9752          }
9753          if(drbSet->list.array[drbIdx]!=NULLP)
9754          {
9755             free(drbSet->list.array[drbIdx]);
9756          }
9757       }
9758       free(drbSet->list.array);
9759    }
9760 }
9761
9762
9763 /*******************************************************************
9764  *
9765  * @brief builds Mac Cell Cfg
9766  *
9767  * @details
9768  *
9769  *    Function : procUeReCfgCellInfo
9770  *
9771  *    Functionality: builds Mac Cell Cfg
9772  *
9773  * @params[in] MacUeCfg *macUeCfgToSend = Used to Store the information which
9774  *                       needs to send in other layer, as well as this can be
9775  *                       the variable which stores the information in DuCb.
9776  *             MacUeCfg *storedMacUeCfg = Null in case of sending the
9777  *                       information to other layer else it will have copyOfmacUeCfg
9778  *                       which we have stored in F1UeContextSetupDb
9779  *             void *cellInfo = CellGroupConfigRrc_t information which is send
9780  *                        by CU, which we have stored in F1UeContextSetupDb
9781  *
9782  * @return void
9783  *
9784  * ****************************************************************/
9785 uint8_t procUeReCfgCellInfo(MacUeCfg *macUeCfgToSend,MacUeCfg *storedMacUeCfg, void *cellInfo)
9786 {
9787    uint8_t ret = ROK;
9788    CellGroupConfigRrc_t *cellGrp = NULLP;
9789
9790    if(cellInfo)
9791    {
9792       cellGrp = (CellGroupConfigRrc_t *)cellInfo;
9793       ret = extractUeReCfgCellInfo(cellGrp, macUeCfgToSend, storedMacUeCfg);
9794       if(ret == RFAILED)
9795          DU_LOG("\nERROR  -->  F1AP : Failed at procUeReCfgCellInfo()");
9796    }
9797    if(ret == RFAILED)
9798    {
9799       freeUeReCfgCellGrpInfo(macUeCfgToSend);
9800    }
9801    return ret;
9802 }
9803
9804 /*******************************************************************
9805  *
9806  * @brief Filling modulation info in mac ue cfg
9807  *
9808  * @details
9809  *
9810  *    Function : duFillModulationDetails
9811  *
9812  *    Functionality: Filling modulation info in mac ue cfg
9813  *
9814  * @params[in] MAC UE Config to be updated
9815  *             Current UE configuration
9816  *             UE NR capability from CU
9817  * @return ROK     - success
9818  *         RFAILED - failure
9819  *
9820  * ****************************************************************/
9821 void duFillModulationDetails(MacUeCfg *ueCfg, MacUeCfg *oldUeCfg, void *ueCap)
9822 {
9823    UE_NR_Capability_t *ueNrCap=NULLP;
9824
9825    if(!ueCap)
9826    {
9827       memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9828       memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9829    }
9830    else
9831    {
9832       ueNrCap = (UE_NR_Capability_t *)ueCap;
9833
9834       /* Filling DL modulation info */
9835       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsDownlinkPerCC && \
9836          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0] && \
9837          ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL)
9838       {
9839          switch(*(ueNrCap->featureSets->featureSetsDownlinkPerCC->list.array[0]->supportedModulationOrderDL))
9840          {
9841             case ModulationOrder_qpsk:
9842                {
9843                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QPSK;
9844                   break;
9845                }
9846             case ModulationOrder_qam16:
9847                {
9848                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM16;
9849                   break;
9850                }
9851             case ModulationOrder_qam64:
9852                {
9853                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM64;
9854                   ueCfg->dlModInfo.mcsIndex = PDSCH_MCS_INDEX;
9855                   ueCfg->dlModInfo.mcsTable = MCS_TABLE_QAM64;
9856                   break;
9857                }
9858             case ModulationOrder_qam256:
9859                {
9860                   ueCfg->dlModInfo.modOrder = MOD_ORDER_QAM256;
9861                   break;
9862                }
9863             default:
9864                {
9865                   DU_LOG("\nERROR  -->  DU APP: Incorrect downlink modulation order received. Reatining old modulation configuration");
9866                   memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9867                   break;
9868                }
9869          }
9870       }
9871       else
9872       {
9873          memcpy(&ueCfg->dlModInfo, &oldUeCfg->dlModInfo, sizeof(ModulationInfo));
9874       }
9875
9876       /* Filling UL modulation info */
9877       if(ueNrCap->featureSets && ueNrCap->featureSets->featureSetsUplinkPerCC && \
9878          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0] && \
9879          ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL)
9880       {
9881          switch(*(ueNrCap->featureSets->featureSetsUplinkPerCC->list.array[0]->supportedModulationOrderUL))
9882          {
9883             case ModulationOrder_qpsk:
9884                {
9885                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QPSK;
9886                   break;
9887                }
9888             case ModulationOrder_qam16:
9889                {
9890                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM16;
9891                   ueCfg->ulModInfo.mcsIndex = PUSCH_MCS_INDEX;
9892                   ueCfg->ulModInfo.mcsTable = MCS_TABLE_QAM64;
9893                   break;
9894                }
9895             case ModulationOrder_qam64:
9896                {
9897                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM64;
9898                   break;
9899                }
9900             case ModulationOrder_qam256:
9901                {
9902                   ueCfg->ulModInfo.modOrder = MOD_ORDER_QAM256;
9903                   break;
9904                }
9905             default:
9906                {
9907                   DU_LOG("\nERROR  -->  DU APP: Incorrect uplink modulation order received. Reatining old modulation configuration");
9908                   memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9909                   break;
9910                }
9911          }
9912       }
9913       else
9914       {
9915          memcpy(&ueCfg->ulModInfo, &oldUeCfg->ulModInfo, sizeof(ModulationInfo));
9916       }
9917    }
9918 }
9919
9920 /*******************************************************************
9921  *
9922  * @brief Function to extract cellGrp Info present in cutoDu cont
9923  *
9924  * @details
9925  *
9926  *    Function : extractCellGrpInfo
9927  *
9928  *    Functionality: Function to extract cellGrp Info present
9929  *                   in cutoDu cont
9930  *
9931  * @params[in] ProtocolExtensionContainer_4624P16_t pointer
9932  *
9933  * @return CellGroupConfigRrc_t *
9934  *
9935  * ****************************************************************/
9936
9937 CellGroupConfigRrc_t *extractCellGrpInfo(ProtocolExtensionContainer_4624P16_t *protocolIeExtn,\
9938       DuUeCfg *ueCfgDb)
9939 {
9940    uint8_t idx2 =0;
9941    uint16_t id =0;
9942    uint16_t recvBufLen =0;
9943    CellGroupConfigRrc_t *cellGrpCfg = NULLP;
9944    CUtoDURRCInformation_ExtIEs_t *extIeInfo = NULLP;
9945    asn_dec_rval_t rval; /* Decoder return value */
9946    memset(&rval, 0, sizeof(asn_dec_rval_t));
9947
9948    if(protocolIeExtn)
9949    {
9950       for(idx2 = 0; idx2 < protocolIeExtn->list.count; idx2++)
9951       {
9952          extIeInfo = ((CUtoDURRCInformation_ExtIEs_t *)(protocolIeExtn->list.array[idx2]));
9953          id = extIeInfo->id;
9954          switch(id)
9955          {
9956             case ProtocolIE_ID_id_CellGroupConfig:
9957             {
9958                recvBufLen = extIeInfo->extensionValue.choice.CellGroupConfig.size;
9959                /* decoding the CellGroup Buf received */
9960                DU_ALLOC(cellGrpCfg, sizeof(CellGroupConfigRrc_t));
9961                if(cellGrpCfg)
9962                {
9963                   memset(cellGrpCfg, 0, sizeof(CellGroupConfigRrc_t));
9964                   rval = aper_decode(0, &asn_DEF_CellGroupConfigRrc, (void **)&cellGrpCfg,
9965                      extIeInfo->extensionValue.choice.CellGroupConfig.buf, recvBufLen, 0, 0);
9966                   if(rval.code == RC_FAIL || rval.code == RC_WMORE)
9967                   {
9968                      DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
9969                      return NULLP;
9970                   }
9971                   xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, cellGrpCfg);
9972                   if(extractRlcCfgToAddMod(cellGrpCfg->rlc_BearerToAddModList, ueCfgDb))
9973                      return NULLP;
9974                }
9975                break;
9976             }
9977             default:
9978                DU_LOG("\nERROR  -->  F1AP : Invalid IE received CUtoDURRCInformation:%d at decodeCellGrpCfg()", id);
9979                break;
9980          }
9981       }
9982    }
9983    return cellGrpCfg;
9984 }
9985
9986 /*******************************************************************
9987  *
9988  * @brief Fills Srb List received by CU
9989  *
9990  * @details
9991  *
9992  *    Function : procSrbListToSetup
9993  *
9994  *    Functionality: Fills Srb List received  by CU
9995  *
9996  * @params[in] SRBs_ToBeSetup_Item_t *cuSrbItem
9997  *             LcCfg pointer
9998  *             RlcBearerCfg pointer
9999  * @return void
10000  *
10001  * ****************************************************************/
10002 uint8_t procSrbListToSetup(SRBs_ToBeSetup_Item_t * srbItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd)
10003 {
10004    uint8_t ret = ROK;
10005
10006    /* Filling RLC INFO */
10007    procRlcLcCfg(srbItem->sRBID, srbItem->sRBID, RB_TYPE_SRB, RLC_AM, CONFIG_ADD, NULL, rlcLcToAdd);
10008
10009    /* Filling MAC INFO */
10010    ret = procMacLcCfg(srbItem->sRBID, RB_TYPE_SRB, CONFIG_ADD, NULL,NULL, NULL, NULL, macLcToAdd, NULL);
10011    if(ret == RFAILED)
10012    {
10013       DU_LOG("\nERROR  -->  F1AP : Failed at MAC LC Cfg in procSrbListToSetup()");
10014       return ret;
10015    }
10016    return ret;
10017 }
10018
10019
10020
10021 /*******************************************************************
10022  *
10023  * @brief extract Srb List received by CU
10024  *
10025  * @details
10026  *
10027  *    Function : extractSrbListToSetup
10028  *
10029  *    Functionality: extract Srb List received by CU
10030  *                   for both MAC and RLC
10031  *
10032  * @params[in] SRBs_ToBeSetup_Item_t pointer
10033  *             DuUeCfg pointer
10034  * @return ROK/RFAIED
10035  *
10036  * ****************************************************************/
10037
10038 uint8_t extractSrbListToSetup(SRBs_ToBeSetup_List_t *srbCfg, DuUeCfg *ueCfgDb)
10039 {
10040    uint8_t ret, srbIdx;
10041    SRBs_ToBeSetup_Item_t *srbItem = NULLP;
10042
10043    if(srbCfg)
10044    {
10045       for(srbIdx = 0; srbIdx < srbCfg->list.count; srbIdx++)
10046       {
10047          srbItem = &srbCfg->list.array[srbIdx]->value.choice.SRBs_ToBeSetup_Item;
10048          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
10049          {
10050             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in MAC");
10051             ret = RFAILED;
10052             break;
10053          }
10054          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
10055          {
10056             DU_LOG("\nERROR   -->  F1AP:  MAX LC Reached in RLC");
10057             ret = RFAILED;
10058             break;
10059          }
10060          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
10061          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
10062          ret = procSrbListToSetup(srbItem, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
10063             &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs]);
10064          ueCfgDb->numRlcLcs++;
10065          ueCfgDb->numMacLcs++;
10066          DU_LOG("\nDEBUG --> DUAPP: extractSrbListToSetup: SRBID: %d [RLC,MAC,NumDrb]:[%x,%x,%x]",\
10067                             srbItem->sRBID, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
10068          if(ret == RFAILED)
10069          {
10070             DU_LOG("\nERROR  -->  F1AP:  Failed at extractSrbListToSetup()");
10071             break;
10072          }
10073       }
10074    }
10075    else
10076       ret = RFAILED;
10077
10078    return ret;
10079 }
10080
10081 /*******************************************************************
10082  *
10083  * @brief Fills Drb List received by CU
10084  *
10085  * @details
10086  *
10087  *    Function : procDrbListToSetupMod
10088  *
10089  *    Functionality: Fills Drb List received by CU
10090  *                   for both MAC and RLC
10091  *
10092  * @params[in] SRBs_ToBeSetup_Item_t pointer
10093  *             LcCfg pointer,
10094  *             RlcBearerCfg pointer
10095  * @return void
10096  *
10097  * ****************************************************************/
10098
10099 uint8_t procDrbListToSetupMod(uint8_t lcId, DRBs_ToBeSetup_Item_t *drbItem,\
10100 DRBs_ToBeSetupMod_Item_t *drbSetupModItem, DRBs_ToBeModified_Item_t *drbModItem, LcCfg *macLcToAdd, RlcBearerCfg *rlcLcToAdd, UpTnlCfg *upTnlInfo)
10101 {
10102
10103    if(drbItem != NULLP)
10104    {
10105       /* Filling RLC INFO */
10106       procRlcLcCfg(drbItem->dRBID, lcId, RB_TYPE_DRB, drbItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd);
10107
10108       /* Filling MAC INFO */
10109       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, drbItem, NULL, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
10110       {
10111          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
10112          return RFAILED;
10113       }
10114    }
10115    else if(drbSetupModItem != NULLP)
10116    {
10117       procRlcLcCfg(drbSetupModItem->dRBID, lcId, RB_TYPE_DRB, drbSetupModItem->rLCMode, CONFIG_ADD, NULL, rlcLcToAdd);
10118
10119       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_ADD, NULL, drbSetupModItem, NULL, NULL, macLcToAdd, upTnlInfo) != ROK)
10120       {
10121          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
10122          return RFAILED;
10123       }
10124    }
10125    else if(drbModItem != NULLP)
10126    {
10127       /* Drb to Mod IEs doesnot have rlcMode to be modified
10128        * in ASN. Hence no change in RLC configurations */
10129       if(procMacLcCfg(lcId, RB_TYPE_DRB, CONFIG_MOD, NULL, NULL, drbModItem, NULL, macLcToAdd, upTnlInfo) != ROK)
10130       {
10131          DU_LOG("\nERROR  --> F1AP : Failed at RLC LC Cfg in procDrbListToSetupMod()");
10132          return RFAILED;
10133       }
10134    }
10135    return ROK;
10136 }
10137
10138 /*******************************************************************
10139  *
10140  * @brief extract Drb List received by CU
10141  *
10142  * @details
10143  *
10144  *    Function : extractDrbListToSetupMod
10145  *
10146  *    Functionality: extract Drb List received by CU
10147  *                   for both MAC and RLC
10148  *
10149  * @params[in] DRBs_ToBeSetup_Item_t pointer
10150  *             DuUeCfg pointer
10151  * @return ROK/RFAIED
10152  *
10153  * ****************************************************************/
10154
10155 uint8_t extractDrbListToSetupMod(DRBs_ToBeSetup_List_t *drbCfg, DRBs_ToBeSetupMod_List_t *drbSetupModCfg,\
10156  DRBs_ToBeModified_List_t *drbModCfg, uint8_t drbCount, DuUeCfg *ueCfgDb, uint32_t *drbBitMap)
10157 {
10158    uint8_t ret, drbIdx, lcId = 0;
10159    DRBs_ToBeSetup_Item_t *drbItem = NULLP;
10160    DRBs_ToBeSetupMod_ItemIEs_t *drbSetupModItem = NULLP;
10161    DRBs_ToBeModified_ItemIEs_t *drbModItem = NULLP;
10162
10163    ret = ROK;
10164    if(drbCount > 0)
10165    {
10166       for(drbIdx = 0; drbIdx < drbCount; drbIdx++)
10167       {
10168          if(ueCfgDb->numMacLcs > MAX_NUM_LC)
10169          {
10170             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in MAC at extractDrbListToSetupMod()");
10171             ret = RFAILED;
10172             break;
10173          }
10174          if(ueCfgDb->numRlcLcs > MAX_NUM_LC)
10175          {
10176             DU_LOG("\nERROR  -->  F1AP :  MAX LC Reached in RLC at extractDrbListToSetupMod()");
10177             ret = RFAILED;
10178             break;
10179          }
10180          memset(&ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], 0, sizeof(LcCfg));
10181          memset(&ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], 0, sizeof(RlcBearerCfg));
10182
10183          if(drbModCfg != NULLP)
10184          {
10185             drbModItem = (DRBs_ToBeModified_ItemIEs_t *) drbModCfg->list.array[drbIdx];
10186             lcId = fetchLcId(drbModItem->value.choice.DRBs_ToBeModified_Item.dRBID);
10187             if(lcId < MIN_DRB_LCID)
10188             {
10189                DU_LOG("\nERROR  --> F1AP : Failed fetching LCID %d in extractDrbListToSetupMod() for Modified List", lcId);
10190                break;
10191             }
10192             ret = procDrbListToSetupMod(lcId, NULL, NULL, &(drbModItem->value.choice.DRBs_ToBeModified_Item),\
10193             &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs],\
10194             &ueCfgDb->upTnlInfo[ueCfgDb->numDrb]);
10195             if(ret == RFAILED)
10196             {
10197                DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for Modified List");
10198                break;
10199             }
10200
10201          }
10202          else
10203          {
10204             lcId = getDrbLcId(drbBitMap);
10205             if(lcId == RFAILED)
10206             {
10207                DU_LOG("\nERROR  -->  F1AP :  InCorrect LCID extractDrbListToSetupMod()");
10208                ret = RFAILED;
10209                break;
10210             }
10211             if(drbCfg != NULL)
10212             {
10213                drbItem = &drbCfg->list.array[drbIdx]->value.choice.DRBs_ToBeSetup_Item;
10214                ret = procDrbListToSetupMod(lcId, drbItem, NULL, NULL, &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs],\
10215                      &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs], &ueCfgDb->upTnlInfo[ueCfgDb->numDrb]);
10216                if(ret == RFAILED)
10217                {
10218                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetup List");
10219                   break;
10220                }
10221             }
10222             else if(drbSetupModCfg != NULL)
10223             {
10224                drbSetupModItem = (DRBs_ToBeSetupMod_ItemIEs_t *) drbSetupModCfg->list.array[drbIdx];
10225                ret = procDrbListToSetupMod(lcId, NULL, &(drbSetupModItem->value.choice.DRBs_ToBeSetupMod_Item), NULL,\
10226                      &ueCfgDb->macLcCfg[ueCfgDb->numMacLcs], &ueCfgDb->rlcLcCfg[ueCfgDb->numRlcLcs],\
10227                      &ueCfgDb->upTnlInfo[ueCfgDb->numDrb]);
10228                if(ret == RFAILED)
10229                {
10230                   DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod() for DrbSetupMod List");
10231                   break;
10232                }
10233             }
10234             ueCfgDb->numRlcLcs++;
10235          }
10236          ueCfgDb->numMacLcs++;
10237          ueCfgDb->numDrb++;
10238
10239          DU_LOG("\nDEBUG --> DUAPP: extractDrbListToSetupMod:lcId:%x ,BitMap:%x, [RLC,MAC,NumDrb]:[%x,%x,%x]",\
10240                             lcId,*drbBitMap, ueCfgDb->numRlcLcs, ueCfgDb->numMacLcs,  ueCfgDb->numDrb);
10241          if(ret == RFAILED)
10242          {
10243             DU_LOG("\nERROR  --> F1AP : Failed at extractDrbListToSetupMod()");
10244             break;
10245          }
10246       }
10247    }
10248    else
10249       ret = RFAILED;
10250
10251    return ret;
10252 }
10253
10254 /*******************************************************************
10255  *
10256  * @brief Function to extract Dl RRC Msg received from CU
10257  *
10258  * @details
10259  *
10260  *    Function : extractDlRrcMsg
10261  *
10262  *    Functionality: Function to extract Dl RRC Msg received from CU
10263  *
10264  * @params[in] F1AP message
10265  * @return ROK     - success
10266  *         RFAILED - failure
10267  *
10268  * ****************************************************************/
10269
10270 uint8_t extractDlRrcMsg(uint32_t gnbDuUeF1apId, uint32_t gnbCuUeF1apId, \
10271    F1DlRrcMsg *dlRrcMsg, RRCContainer_t *rrcContainer)
10272 {
10273    uint8_t ret = ROK;
10274    dlRrcMsg->rrcMsgSize = rrcContainer->size;
10275    if(dlRrcMsg->rrcMsgSize > 0)
10276    {
10277       DU_ALLOC_SHRABL_BUF(dlRrcMsg->rrcMsgPdu, dlRrcMsg->rrcMsgSize);
10278       if(!dlRrcMsg->rrcMsgPdu)
10279       {
10280          DU_LOG("\nERROR  --> DU APP : Memory allocation failed for RRC Msg in extractDlRrcMsg()");
10281          ret = RFAILED;
10282       }
10283       else
10284       {
10285          dlRrcMsg->gnbDuUeF1apId = gnbDuUeF1apId;
10286          dlRrcMsg->gnbCuUeF1apId = gnbCuUeF1apId;
10287          dlRrcMsg->srbId = SRB1_LCID;
10288          memcpy(dlRrcMsg->rrcMsgPdu, rrcContainer->buf, dlRrcMsg->rrcMsgSize);
10289       }
10290    }
10291    return ret;
10292 }
10293
10294 /*******************************************************************
10295  *
10296  * @brief Extract UE capability info
10297  *
10298  * @details
10299  *
10300  *    Function : extractUeCapability
10301  *
10302  *    Functionality: Extract UE capability info and stores in ue Cb
10303  *
10304  * @params[in] Octet string of UE capability RAT container list
10305  * @return ROK     - success
10306  *         RFAILED - failure
10307  *
10308  * ****************************************************************/
10309 UE_NR_Capability_t *extractUeCapability(UE_CapabilityRAT_ContainerList_t *ueCapablityListBuf, DuUeCb *ueCb)
10310 {
10311    uint8_t  idx;
10312    uint16_t recvBufLen;
10313    asn_dec_rval_t rval;
10314    UE_NR_Capability_t  *ueNrCap = NULLP;
10315    UE_CapabilityRAT_ContainerListRRC_t  *ueCapRatContList = NULLP;
10316
10317    /* Decoding UE Capability RAT Container List */
10318    recvBufLen = ueCapablityListBuf->size;
10319    DU_ALLOC(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10320    if(!ueCapRatContList)
10321    {
10322       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
10323       return NULLP;
10324    }
10325    memset(ueCapRatContList, 0, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10326    memset(&rval, 0, sizeof(asn_dec_rval_t));
10327    rval = aper_decode(0, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, (void **)&ueCapRatContList,
10328           ueCapablityListBuf->buf, recvBufLen, 0, 0);
10329    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10330    {
10331       DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
10332       return NULLP;
10333    }
10334    xer_fprint(stdout, &asn_DEF_UE_CapabilityRAT_ContainerListRRC, ueCapRatContList);
10335
10336    /* Free encoded buffer after decoding */
10337
10338    for(idx = 0; idx < ueCapRatContList->list.count; idx++)
10339    {
10340       if(ueCapRatContList->list.array[idx]->rat_Type == RAT_Type_nr)
10341       {
10342          /* Decoding UE NR Capability */
10343           recvBufLen = ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.size;
10344           DU_ALLOC(ueNrCap, sizeof(UE_NR_Capability_t));
10345           if(!ueNrCap)
10346           {
10347              DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in extractUeCapability");
10348              DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10349              return NULLP;
10350           }
10351           memset(ueNrCap, 0, sizeof(UE_NR_Capability_t));
10352           memset(&rval, 0, sizeof(asn_dec_rval_t));
10353           rval = aper_decode(0, &asn_DEF_UE_NR_Capability, (void **)&ueNrCap,
10354                  ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf, recvBufLen, 0, 0);
10355           if(rval.code == RC_FAIL || rval.code == RC_WMORE)
10356           {
10357              DU_LOG("\nERROR  -->  F1AP : ASN decode failed at decodeCellGrpCfg()");
10358              return NULLP;
10359           }
10360           xer_fprint(stdout, &asn_DEF_UE_NR_Capability, ueNrCap);
10361
10362           /* Free encoded buffer after decoding */
10363           free(ueCapRatContList->list.array[idx]->ue_CapabilityRAT_Container.buf);
10364       }
10365       free(ueCapRatContList->list.array[idx]);
10366    }
10367
10368    /* Free Memory*/
10369    free(ueCapRatContList->list.array);
10370    DU_FREE(ueCapRatContList, sizeof(UE_CapabilityRAT_ContainerListRRC_t));
10371    return ueNrCap;
10372 }
10373
10374 /*******************************************************************
10375 *
10376 * @brief free UE context setup request from CU
10377 *
10378 * @details
10379 *
10380 *    Function : freeAperDecodeF1UeContextSetupReq
10381 *
10382 *    Functionality: freeing part for the memory allocated by aper_decoder
10383 *
10384 * @params[in] F1AP message
10385 * @return ROK     - success
10386 *         RFAILED - failure
10387 *
10388 * ****************************************************************/
10389 void freeAperDecodeF1UeContextSetupReq(UEContextSetupRequest_t   *ueSetReq)
10390 {
10391    uint8_t ieIdx = 0;
10392
10393    if(ueSetReq->protocolIEs.list.array != NULLP)
10394    {
10395       for(ieIdx = 0; ieIdx < ueSetReq->protocolIEs.list.count; ieIdx++)
10396       {
10397          if(ueSetReq->protocolIEs.list.array[ieIdx])
10398          {
10399             switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
10400             {
10401                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10402                   break;
10403                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10404                   break;
10405                case ProtocolIE_ID_id_SpCell_ID:
10406                   freeAperDecodeNrcgi(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.NRCGI);
10407                   break;
10408                case ProtocolIE_ID_id_ServCellIndex:
10409                   break;
10410                case ProtocolIE_ID_id_SpCellULConfigured:
10411                   break;
10412                case ProtocolIE_ID_id_CUtoDURRCInformation:
10413
10414                   freeAperDecodeCuToDuInfo(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation);
10415                   break;
10416                case ProtocolIE_ID_id_SCell_ToBeSetup_List:
10417
10418                   freeAperDecodeSplCellList(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SCell_ToBeSetup_List);
10419                   break;
10420                case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
10421
10422                   freeAperDecodeSRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List);
10423                   break;
10424                case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
10425
10426                   freeAperDecodeDRBSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List);
10427                   break;
10428                case ProtocolIE_ID_id_RRCContainer:
10429                   {
10430
10431                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf != NULLP)
10432                      {
10433
10434                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
10435                      }
10436                      break;
10437                   }
10438                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10439                   break;
10440                case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
10441                   {
10442                      if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf)
10443                      {
10444                         free(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf);
10445                      }
10446                      break;
10447                   }
10448                default:
10449                   DU_LOG("\nERROR  -->  F1AP: Invalid event type %ld " ,ueSetReq->protocolIEs.list.array[ieIdx]->id);
10450             }
10451             free(ueSetReq->protocolIEs.list.array[ieIdx]);
10452          }
10453       }
10454       free(ueSetReq->protocolIEs.list.array);
10455    }
10456 }
10457 /*******************************************************************
10458  *
10459  * @brief Process UE context setup request from CU
10460  *
10461  * @details
10462  *
10463  *    Function : procF1UeContextSetupReq
10464  *
10465  *    Functionality: Process UE context setup request from CU
10466  *
10467  * @params[in] F1AP message
10468  * @return ROK     - success
10469  *         RFAILED - failure
10470  *
10471  * ****************************************************************/
10472 uint8_t procF1UeContextSetupReq(F1AP_PDU_t *f1apMsg)
10473 {
10474    uint8_t  ret=0, ieIdx=0, ueIdx=0, cellIdx=0;
10475    bool ueCbFound = false;
10476    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0, bitRateSize=0;
10477    DuUeCb   *duUeCb = NULL;
10478    UEContextSetupRequest_t   *ueSetReq = NULL;
10479    DRBs_ToBeSetup_List_t *drbCfg = NULL;
10480
10481    ret = ROK;
10482
10483    ueSetReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextSetupRequest;
10484    for(ieIdx=0; (ieIdx < ueSetReq->protocolIEs.list.count && ret == ROK); ieIdx++)
10485    {
10486       switch(ueSetReq->protocolIEs.list.array[ieIdx]->id)
10487       {
10488          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10489             {
10490                gnbCuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
10491                break;
10492             }
10493          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10494             {
10495                gnbDuUeF1apId = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
10496                break;
10497             }
10498          case ProtocolIE_ID_id_ServCellIndex:
10499             {
10500                cellIdx = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.ServCellIndex;
10501                for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++)
10502                {
10503                   if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
10504                         (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
10505                   {
10506                      ueCbFound = true;
10507                      duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
10508                      DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
10509                      if(duUeCb->f1UeDb)
10510                      {
10511                         memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
10512                         duUeCb->f1UeDb->actionType = UE_CTXT_SETUP;
10513                         duUeCb->f1UeDb->cellIdx = cellIdx;
10514                      }
10515                      else
10516                      {
10517                         DU_LOG("\nERROR  -->  F1AP: Memory Alloc Failed at procF1UeContextSetupReq()");
10518                         ret = RFAILED;
10519                      }
10520                      break;
10521                   }
10522                   else
10523                      ueCbFound = false;
10524
10525                }
10526                if(!ueCbFound)
10527                {
10528                   DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
10529                   ret = RFAILED;
10530                }
10531                break;
10532             }
10533          case ProtocolIE_ID_id_SpCellULConfigured:
10534             /* Indicates whether the gNB-CU requests the gNB-DU to configure the uplink as no UL,
10535                UL, SUL or UL+SUL for the indicated cell for the UE */
10536             break;
10537          case ProtocolIE_ID_id_CUtoDURRCInformation:
10538             {
10539                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.uE_CapabilityRAT_ContainerList)
10540                {
10541                   duUeCb->f1UeDb->duUeCfg.ueNrCapability = \
10542                   extractUeCapability(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.\
10543                   uE_CapabilityRAT_ContainerList, duUeCb);
10544                }
10545                if(ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.CUtoDURRCInformation.iE_Extensions)
10546                {
10547                   duUeCb->f1UeDb->duUeCfg.cellGrpCfg = extractCellGrpInfo(ueSetReq->protocolIEs.list.array[ieIdx]->\
10548                         value.choice.CUtoDURRCInformation.iE_Extensions, &duUeCb->f1UeDb->duUeCfg);
10549                   if(!duUeCb->f1UeDb->duUeCfg.cellGrpCfg)
10550                   {
10551                      DU_LOG("\nERROR  -->  F1AP: Failed to extract cell Grp Info");
10552                      //TODO: Update the failure cause in ue context Setup Response
10553                      ret = RFAILED;
10554                   }
10555                }
10556                break;
10557             }
10558          case ProtocolIE_ID_id_SCell_ToBeSetup_List:
10559             {
10560                DU_LOG("\nINFO   -->  DU_APP: Received SCell_ToBeSetup_List but  Not processing the list");
10561                break;
10562             }
10563          case ProtocolIE_ID_id_SRBs_ToBeSetup_List:
10564             {
10565                if(extractSrbListToSetup(&ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.SRBs_ToBeSetup_List,\
10566                &duUeCb->f1UeDb->duUeCfg))
10567                {
10568                   DU_LOG("\nERROR  -->  DU APP : Failed at extractSrbListToSetup()");
10569                   //TODO: Update the failure cause in ue context Setup Response
10570                   ret = RFAILED;
10571                }
10572                break;
10573             }
10574          case ProtocolIE_ID_id_DRBs_ToBeSetup_List:
10575             {
10576                   drbCfg = &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.DRBs_ToBeSetup_List;
10577
10578                   if(extractDrbListToSetupMod(drbCfg, NULL, NULL, drbCfg->list.count, &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap))
10579                   {
10580                      DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod()");
10581                      //TODO: Update the failure cause in ue context Setup Response
10582                      ret = RFAILED;
10583                   }
10584                break;
10585             }
10586          case ProtocolIE_ID_id_RRCContainer:
10587             {
10588                /* Filling Dl RRC Msg Info */
10589                DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
10590                if(!duUeCb->f1UeDb->dlRrcMsg)
10591                {
10592                   DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for DL RRC Msg in procUeCtxtSetupReq()");
10593                   ret = RFAILED;
10594                }
10595                else
10596                {
10597                   duUeCb->f1UeDb->dlRrcMsgPres = true;
10598                   memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
10599                   ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
10600                         &ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer);
10601                }
10602                break;
10603             }
10604          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
10605             {
10606                if(duUeCb->f1UeDb->dlRrcMsg->rrcMsgPdu)
10607                {
10608                   duUeCb->f1UeDb->dlRrcMsg->deliveryStatRpt = true;
10609                }
10610                else
10611                {
10612                   DU_LOG("\nERROR  -->  Ignoring delivery report, since rrcContainer is not present");
10613                }
10614                break;
10615             }
10616          case ProtocolIE_ID_id_GNB_DU_UE_AMBR_UL:
10617             {
10618                /* MaximumBitRate Uplink */
10619                bitRateSize = ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.size;
10620                if(bitRateSize > 0)
10621                {
10622                   DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->duUeCfg.ambrCfg, bitRateSize);
10623                   if(!duUeCb->f1UeDb->duUeCfg.ambrCfg)
10624                   {
10625                      DU_LOG("\nERROR  -->  DU APP : Memory allocation failed for bitRate in procUeCtxtSetupReq");
10626                      ret = RFAILED;
10627                   }
10628                   else
10629                   {
10630                      memset(duUeCb->f1UeDb->duUeCfg.ambrCfg, 0, sizeof(AmbrCfg));
10631                      memcpy(&duUeCb->f1UeDb->duUeCfg.ambrCfg->ulBr,
10632                            ueSetReq->protocolIEs.list.array[ieIdx]->value.choice.BitRate.buf, bitRateSize);
10633                   }
10634                }
10635                else
10636                   ret = RFAILED;
10637                break;
10638             }
10639          default:
10640             {
10641                break;
10642             }
10643       }
10644    }
10645    if(ret == RFAILED)
10646    {
10647       /*TODO : Negative case*/
10648       // BuildAndSendUeContextSetupRsp(cellId,ueIdx);
10649       DU_LOG("\nERROR  -->  F1AP: Failed to process UE CNTXT SETUP REQ at procF1UeContextSetupReq()");
10650    }
10651    else
10652       ret = duProcUeContextSetupRequest(duUeCb);
10653
10654    freeAperDecodeF1UeContextSetupReq(ueSetReq);
10655    return ret;
10656
10657 }
10658 /*******************************************************************
10659  * @brief Free the memory allocated for Dl Tunnel Info
10660  *
10661  * @details
10662  *
10663  *    Function : freeDlTnlInfo
10664  *
10665  *    Functionality:
10666  *       Free the memory allocated for Dl Tunnel Info
10667  *
10668  * @params[in] DLUPTNLInformation_ToBeSetup_List_t *
10669  * @return void
10670  *
10671  * ****************************************************************/
10672
10673 void freeDlTnlInfo(DLUPTNLInformation_ToBeSetup_List_t *tnlInfo)
10674 {
10675    uint8_t arrIdx = 0;
10676
10677    if(tnlInfo)
10678    {
10679       for(arrIdx=0; arrIdx < tnlInfo->list.count; arrIdx++)
10680       {
10681          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf,\
10682                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.size);
10683          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf,\
10684                tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel->gTP_TEID.size);
10685          DU_FREE(tnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
10686          DU_FREE(tnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
10687       }
10688       DU_FREE(tnlInfo->list.array, tnlInfo->list.size);
10689    }
10690 }
10691
10692 /*******************************************************************
10693  * @brief Free the memory allocated for DRB setup List
10694  *
10695  * @details
10696  *
10697  *    Function : freeDrbSetupList
10698  *
10699  *    Functionality:
10700  *       Free the memory allocated for DRB setup list
10701  *
10702  * @params[in] DRBs_Setup_List_t *
10703  * @return void
10704  *
10705  * ****************************************************************/
10706 void freeDrbSetupList(DRBs_Setup_List_t *drbSetupList)
10707 {
10708    uint8_t arrIdx = 0;
10709    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
10710
10711    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
10712    {
10713       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
10714       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List);
10715       DU_FREE(drbSetupList->list.array[arrIdx],  sizeof(DRBs_Setup_Item_t));
10716    }
10717    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
10718 }
10719
10720 /*******************************************************************
10721  * @brief Free the memory allocated for UE Setup response
10722  *
10723  * @details
10724  *
10725  *    Function : FreeUeContextSetupRsp
10726  *
10727  *    Functionality:
10728  *       Free the memory allocated for UE Setup response
10729  *
10730  * @params[in] F1AP PDU for UE setup response
10731  * @return ROK     - success
10732  *         RFAILED - failure
10733  *
10734  * ****************************************************************/
10735 void FreeUeContextSetupRsp(F1AP_PDU_t *f1apMsg)
10736 {
10737    uint8_t idx;
10738    UEContextSetupResponse_t *ueSetRsp = NULLP;
10739
10740    if(f1apMsg)
10741    {
10742       if(f1apMsg->choice.successfulOutcome)
10743       {
10744          ueSetRsp = &f1apMsg->choice.successfulOutcome->value.choice.\
10745                     UEContextSetupResponse;
10746          if(ueSetRsp->protocolIEs.list.array)
10747          {
10748             for(idx = 0; idx < ueSetRsp->protocolIEs.list.count; idx++)
10749             {
10750                if(ueSetRsp->protocolIEs.list.array[idx])
10751                {
10752                   switch(ueSetRsp->protocolIEs.list.array[idx]->id)
10753                   {
10754                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
10755                         break;
10756                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
10757                         break;
10758                      case ProtocolIE_ID_id_DUtoCURRCInformation:
10759                         {
10760                            CellGroupConfig_t *cellGrpCfg = NULLP;
10761                            cellGrpCfg  = &ueSetRsp->protocolIEs.list.array[idx]->value.choice.\
10762                                          DUtoCURRCInformation.cellGroupConfig;
10763                            if(cellGrpCfg->buf != NULLP)
10764                            {
10765                               DU_FREE(cellGrpCfg->buf, cellGrpCfg->size);
10766                               cellGrpCfg = NULLP;
10767                            }
10768                            break;
10769                         }
10770                     case ProtocolIE_ID_id_DRBs_Setup_List:
10771                         {
10772                            freeDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List);
10773                            break;
10774                         }
10775                      default:
10776                         DU_LOG("\nERROR  -->  DUAPP: Invalid Id %ld at FreeUeContextSetupRsp()",\
10777                         ueSetRsp->protocolIEs.list.array[idx]->id);
10778                         break;
10779                   }
10780                   DU_FREE(ueSetRsp->protocolIEs.list.array[idx],\
10781                         sizeof(UEContextSetupResponseIEs_t));
10782                }
10783             }
10784             DU_FREE(ueSetRsp->protocolIEs.list.array, \
10785                   ueSetRsp->protocolIEs.list.size);
10786          }
10787          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
10788       }
10789       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
10790    }
10791 }
10792
10793 /*******************************************************************
10794  *
10795  * @brief Builds Ue context Setup Rsp DU To CU Info
10796  *
10797  * @details
10798  *
10799  *    Function : EncodeUeCntxtDuToCuInfo
10800  *
10801  *    Functionality: Builds Ue context Setup Rsp DU To CU Info
10802  *
10803  * @params[in] CellGroupConfig_t *, CellGroupConfigRrc_t *
10804  *
10805  * @return ROK     - success
10806  *         RFAILED - failure
10807  *
10808  ******************************************************************/
10809
10810 uint8_t EncodeUeCntxtDuToCuInfo(CellGroupConfig_t *duToCuCellGrp, CellGroupConfigRrc_t *duCellGrpCfg)
10811 {
10812    asn_enc_rval_t        encRetVal;
10813
10814    xer_fprint(stdout, &asn_DEF_CellGroupConfigRrc, duCellGrpCfg);
10815    memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
10816    encBufSize = 0;
10817    encRetVal = aper_encode(&asn_DEF_CellGroupConfigRrc, 0, duCellGrpCfg, PrepFinalEncBuf, encBuf);
10818    /* Encode results */
10819    if(encRetVal.encoded == ENCODE_FAIL)
10820    {
10821       DU_LOG( "\nERROR  -->  F1AP : Could not encode UeCntxtDuToCuInfo (at %s)\n",\
10822             encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
10823       return RFAILED;
10824    }
10825    else
10826    {
10827       DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UeCntxtDuToCuInfo\n");
10828       for(int i=0; i< encBufSize; i++)
10829       {
10830          printf("%x",encBuf[i]);
10831       }
10832    }
10833    duToCuCellGrp->size = encBufSize;
10834    DU_ALLOC(duToCuCellGrp->buf, duToCuCellGrp->size);
10835    if(!duToCuCellGrp->buf)
10836    {
10837       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in UeCntxtDuToCuInfo");
10838    }
10839    memcpy(duToCuCellGrp->buf, encBuf, duToCuCellGrp->size);
10840    return ROK;
10841 }
10842
10843 /*******************************************************************
10844  *
10845  * @brief Fills Dl Gtp tunnel Info
10846  *
10847  * @details
10848  *
10849  *    Function : fillGtpTunnelforDl
10850  *
10851  *    Functionality: Fills Dl Gtp tunnel Info
10852  *
10853  * @params[in]
10854  *
10855  * @return ROK     - success
10856  *         RFAILED - failure
10857  *
10858  * ****************************************************************/
10859
10860 uint8_t fillGtpTunnelforDl(GTPTunnel_t *gtpDl, GtpTnlCfg *gtpUeCfg)
10861 {
10862    uint8_t bufSize = 0;
10863
10864    gtpDl->transportLayerAddress.size    = 4*sizeof(uint8_t);
10865    DU_ALLOC(gtpDl->transportLayerAddress.buf, gtpDl->transportLayerAddress.size);
10866    if(gtpDl->transportLayerAddress.buf == NULLP)
10867    {
10868       return RFAILED;
10869    }
10870    memcpy(gtpDl->transportLayerAddress.buf, &gtpUeCfg->dlTnlAddress, gtpDl->transportLayerAddress.size);
10871
10872    /*GTP TEID*/
10873    gtpDl->gTP_TEID.size = 4 * sizeof(uint8_t);
10874    DU_ALLOC(gtpDl->gTP_TEID.buf, gtpDl->gTP_TEID.size);
10875    if(gtpDl->gTP_TEID.buf == NULLP)
10876    {
10877       return RFAILED;
10878    }
10879    bufSize = 3; /*forming an Octect String*/
10880    fillTeIdString(bufSize, gtpUeCfg->teId, gtpDl->gTP_TEID.buf);
10881
10882    return ROK;
10883 }
10884
10885 /*******************************************************************
10886  *
10887  * @brief Fills DL Tunnel Setup List
10888  *
10889  * @details
10890  *
10891  *    Function : fillDlTnlSetupList
10892  *
10893  *    Functionality: Fills the DL Tunnel Setup List
10894  *
10895  * @params[in]
10896  *
10897  * @return ROK     - success
10898  *         RFAILED - failure
10899  *
10900  * ****************************************************************/
10901
10902 uint8_t fillDlTnlSetupList(DLUPTNLInformation_ToBeSetup_List_t *dlTnlInfo, UpTnlCfg *tnlCfg)
10903 {
10904    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
10905
10906    eleCount = 1;
10907    dlTnlInfo->list.count = eleCount;
10908    dlTnlInfo->list.size = (eleCount * sizeof(DLUPTNLInformation_ToBeSetup_Item_t *));
10909
10910    /* Initialize the DL Tnl Setup List Members */
10911    DU_ALLOC(dlTnlInfo->list.array, dlTnlInfo->list.size);
10912    if(dlTnlInfo->list.array == NULLP)
10913    {
10914       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL Tnl Setup List in fillDlTnlSetupList()");
10915       ret = RFAILED;
10916    }
10917    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
10918    {
10919       DU_ALLOC(dlTnlInfo->list.array[arrIdx], sizeof(DLUPTNLInformation_ToBeSetup_Item_t));
10920       if(dlTnlInfo->list.array[arrIdx] == NULLP)
10921       {
10922          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDlTnlSetupList()", arrIdx);
10923          return RFAILED;
10924       }
10925       dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.present = UPTransportLayerInformation_PR_gTPTunnel;
10926       DU_ALLOC(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel, sizeof(GTPTunnel_t));
10927       if(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel == NULLP)
10928       {
10929          DU_LOG(" ERROR  -->  F1AP : Memory allocation for DL tunnel info in fillDlTnlSetupList()");
10930          return RFAILED;
10931       }
10932       ret = fillGtpTunnelforDl(dlTnlInfo->list.array[arrIdx]->dLUPTNLInformation.choice.gTPTunnel,\
10933                tnlCfg->tnlCfg1);
10934       if(ret != ROK)
10935          break;
10936    }
10937    return ret;
10938 }
10939
10940 /*******************************************************************
10941  *
10942  * @brief Fills the Drb Setup List for Ue Context Setup Response
10943  *
10944  * @details
10945  *
10946  *    Function : fillDrbSetupList
10947  *
10948  *    Functionality: Fills the Drb Setup List for Ue Context Setup Response
10949  *
10950  * @params[in]
10951  *
10952  * @return ROK     - success
10953  *         RFAILED - failure
10954  *
10955  * ****************************************************************/
10956 uint8_t fillDrbSetupList(DRBs_Setup_List_t *drbSetupList, DuUeCfg *ueCfg)
10957 {
10958    uint8_t ret = ROK, arrIdx = 0, eleCount = 0;
10959    DRBs_Setup_ItemIEs_t *drbItemIe = NULLP;
10960
10961    eleCount = ueCfg->numDrb;
10962    drbSetupList->list.count = eleCount;
10963    drbSetupList->list.size = \
10964         (eleCount * sizeof(DRBs_Setup_Item_t *));
10965
10966    /* Initialize the Drb Setup List Members */
10967    DU_ALLOC(drbSetupList->list.array, drbSetupList->list.size);
10968    if(drbSetupList->list.array == NULLP)
10969    {
10970       DU_LOG(" ERROR  -->  F1AP : Memory allocation for DRB Setup List in fillDrbSetupList()");
10971       ret = RFAILED;
10972    }
10973
10974    for(arrIdx=0; arrIdx < eleCount; arrIdx++)
10975    {
10976       DU_ALLOC(drbSetupList->list.array[arrIdx], sizeof(DRBs_Setup_Item_t));
10977       if(drbSetupList->list.array[arrIdx] == NULLP)
10978       {
10979          DU_LOG(" ERROR  -->  F1AP : Memory allocation for arrIdx [%d] failed in fillDrbSetupList()", arrIdx);
10980          return RFAILED;
10981       }
10982       drbItemIe = ((DRBs_Setup_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
10983       drbItemIe->id = ProtocolIE_ID_id_DRBs_Setup_Item;
10984       drbItemIe->criticality = Criticality_reject;
10985       drbItemIe->value.present = DRBs_Setup_ItemIEs__value_PR_DRBs_Setup_Item;
10986       drbItemIe->value.choice.DRBs_Setup_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
10987       ret = fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_Setup_Item.dLUPTNLInformation_ToBeSetup_List,\
10988           &ueCfg->upTnlInfo[arrIdx]);
10989       if(ret != ROK)
10990          break;
10991    }
10992    return ret;
10993 }
10994
10995 /*******************************************************************
10996  *
10997  * @brief Builds and sends the UE Setup Response
10998  *
10999  * @details
11000  *
11001  *    Function : BuildAndSendUeContextSetupRsp
11002  *
11003  *    Functionality: Constructs the UE Setup Response and sends
11004  *                   it to the DU through SCTP.
11005  *
11006  * @params[in] uint8_t cellId,uint8_t ueIdx
11007  *
11008  * @return ROK     - success
11009  *         RFAILED - failure
11010  *
11011  * ****************************************************************/
11012 uint8_t BuildAndSendUeContextSetupRsp(uint8_t cellId,uint8_t ueIdx)
11013 {
11014    uint8_t   idx, ret, cellIdx, elementCnt;
11015    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
11016    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
11017    asn_enc_rval_t  encRetVal;        /* Encoder return value */
11018    F1AP_PDU_t               *f1apMsg = NULLP;
11019    UEContextSetupResponse_t *ueSetRsp = NULLP;
11020    CellGroupConfigRrc_t     *cellGrpCfg = NULLP;
11021    DuUeCb                   *ueCb = NULLP;
11022
11023    DU_LOG("\n INFO   -->  F1AP : Building UE Context Setup Response for cellId %d, ueIdx %d\n", cellId, ueIdx);
11024
11025    while(true)
11026    {
11027       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11028       if(f1apMsg == NULLP)
11029       {
11030          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11031          ret = RFAILED;
11032          break;
11033       }
11034
11035       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
11036       DU_ALLOC(f1apMsg->choice.successfulOutcome,
11037             sizeof(SuccessfulOutcome_t));
11038       if(f1apMsg->choice.successfulOutcome == NULLP)
11039       {
11040          DU_LOG(" ERROR  -->  F1AP : Memory allocation for      F1AP-PDU failed");
11041          ret = RFAILED;
11042          break;
11043       }
11044
11045       f1apMsg->choice.successfulOutcome->procedureCode = \
11046                                                          ProcedureCode_id_UEContextSetup;
11047       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
11048       f1apMsg->choice.successfulOutcome->value.present = \
11049                                                          SuccessfulOutcome__value_PR_UEContextSetupResponse;
11050
11051       ueSetRsp =
11052          &f1apMsg->choice.successfulOutcome->value.choice.UEContextSetupResponse;
11053       elementCnt = 4;
11054       ueSetRsp->protocolIEs.list.count = elementCnt;
11055       ueSetRsp->protocolIEs.list.size = \
11056                                         elementCnt * sizeof(UEContextSetupResponse_t *);
11057
11058       /* Initialize the UESetup members */
11059       DU_ALLOC(ueSetRsp->protocolIEs.list.array, \
11060             ueSetRsp->protocolIEs.list.size);
11061       if(ueSetRsp->protocolIEs.list.array == NULLP)
11062       {
11063          DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
11064          ret = RFAILED;
11065          break;
11066       }
11067
11068       for(idx=0; idx<elementCnt; idx++)
11069       {
11070          DU_ALLOC(ueSetRsp->protocolIEs.list.array[idx],\
11071                sizeof(UEContextSetupResponseIEs_t));
11072          if(ueSetRsp->protocolIEs.list.array[idx] == NULLP)
11073          {
11074             DU_LOG(" ERROR  -->  F1AP : Memory allocation for UE Setup Response failed");
11075             ret = RFAILED;
11076             break;
11077          }
11078       }
11079       /* Fetching Ue Cb Info*/
11080       GET_CELL_IDX(cellId, cellIdx);
11081       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
11082       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
11083       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
11084
11085       idx = 0;
11086       /*GNB CU UE F1AP ID*/
11087       ueSetRsp->protocolIEs.list.array[idx]->id = \
11088                                                   ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11089       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11090       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
11091                                                              UEContextSetupResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
11092       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
11093
11094       /*GNB DU UE F1AP ID*/
11095       idx++;
11096       ueSetRsp->protocolIEs.list.array[idx]->id = \
11097                                                   ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11098       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11099       ueSetRsp->protocolIEs.list.array[idx]->value.present = \
11100                                                              UEContextSetupResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
11101       ueSetRsp->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
11102
11103
11104       /*DUtoCURRC Information */
11105       idx++;
11106       ueSetRsp->protocolIEs.list.array[idx]->id  = \
11107                                                    ProtocolIE_ID_id_DUtoCURRCInformation;
11108       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11109       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
11110                                                             UEContextSetupResponseIEs__value_PR_DUtoCURRCInformation;
11111       if(ueCb->f1UeDb)
11112       {
11113          if(ueCb->f1UeDb->duUeCfg.cellGrpCfg)
11114          {
11115             cellGrpCfg = (CellGroupConfigRrc_t*)ueCb->f1UeDb->duUeCfg.cellGrpCfg;
11116             ret = EncodeUeCntxtDuToCuInfo(&ueSetRsp->protocolIEs.list.array[idx]->value.\
11117                      choice.DUtoCURRCInformation.cellGroupConfig, cellGrpCfg);
11118             if(ret == RFAILED)
11119             {
11120                DU_LOG("\nERROR  -->  F1AP : Failed to EncodeUeCntxtDuToCuInfo in BuildAndSendUeContextSetupRsp()");
11121                freeF1UeDb(ueCb->f1UeDb);
11122                ueCb->f1UeDb = NULLP;
11123                break;
11124             }
11125          }
11126       }
11127       else
11128       {
11129          DU_LOG("\nERROR  -->  F1AP : Failed to form DUtoCU RRCInfo at BuildAndSendUeContextSetupRsp()");
11130          ret = RFAILED;
11131          break;
11132       }
11133
11134       /* Drb Setup List */
11135       idx++;
11136       ueSetRsp->protocolIEs.list.array[idx]->id  = \
11137                                  ProtocolIE_ID_id_DRBs_Setup_List;
11138       ueSetRsp->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11139       ueSetRsp->protocolIEs.list.array[idx]->value.present =\
11140                                  UEContextSetupResponseIEs__value_PR_DRBs_Setup_List;
11141       ret = fillDrbSetupList(&ueSetRsp->protocolIEs.list.array[idx]->value.choice.DRBs_Setup_List,\
11142                &ueCb->f1UeDb->duUeCfg);
11143       if(ret == RFAILED)
11144       {
11145          DU_LOG("\nERROR  -->  F1AP : Failed to fillDrbSetupList in BuildAndSendUeContextSetupRsp()");
11146          freeF1UeDb(ueCb->f1UeDb);
11147          ueCb->f1UeDb = NULLP;
11148          break;
11149       }
11150
11151        /* Free UeContext Db created during Ue context Req */
11152        freeF1UeDb(ueCb->f1UeDb);
11153        ueCb->f1UeDb = NULLP;
11154
11155       /* TODO: To send Drb list */
11156       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11157
11158       /* Encode the UE context setup response type as APER */
11159       memset((uint8_t *)encBuf, 0, ENC_BUF_MAX_LEN);
11160       encBufSize = 0;
11161       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11162             encBuf);
11163       /* Encode results */
11164       if(encRetVal.encoded == ENCODE_FAIL)
11165       {
11166          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Response structure (at %s)\n",\
11167                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11168          ret = RFAILED;
11169          break;
11170       }
11171       else
11172       {
11173          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Setup Response\n");
11174          for(int i=0; i< encBufSize; i++)
11175          {
11176             printf("%x",encBuf[i]);
11177          }
11178       }
11179
11180       /* Sending  msg  */
11181       if(sendF1APMsg()  != ROK)
11182       {
11183          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Response failed");
11184          ret = RFAILED;
11185          break;
11186       }
11187       break;
11188    }
11189    FreeUeContextSetupRsp(f1apMsg);
11190    return ret;
11191 }/* End of BuildAndSendUeContextSetupRsp */
11192 /*******************************************************************
11193 *
11194 * @brief  Build And Send Ue Context Rsp
11195 *
11196 * @details
11197 *
11198 *    Function : BuildAndSendUeCtxtRsp
11199 *
11200 *    Functionality : Build And Send Ue Context Rsp
11201
11202 * @params[in]
11203 * @return sucess = ROK
11204 *         failure = RFAILED
11205 *
11206 * ****************************************************************/
11207 uint8_t BuildAndSendUeCtxtRsp(uint8_t cellId, uint8_t ueIdx)
11208 {
11209    uint8_t cellIdx = 0, actionType = 0;
11210
11211    GET_CELL_IDX(cellId, cellIdx);
11212    actionType = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].f1UeDb->actionType;
11213
11214    switch(actionType)
11215    {
11216       case UE_CTXT_SETUP:
11217          {
11218             BuildAndSendUeContextSetupRsp(cellId,ueIdx);
11219             break;
11220          }
11221       case UE_CTXT_MOD:
11222          {
11223             BuildAndSendUeContextModRsp(cellId, ueIdx);
11224             break;
11225          }
11226       default:
11227          DU_LOG("ERROR  -->  F1AP: Invalid Action Type %d at BuildAndSendUeCtxtRsp()", actionType);
11228          break;
11229
11230    }
11231    return ROK;
11232 }
11233
11234 /*******************************************************************
11235  *
11236  * @brief deallocating the memory of  F1reset msg
11237  *
11238  * @details
11239  *
11240  *    Function : FreeF1ResetReq
11241  *
11242  *    Functionality :
11243  *         - freeing memory of F1reset request msg
11244  *
11245  * @params[in]
11246  * @return void
11247  *
11248  *
11249  * ****************************************************************/
11250 void FreeF1ResetReq(F1AP_PDU_t *f1apMsg)
11251 {
11252    uint8_t idx =0 ;
11253    Reset_t *f1ResetMsg;
11254
11255    if(f1apMsg)
11256    {
11257       if(f1apMsg->choice.initiatingMessage)
11258       {
11259          f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11260
11261          if(f1ResetMsg->protocolIEs.list.array)
11262          {
11263             for(idx=0 ;idx < f1ResetMsg->protocolIEs.list.count ; idx++)
11264             {
11265                if(f1ResetMsg->protocolIEs.list.array[idx])
11266                {
11267                   DU_FREE(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
11268                }
11269             }
11270             DU_FREE(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
11271          }
11272          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11273       }
11274       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11275    }
11276 }
11277 /*******************************************************************
11278  *
11279  * @brief Build and Send F1reset request
11280  *
11281  * @details
11282  *
11283  *    Function : BuildAndSendF1ResetReq
11284  *
11285  *    Functionality:
11286  *         - Build and Send F1reset request msg
11287  *
11288  * @params[in]
11289  * @return ROK     - success
11290  *         RFAILED - failure
11291  *
11292  * ****************************************************************/
11293 uint8_t BuildAndSendF1ResetReq()
11294 {
11295    uint8_t          elementCnt=0;
11296    uint8_t          idx=0;
11297    uint8_t          ret= RFAILED;
11298    Reset_t          *f1ResetMsg = NULLP;
11299    F1AP_PDU_t       *f1apMsg = NULLP;
11300    asn_enc_rval_t   encRetVal;
11301    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset request \n");
11302    do
11303    {
11304       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11305       if(f1apMsg == NULLP)
11306       {
11307          break;
11308       }
11309       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
11310       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
11311       if(f1apMsg->choice.initiatingMessage == NULLP)
11312       {
11313          break;
11314       }
11315       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_Reset;
11316       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
11317       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_Reset;
11318
11319       f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11320
11321       elementCnt = 3;
11322       f1ResetMsg->protocolIEs.list.count = elementCnt;
11323       f1ResetMsg->protocolIEs.list.size = elementCnt * sizeof(ResetIEs_t *);
11324
11325       /* Initialize the F1Setup members */
11326       DU_ALLOC(f1ResetMsg->protocolIEs.list.array,f1ResetMsg->protocolIEs.list.size);
11327       if(f1ResetMsg->protocolIEs.list.array == NULLP)
11328       {
11329          break;
11330       }
11331       for(idx=0; idx<elementCnt; idx++)
11332       {
11333          DU_ALLOC(f1ResetMsg->protocolIEs.list.array[idx],sizeof(ResetIEs_t));
11334          if(f1ResetMsg->protocolIEs.list.array[idx] == NULLP)
11335          {
11336             break;
11337          }
11338       }
11339
11340       /*TransactionID*/
11341       idx=0;
11342       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
11343       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11344       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_TransactionID;
11345       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.TransactionID = 1;
11346
11347       /*Cause*/
11348       idx++;
11349       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_Cause;
11350       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_ignore;
11351       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_Cause;
11352       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.present = Cause_PR_radioNetwork;
11353       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.Cause.choice.radioNetwork = CauseRadioNetwork_action_desirable_for_radio_reasons;
11354
11355       /*Reset Type*/
11356       idx++;
11357       f1ResetMsg->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_ResetType;
11358       f1ResetMsg->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11359       f1ResetMsg->protocolIEs.list.array[idx]->value.present = ResetIEs__value_PR_ResetType;
11360       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.present = ResetType_PR_f1_Interface;
11361       f1ResetMsg->protocolIEs.list.array[idx]->value.choice.ResetType.choice.f1_Interface = ResetAll_reset_all;
11362
11363       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11364
11365       /* Encode the F1SetupRequest type as APER */
11366       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11367       encBufSize = 0;
11368       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11369             encBuf);
11370
11371       /* Encode results */
11372       if(encRetVal.encoded == ENCODE_FAIL)
11373       {
11374          DU_LOG("\nERROR  -->  F1AP : Could not encode F1Reset structure (at %s)\n",\
11375                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11376          break;
11377       }
11378       else
11379       {
11380          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for F1Reset\n");
11381          for(idx=0; idx< encBufSize; idx++)
11382          {
11383             printf("%x",encBuf[idx]);
11384          }
11385       }
11386
11387       if(sendF1APMsg() != ROK)
11388       {
11389          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset request failed");
11390          break;
11391       }
11392
11393       ret = ROK;
11394       break;
11395    }while(true);
11396
11397    FreeF1ResetReq(f1apMsg);
11398    return ret;
11399 }
11400 /*******************************************************************
11401  *
11402  * @brief Build And Send F1ResetAck
11403  *
11404  * @details
11405  *
11406  *    Function : BuildAndSendF1ResetAck
11407  *
11408  *    Functionality:
11409  *         - Build And Send  F1ResetRSP
11410  *
11411  * @return ROK     - success
11412  *         RFAILED - failure
11413  *
11414  * ****************************************************************/
11415 void FreeF1ResetAck(F1AP_PDU_t *f1apMsg)
11416 {
11417    uint8_t idx;
11418    ResetAcknowledge_t *f1ResetAck;
11419
11420    if(f1apMsg)
11421    {
11422       if(f1apMsg->choice.successfulOutcome)
11423       {
11424          f1ResetAck= &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
11425
11426          if(f1ResetAck->protocolIEs.list.array)
11427          {
11428             for(idx=0; idx<f1ResetAck->protocolIEs.list.count ; idx++)
11429             {
11430                if(f1ResetAck->protocolIEs.list.array[idx])
11431                {
11432                   DU_FREE(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
11433                }
11434             }
11435             DU_FREE(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
11436          }
11437          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11438       }
11439       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
11440    }
11441 }
11442
11443 /*******************************************************************
11444  *
11445  * @brief Build And Send F1ResetAck
11446  *
11447  * @details
11448  *
11449  *    Function : BuildAndSendF1ResetAck
11450  *
11451  *    Functionality:
11452  *         - Build And Send  F1ResetRSP
11453  *
11454  *  @params[in]
11455  * @return ROK     - success
11456  *         RFAILED - failure
11457  *
11458  * ****************************************************************/
11459 uint8_t BuildAndSendF1ResetAck()
11460 {
11461    uint8_t                idx = 0;
11462    uint8_t                elementCnt = 0;
11463    uint8_t                ret = RFAILED;
11464    F1AP_PDU_t             *f1apMsg = NULL;
11465    ResetAcknowledge_t     *f1ResetAck = NULLP;
11466    asn_enc_rval_t         encRetVal;
11467    DU_LOG("\nINFO   -->  F1AP : Building F1 Reset Acknowledgment \n");
11468
11469    do{
11470       /* Allocate the memory for F1ResetRequest_t */
11471       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11472       if(f1apMsg == NULLP)
11473       {
11474          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11475          break;
11476       }
11477
11478       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
11479
11480       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
11481       if(f1apMsg->choice.successfulOutcome == NULLP)
11482       {
11483          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11484          break;
11485       }
11486       f1apMsg->choice.successfulOutcome->criticality   = Criticality_reject;
11487       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_ResetAcknowledge;
11488       f1ResetAck = &f1apMsg->choice.successfulOutcome->value.choice.ResetAcknowledge;
11489
11490       elementCnt = 1;
11491
11492       f1ResetAck->protocolIEs.list.count = elementCnt;
11493       f1ResetAck->protocolIEs.list.size = elementCnt*sizeof(ResetAcknowledgeIEs_t *);
11494
11495       DU_ALLOC(f1ResetAck->protocolIEs.list.array, f1ResetAck->protocolIEs.list.size );
11496       if(f1ResetAck->protocolIEs.list.array == NULLP)
11497       {
11498          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1ResetAckIEs failed");
11499          break;
11500       }
11501
11502       for(idx=0; idx<elementCnt; idx++)
11503       {
11504          DU_ALLOC(f1ResetAck->protocolIEs.list.array[idx], sizeof(ResetAcknowledgeIEs_t));
11505          if(f1ResetAck->protocolIEs.list.array[idx] == NULLP)
11506          {
11507             break;
11508          }
11509       }
11510       /*TransactionID*/
11511       idx = 0;
11512       f1ResetAck->protocolIEs.list.array[idx]->id = ProtocolIE_ID_id_TransactionID;
11513       f1ResetAck->protocolIEs.list.array[idx]->criticality = Criticality_reject;
11514       f1ResetAck->protocolIEs.list.array[idx]->value.present = ResetAcknowledgeIEs__value_PR_TransactionID;
11515       f1ResetAck->protocolIEs.list.array[idx]->value.choice.TransactionID = TRANS_ID;
11516
11517       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11518
11519       /* Encode the F1SetupRequest type as UPER */
11520       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11521       encBufSize = 0;
11522       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
11523
11524       /* Check encode results */
11525       if(encRetVal.encoded == ENCODE_FAIL)
11526       {
11527          DU_LOG("\nERROR  -->  F1AP : Could not encode F1ResetAck structure (at %s)\n",\
11528                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11529          break;
11530       }
11531       else
11532       {
11533          DU_LOG("\nDUBUG   -->  F1AP : Created APER encoded buffer for F1ResetAck\n");
11534          for(int i=0; i< encBufSize; i++)
11535          {
11536             printf("%x",encBuf[i]);
11537          }
11538       }
11539       /* Sending msg */
11540       if(sendF1APMsg() != ROK)
11541       {
11542          DU_LOG("\nERROR  -->  F1AP : Sending F1 Reset Acknowledgement failed");
11543          break;
11544       }
11545
11546       ret = ROK;
11547       break;
11548    }while(true);
11549
11550    FreeF1ResetAck(f1apMsg);
11551    return ret;
11552 }
11553 /******************************************************************
11554 *
11555 * @brief free F1 reset msg allocated by aper_decoder
11556 *
11557 * @details
11558 *
11559 *    Function : freeAperDecodeF1ResetMsg
11560 *
11561 *    Functionality: free F1 reset msg allocated by aper_decoder
11562 *
11563 * @params[in] Reset_t *f1ResetMsg
11564 * @return void
11565 *
11566 * ****************************************************************/
11567
11568 void freeAperDecodeF1ResetMsg(Reset_t *f1ResetMsg)
11569 {
11570    uint8_t ieIdx =0;
11571    if(f1ResetMsg->protocolIEs.list.array)
11572    {
11573       for(ieIdx=0 ;ieIdx < f1ResetMsg->protocolIEs.list.count ; ieIdx++)
11574       {
11575          if(f1ResetMsg->protocolIEs.list.array[ieIdx])
11576          {
11577             free(f1ResetMsg->protocolIEs.list.array[ieIdx]);
11578          }
11579       }
11580       free(f1ResetMsg->protocolIEs.list.array);
11581    }
11582 }
11583
11584 /******************************************************************
11585  *
11586  * @brief Processes DL RRC Message Transfer  sent by CU
11587  *
11588  * @details
11589  *
11590  *    Function : procF1ResetReq
11591  *
11592  *    Functionality: Processes DL RRC Message Transfer sent by CU
11593  *
11594  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11595  * @return ROK     - success
11596  *         RFAILED - failure
11597  *
11598  * ****************************************************************/
11599 uint8_t procF1ResetReq(F1AP_PDU_t *f1apMsg)
11600 {
11601    /* we are currently not supporting Ue release. right now we are supporting only init case of fireset */
11602    uint8_t       ieIdx = 0;
11603    uint8_t        ret = ROK;
11604    Reset_t       *f1ResetMsg = NULLP;
11605
11606    DU_LOG("\nINFO   -->  Processing F1 reset request");
11607    f1ResetMsg = &f1apMsg->choice.initiatingMessage->value.choice.Reset;
11608
11609    for(ieIdx=0; ieIdx<f1ResetMsg->protocolIEs.list.count; ieIdx++)
11610    {
11611       switch(f1ResetMsg->protocolIEs.list.array[ieIdx]->id)
11612       {
11613          case ProtocolIE_ID_id_TransactionID:
11614             break;
11615
11616          case ProtocolIE_ID_id_Cause:
11617             break;
11618
11619          case ProtocolIE_ID_id_ResetType:
11620             {
11621                break;
11622             }
11623
11624          default:
11625             break;
11626       }
11627    }
11628    ret = BuildAndSendF1ResetAck();
11629    DU_LOG("\nINFO   -->  UE release is not supported for now");
11630
11631    freeAperDecodeF1ResetMsg(f1ResetMsg);
11632
11633    return ret;
11634 }
11635
11636 /*******************************************************************
11637  *
11638  * @brief free the RRC delivery report
11639  *
11640  * @details
11641  *
11642  *    Function : freeRrcDeliveryReport
11643  *
11644  *    Functionality: free the RRC delivery report
11645  *
11646  * @params[in]
11647  * @return ROK     - success
11648  *         RFAILED - failure
11649  *
11650  * ****************************************************************/
11651 void freeRrcDeliveryReport(F1AP_PDU_t  *f1apMsg )
11652 {
11653    uint8_t idx=0;
11654    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11655
11656    if(f1apMsg)
11657    {
11658       if(f1apMsg->choice.initiatingMessage)
11659       {
11660          rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11661          if(rrcDeliveryReport->protocolIEs.list.array)
11662          {
11663             for(idx =0 ;idx <rrcDeliveryReport->protocolIEs.list.count ;
11664                   idx++)
11665             {
11666                if(rrcDeliveryReport->protocolIEs.list.array[idx])
11667                {
11668                   DU_FREE(rrcDeliveryReport->protocolIEs.list.array[idx],
11669                         sizeof(RRCDeliveryReportIEs_t));
11670                }
11671             }
11672             DU_FREE(rrcDeliveryReport->protocolIEs.list.array,
11673                   rrcDeliveryReport->protocolIEs.list.size);
11674          }
11675          DU_FREE(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11676       }
11677       DU_FREE(f1apMsg,
11678             sizeof(F1AP_PDU_t));
11679    }
11680 }
11681
11682 /*******************************************************************
11683 *
11684 * @brief Builds and sends the RRC delivery report
11685 *
11686 * @details
11687 *
11688 *    Function : BuildAndSendRrcDeliveryReport
11689 *
11690 *    Functionality: Builds and sends the RRC delivery report
11691 *
11692 * @params[in]
11693 *
11694 * @return ROK     - success
11695 *         RFAILED - failure
11696 *
11697 * ****************************************************************/
11698 uint8_t BuildAndSendRrcDeliveryReport(uint32_t gnbCuUeF1apId, \
11699    uint32_t gnbDuUeF1apId, RrcDeliveryReport *rrcDelivery)
11700 {
11701    uint8_t             ret = RFAILED;
11702    uint8_t             idx    = 0;
11703    uint8_t             idx1   = 0;
11704    uint8_t             elementCnt = 0;
11705    F1AP_PDU_t          *f1apMsg = NULLP;
11706    asn_enc_rval_t      encRetVal;
11707    RRCDeliveryReport_t *rrcDeliveryReport= NULLP;
11708
11709    do{
11710
11711       DU_LOG("\nINFO   -->  F1AP : Building RRC delivery Message Transfer Message\n");
11712       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
11713       if(f1apMsg == NULLP)
11714       {
11715          DU_LOG(" ERROR  -->  F1AP : Memory allocation for F1AP-PDU failed");
11716          break;
11717       }
11718       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
11719       DU_ALLOC(f1apMsg->choice.initiatingMessage,sizeof(InitiatingMessage_t));
11720       if(f1apMsg->choice.initiatingMessage == NULLP)
11721       {
11722          DU_LOG(" ERROR  -->  F1AP : Memory allocation for  F1AP-PDU  failed");
11723          break;
11724       }
11725       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_RRCDeliveryReport;
11726       f1apMsg->choice.initiatingMessage->criticality   = Criticality_ignore;
11727       f1apMsg->choice.initiatingMessage->value.present = InitiatingMessage__value_PR_RRCDeliveryReport;
11728
11729       rrcDeliveryReport = &f1apMsg->choice.initiatingMessage->value.choice.RRCDeliveryReport;
11730       elementCnt = 4;
11731       rrcDeliveryReport->protocolIEs.list.count = elementCnt;
11732       rrcDeliveryReport->protocolIEs.list.size = elementCnt * sizeof(RRCDeliveryReportIEs_t *);
11733
11734       /* Initialize the F1Setup members */
11735       DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array, rrcDeliveryReport->protocolIEs.list.size);
11736       if(rrcDeliveryReport->protocolIEs.list.array == NULLP)
11737       {
11738          DU_LOG(" ERROR  -->  F1AP : Memory allocation for RRC Delivery  failed");
11739          break;
11740       }
11741       for(idx =0 ;idx <elementCnt; idx++)
11742       {
11743          DU_ALLOC(rrcDeliveryReport->protocolIEs.list.array[idx], sizeof(RRCDeliveryReportIEs_t));
11744          if(rrcDeliveryReport->protocolIEs.list.array[idx] == NULLP)
11745          {
11746             break;
11747          }
11748       }
11749
11750       idx1 = 0;
11751
11752       /*GNB CU UE F1AP ID*/
11753       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
11754       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
11755       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_CU_UE_F1AP_ID;
11756       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
11757
11758       /*GNB DU UE F1AP ID*/
11759       idx1++;
11760       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
11761       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_reject;
11762       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_GNB_DU_UE_F1AP_ID;
11763       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
11764
11765       /*RRC delivery status*/
11766       idx1++;
11767       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_RRCDeliveryStatus;
11768       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
11769       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_RRCDeliveryStatus;
11770       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.delivery_status =\
11771       rrcDelivery->rrcDeliveryStatus.deliveryStatus;
11772       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.RRCDeliveryStatus.triggering_message =\
11773       rrcDelivery->rrcDeliveryStatus.triggeringMessage;
11774
11775       /* SRB ID */
11776       idx1++;
11777       rrcDeliveryReport->protocolIEs.list.array[idx1]->id = ProtocolIE_ID_id_SRBID;
11778       rrcDeliveryReport->protocolIEs.list.array[idx1]->criticality = Criticality_ignore;
11779       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.present = RRCDeliveryReportIEs__value_PR_SRBID;
11780       rrcDeliveryReport->protocolIEs.list.array[idx1]->value.choice.SRBID =  rrcDelivery->srbId;
11781
11782       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
11783
11784       /* Encode the RRC DELIVERY REPORT type as APER */
11785       memset(encBuf, 0, ENC_BUF_MAX_LEN);
11786       encBufSize = 0;
11787       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,\
11788             encBuf);
11789
11790       /* Encode results */
11791       if(encRetVal.encoded == ENCODE_FAIL)
11792       {
11793          DU_LOG("\nERROR  -->  F1AP : Could not encode RRC Delivery Msg structure (at %s)\n",\
11794                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
11795          break;
11796       }
11797       else
11798       {
11799          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for RRC Delivery Msg \n");
11800          for(idx=0; idx< encBufSize; idx++)
11801          {
11802             printf("%x",encBuf[idx]);
11803          }
11804       }
11805
11806       /* Sending msg */
11807       if(sendF1APMsg() != ROK)
11808       {
11809          DU_LOG("\nERROR  -->  F1AP : Sending RRC delivery  msg request failed");
11810          break;
11811       }
11812       ret = ROK;
11813       break;
11814
11815    }while(true);
11816
11817    freeRrcDeliveryReport(f1apMsg);
11818    return ret;
11819 }
11820
11821 /*******************************************************************
11822  *
11823  * @brief Processes cells to be activated
11824  *
11825  * @details
11826  *
11827  *    Function : extractCellsToBeActivated
11828  *
11829  *    Functionality:
11830  *      - Processes cells to be activated list received in F1SetupRsp
11831  *
11832  * @params[in] void
11833  * @return ROK     - success
11834  *         RFAILED - failure
11835  *
11836  * ****************************************************************/
11837
11838 uint8_t extractCellsToBeActivated(Cells_to_be_Activated_List_t cellsToActivate)
11839 {
11840    uint8_t  ret = ROK;
11841    uint16_t idx, nci, pci = 0;
11842    Cells_to_be_Activated_List_Item_t cell;
11843
11844    for(idx=0; idx<cellsToActivate.list.count; idx++)
11845    {
11846       nci = 0;
11847       cell = cellsToActivate.list.array[idx]->value.choice.Cells_to_be_Activated_List_Item;
11848       bitStringToInt(&cell.nRCGI.nRCellIdentity, &nci);
11849
11850       if(cell.nRPCI)
11851       {
11852          pci = *cell.nRPCI;
11853       }
11854       ret = duProcCellsToBeActivated(cell.nRCGI.pLMN_Identity.buf, nci, pci);
11855    }
11856    return ret;
11857 }
11858 /******************************************************************
11859 *
11860 * @brief Processes F1 Setup Response allocated by aper_decoder
11861 *
11862 * @details
11863 *
11864 *    Function : freeF1SetupRsp
11865 *
11866 *    Functionality: free F1 Setup Response allocated by aper_decoder
11867 *
11868 * @params[in] F1SetupResponse_t *f1SetRspMsg
11869 * @return void
11870 *
11871 * ****************************************************************/
11872
11873 void freeAperDecodeF1SetupRsp(F1SetupResponse_t *f1SetRspMsg)
11874 {
11875    uint8_t ieIdx =0;
11876    uint8_t arrIdx =0;
11877    Cells_to_be_Activated_List_t *cellToActivate =NULLP;
11878    RRC_Version_t      *rrcVer =NULLP;
11879
11880    if(f1SetRspMsg->protocolIEs.list.array)
11881    {
11882       for(ieIdx=0; ieIdx<f1SetRspMsg->protocolIEs.list.count; ieIdx++)
11883       {
11884          if(f1SetRspMsg->protocolIEs.list.array[ieIdx])
11885          {
11886             switch(f1SetRspMsg->protocolIEs.list.array[ieIdx]->id)
11887             {
11888                case ProtocolIE_ID_id_Cells_to_be_Activated_List:
11889                   {
11890                      cellToActivate =
11891                         &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.Cells_to_be_Activated_List;
11892                      if(cellToActivate->list.array)
11893                      {
11894                         for(arrIdx=0; arrIdx<cellToActivate->list.count ; arrIdx++)
11895                         {
11896                            if(cellToActivate->list.array[arrIdx])
11897                            {
11898
11899                               if(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.nRCGI.\
11900                               pLMN_Identity.buf)
11901                               {
11902                                  if(cellToActivate->list.array[0]->value.choice.\
11903                                        Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf)
11904                                  {
11905                                     free(cellToActivate->list.array[0]->value.choice.\
11906                                           Cells_to_be_Activated_List_Item.nRCGI.nRCellIdentity.buf);
11907                                  }
11908
11909                                  free(cellToActivate->list.array[0]->value.choice.Cells_to_be_Activated_List_Item.\
11910                                        nRCGI.pLMN_Identity.buf);
11911                               }
11912                               free(cellToActivate->list.array[arrIdx]);
11913                            }
11914                         }
11915                         free(cellToActivate->list.array);
11916                      }
11917                      break;
11918                   }
11919                case ProtocolIE_ID_id_TransactionID:
11920                   {
11921                      break;
11922                   }
11923                case ProtocolIE_ID_id_gNB_CU_Name:
11924                   {
11925                      free(f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_Name.buf);
11926                      break;
11927                   }
11928                case ProtocolIE_ID_id_GNB_CU_RRC_Version:
11929                   {
11930                      rrcVer = &f1SetRspMsg->protocolIEs.list.array[ieIdx]->value.choice.RRC_Version;
11931                      if(rrcVer->latest_RRC_Version.buf)
11932                      {
11933                         if(rrcVer->iE_Extensions)
11934                         {
11935                            if(rrcVer->iE_Extensions->list.array)
11936                            {
11937                               if(rrcVer->iE_Extensions->list.array[0])
11938                               {
11939                                  if(rrcVer->iE_Extensions->list.\
11940                                        array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf)
11941                                  {
11942                                     free(rrcVer->iE_Extensions->list.\
11943                                           array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf);
11944                                  }
11945                                  free(rrcVer->iE_Extensions->list.array[0]);
11946                               }
11947                               free(rrcVer->iE_Extensions->list.array);
11948                            }
11949                            free(rrcVer->iE_Extensions);
11950                         }
11951                         free(rrcVer->latest_RRC_Version.buf);
11952                      }
11953                      break;
11954
11955                   }
11956                default:
11957                   {
11958                      DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
11959                            f1SetRspMsg->protocolIEs.list.array[ieIdx]->id);
11960                   }
11961             }
11962             free(f1SetRspMsg->protocolIEs.list.array[ieIdx]);
11963          }
11964       }
11965       free(f1SetRspMsg->protocolIEs.list.array);
11966    }
11967 }
11968 /******************************************************************
11969  *
11970  * @brief Processes F1 Setup Response sent by CU
11971  *
11972  * @details
11973  *
11974  *    Function : procF1SetupRsp
11975  *
11976  *    Functionality: Processes F1 Setup Response sent by CU
11977  *
11978  * @params[in] F1AP_PDU_t ASN decoded F1AP message
11979  * @return ROK     - success
11980  *         RFAILED - failure
11981  *
11982  * ****************************************************************/
11983 uint8_t procF1SetupRsp(F1AP_PDU_t *f1apMsg)
11984 {
11985    uint8_t ret = ROK;
11986    uint16_t idx =0;
11987    F1SetupResponse_t *f1SetRspMsg = NULLP;
11988    GNB_CU_Name_t     *cuName = NULLP;
11989    F1SetupRsp  f1SetRspDb;
11990    RRC_Version_t      *rrcVer =NULLP;
11991
11992    memset(&f1SetRspDb, 0, sizeof(F1SetupRsp));
11993
11994    DU_LOG("\nINFO   -->  F1AP : F1 Setup Response received");
11995    f1SetRspMsg = &f1apMsg->choice.successfulOutcome->value.choice.F1SetupResponse;
11996
11997    for(idx=0; idx<f1SetRspMsg->protocolIEs.list.count; idx++)
11998    {
11999       switch(f1SetRspMsg->protocolIEs.list.array[idx]->id)
12000       {
12001          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
12002             {
12003                extractCellsToBeActivated(f1SetRspMsg->protocolIEs.list.array[idx]->\
12004                      value.choice.Cells_to_be_Activated_List);
12005                break;
12006             }
12007          case ProtocolIE_ID_id_TransactionID:
12008             {
12009                f1SetRspDb.transId = f1SetRspMsg->protocolIEs.list.array[idx]->\
12010                                     value.choice.TransactionID;
12011                break;
12012             }
12013          case ProtocolIE_ID_id_gNB_CU_Name:
12014             {
12015                cuName = &f1SetRspMsg->protocolIEs.list.array[idx]->\
12016                         value.choice.GNB_CU_Name;
12017                strcpy(f1SetRspDb.cuName, (const char*)cuName->buf);
12018                break;
12019             }
12020          case ProtocolIE_ID_id_GNB_CU_RRC_Version:
12021             {
12022                rrcVer = &f1SetRspMsg->protocolIEs.list.array[idx]->value.choice.RRC_Version;
12023                strcpy(f1SetRspDb.rrcVersion.rrcVer,
12024                      (const char*)rrcVer->latest_RRC_Version.buf);
12025                break;
12026             }
12027          default:
12028             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in F1SetupRsp:%ld",
12029                   f1SetRspMsg->protocolIEs.list.array[idx]->id);
12030       }
12031       duProcF1SetupRsp();
12032    }
12033
12034    freeAperDecodeF1SetupRsp(f1SetRspMsg);
12035    return ret;
12036 }
12037 /*******************************************************************
12038 *
12039 * @brief free GNB DU config update ack
12040 *
12041 * @details
12042 *
12043 *    Function : freeAperDecodeGnbDuAck
12044 *
12045 *    Functionality: Processes GNB DU config update ack And
12046 *                     added free part for the memory allocated by aper_decoder
12047 *
12048 * @params[in] F1AP_PDU_t ASN decoded F1AP message
12049 * @return ROK     - success
12050 *         RFAILED - failure
12051 *
12052 * ****************************************************************/
12053
12054 void freeAperDecodeGnbDuAck(GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck)
12055 {
12056    uint8_t ieIdx = 0;
12057
12058    if(gnbDuAck->protocolIEs.list.array)
12059    {
12060       for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
12061       {
12062          if(gnbDuAck->protocolIEs.list.array[ieIdx])
12063          {
12064             free(gnbDuAck->protocolIEs.list.array[ieIdx]);
12065          }
12066       }
12067       free(gnbDuAck->protocolIEs.list.array);
12068    }
12069 }
12070
12071 /*******************************************************************
12072 *
12073 * @brief Building  result of gnb-du config update ack output
12074 *
12075 * @details
12076 *
12077 *    Function : duProcGnbDuCfgUpdAckMsg
12078 *
12079 *    Functionality:
12080 *        Building output of gnb-du config update ack
12081 *
12082 * @params[in] transId
12083 * @return void
12084 *
12085 * ****************************************************************/
12086
12087 uint8_t duProcGnbDuCfgUpdAckMsg(uint8_t transId)
12088 {
12089    uint8_t  ieIdx=0, arrIdx=0,ret=ROK;
12090    uint8_t  ueId =0 , ueIdx =0;
12091    uint16_t cellId =0, cellIdx =0, crnti=0;
12092    CmLList *f1apPduNode = NULLP;
12093    ReservedF1apPduInfo *f1apPduInfo =NULLP;
12094    F1AP_PDU_t *f1apMsgPdu = NULLP;
12095    GNBDUConfigurationUpdate_t *gnbDuConfigUpdate = NULLP;
12096    BIT_STRING_t *cellIdentity=NULLP;
12097    struct Served_Cells_To_Delete_ItemIEs *deleteItemIe=NULLP;
12098    Served_Cells_To_Delete_List_t *cellsToDelete=NULLP;
12099    Served_Cells_To_Delete_Item_t *deleteItem=NULLP;
12100
12101    DU_LOG("\nINFO   -->  DU APP: GNB-DU config update Ack received ");
12102    f1apPduNode = searchFromReservedF1apPduList(transId);
12103    f1apPduInfo = (ReservedF1apPduInfo *)f1apPduNode->node;
12104    f1apMsgPdu = (F1AP_PDU_t *)f1apPduInfo->f1apMsg;
12105
12106    if(f1apMsgPdu)
12107    {
12108       if(f1apMsgPdu->choice.initiatingMessage)
12109       {
12110          gnbDuConfigUpdate = &f1apMsgPdu->choice.initiatingMessage->value.choice.GNBDUConfigurationUpdate;
12111          for(ieIdx=0; ieIdx < gnbDuConfigUpdate->protocolIEs.list.count; ieIdx++)
12112          {
12113             switch(gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->id)
12114             {
12115                case ProtocolIE_ID_id_Served_Cells_To_Delete_List:
12116                   {
12117                      cellsToDelete = &gnbDuConfigUpdate->protocolIEs.list.array[ieIdx]->value.choice.\
12118                                      Served_Cells_To_Delete_List;
12119                      if(cellsToDelete->list.array)
12120                      {
12121                         if(cellsToDelete->list.array[arrIdx])
12122                         {
12123                            deleteItemIe = (Served_Cells_To_Delete_ItemIEs_t*)cellsToDelete->list.array[arrIdx];
12124                            deleteItem=&deleteItemIe->value.choice.Served_Cells_To_Delete_Item;
12125                            if(deleteItem->oldNRCGI.nRCellIdentity.buf)
12126                            {
12127                               cellIdentity = &deleteItem->oldNRCGI.nRCellIdentity;
12128                               bitStringToInt(cellIdentity, &cellId);
12129                            }
12130                         }
12131                      }
12132
12133                      GET_CELL_IDX(cellId, cellIdx);
12134                      if(duCb.actvCellLst[cellIdx] != NULLP)
12135                      {
12136                         if(duCb.actvCellLst[cellIdx]->numActvUes == 0)
12137                         {
12138                            duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
12139                            ret = duSendCellDeletReq(cellId);
12140                            if(ret == RFAILED)
12141                            {
12142                               DU_LOG("ERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to send cell delete\
12143                               request for cellId[%d]", cellId);
12144                            }
12145                         }
12146                         else
12147                         {
12148                            for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
12149                            {
12150                               crnti = duCb.actvCellLst[cellIdx]->ueCb[ueIdx].crnti;
12151                               GET_UE_IDX(crnti,ueId);
12152                               ret = BuildAndSendUeContextReleaseReq(cellId, ueId);
12153                               if(ret == RFAILED)
12154                               {
12155                                  DU_LOG("ERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): Failed to build and send UE delete\
12156                                  request for cellId[%d]", cellId);
12157                               }
12158                            }
12159                         }
12160                      }
12161                      else
12162                      {
12163                         DU_LOG("ERROR  --> DU_APP : duProcGnbDuCfgUpdAckMsg(): CellId [%d] not found", cellId);
12164                         ret = RFAILED;
12165                      }
12166                      break;
12167                   }
12168
12169                default:
12170                   break;
12171             }
12172          }
12173       }
12174    }
12175
12176    FreeDUConfigUpdate(f1apMsgPdu);
12177    deleteFromReservedF1apPduList(f1apPduNode);
12178    return ret;
12179 }
12180
12181 /*******************************************************************
12182 *
12183 * @brief Processes GNB DU config update ack
12184 *
12185 * @details
12186 *
12187 *    Function : procF1GNBDUCfgUpdAck
12188 *
12189 *    Functionality: added free part for the memory allocated by aper_decoder
12190 *
12191 * @params[in] F1AP_PDU_t *f1apMsg
12192 * @return void
12193 *
12194 * ****************************************************************/
12195 uint8_t procF1GNBDUCfgUpdAck(F1AP_PDU_t *f1apMsg)
12196 {
12197    uint8_t ieIdx=0,transId=0;
12198    GNBDUConfigurationUpdateAcknowledge_t *gnbDuAck = NULLP;
12199
12200    DU_LOG("\nINFO   -->  F1AP : GNB-DU config update acknowledgment");
12201    gnbDuAck = &f1apMsg->choice.successfulOutcome->value.choice.GNBDUConfigurationUpdateAcknowledge;
12202
12203    for(ieIdx=0; ieIdx < gnbDuAck->protocolIEs.list.count; ieIdx++)
12204    {
12205       switch(gnbDuAck->protocolIEs.list.array[ieIdx]->id)
12206       {
12207          case ProtocolIE_ID_id_TransactionID:
12208             {
12209                transId = gnbDuAck->protocolIEs.list.array[ieIdx]->value.choice.TransactionID;
12210                break;
12211             }
12212          case ProtocolIE_ID_id_Cells_to_be_Activated_List:
12213             {
12214                break;
12215             }
12216          default :
12217             {
12218                DU_LOG("\nERROR  -->  F1AP: procF1GNBDUCfgUpdAck(): Invalid IE Received: %ld", \
12219                      gnbDuAck->protocolIEs.list.array[ieIdx]->id);
12220                break;
12221             }
12222       }
12223    }
12224
12225    duProcGnbDuCfgUpdAckMsg(transId);
12226
12227 #if 0
12228    /* presently we are not supporting F1 Reset from DU to CU , we are only
12229     * supporting F1 Reset from CU to DU */
12230
12231    if(BuildAndSendF1ResetReq() != ROK)
12232    {
12233       return RFAILED;
12234    }
12235 #endif
12236
12237    freeAperDecodeGnbDuAck(gnbDuAck);
12238    return ROK;
12239 }
12240 /******************************************************************
12241 *
12242 * @brief free DL RRC Message Transfer allocated by aper_decoder
12243 *
12244 * @details
12245 *
12246 *    Function : freeAperDecodef1DlRrcMsg
12247 *
12248 *    Functionality: free DL RRC Message Transfer allocated by aper_decoder
12249 *
12250 * @params[in] DLRRCMessageTransfer_t *f1DlRrcMsg
12251 * @return ROK     - success
12252 *         RFAILED - failure
12253 *
12254 * ****************************************************************/
12255
12256 void freeAperDecodef1DlRrcMsg(DLRRCMessageTransfer_t *f1DlRrcMsg)
12257 {
12258    uint8_t ieIdx =0;
12259    RRCContainer_t *rrcContainer = NULLP;
12260
12261    if(f1DlRrcMsg->protocolIEs.list.array)
12262    {
12263       for(ieIdx=0; ieIdx<f1DlRrcMsg->protocolIEs.list.count; ieIdx++)
12264       {
12265          if(f1DlRrcMsg->protocolIEs.list.array[ieIdx])
12266          {
12267             switch(f1DlRrcMsg->protocolIEs.list.array[ieIdx]->id)
12268             {
12269                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12270                   break;
12271                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12272                   break;
12273                case ProtocolIE_ID_id_SRBID:
12274                   break;
12275                case ProtocolIE_ID_id_RRCContainer:
12276                   {
12277                      rrcContainer =&f1DlRrcMsg->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer;
12278                      free(rrcContainer->buf);
12279                   }
12280                case ProtocolIE_ID_id_ExecuteDuplication:
12281                   break;
12282                case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
12283                   break;
12284                   break;
12285             }
12286             free(f1DlRrcMsg->protocolIEs.list.array[ieIdx]);
12287          }
12288       }
12289       free(f1DlRrcMsg->protocolIEs.list.array);
12290    }
12291 }
12292 /******************************************************************
12293  *
12294  * @brief Processes DL RRC Message Transfer  sent by CU
12295  *
12296  * @details
12297  *
12298  *    Function : procF1DlRrcMsgTrans
12299  *
12300  *    Functionality: Processes DL RRC Message Transfer sent by CU
12301  *
12302  * @params[in] F1AP_PDU_t ASN decoded F1AP message
12303  * @return ROK     - success
12304  *         RFAILED - failure
12305  *
12306  * ****************************************************************/
12307 uint8_t procF1DlRrcMsgTrans(F1AP_PDU_t *f1apMsg)
12308 {
12309    uint8_t  idx, ret;
12310    DLRRCMessageTransfer_t *f1DlRrcMsg = NULLP;
12311    F1DlRrcMsg dlMsg;
12312    memset(&dlMsg, 0, sizeof(F1DlRrcMsg));
12313
12314    DU_LOG("\nINFO   -->  DU_APP : DL RRC message transfer Recevied");
12315    f1DlRrcMsg = &f1apMsg->choice.initiatingMessage->value.choice.DLRRCMessageTransfer;
12316
12317    ret = ROK;
12318
12319    for(idx=0; idx<f1DlRrcMsg->protocolIEs.list.count; idx++)
12320    {
12321       switch(f1DlRrcMsg->protocolIEs.list.array[idx]->id)
12322       {
12323          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12324             {
12325                dlMsg.gnbCuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_CU_UE_F1AP_ID;
12326                break;
12327             }
12328          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12329             {
12330                dlMsg.gnbDuUeF1apId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.GNB_DU_UE_F1AP_ID;
12331                break;
12332             }
12333          case ProtocolIE_ID_id_SRBID:
12334             {
12335                dlMsg.srbId = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.SRBID;
12336                break;
12337             }
12338          case ProtocolIE_ID_id_ExecuteDuplication:
12339             dlMsg.execDup = true;
12340             break;
12341
12342          case ProtocolIE_ID_id_RRCContainer:
12343             {
12344                if(f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size > 0)
12345                {
12346                   dlMsg.rrcMsgSize = f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size;
12347                   DU_ALLOC_SHRABL_BUF(dlMsg.rrcMsgPdu, dlMsg.rrcMsgSize);
12348                   if(dlMsg.rrcMsgPdu)
12349                   {
12350                      memcpy(dlMsg.rrcMsgPdu, f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.buf,\
12351                         dlMsg.rrcMsgSize);
12352                   }
12353                   else
12354                   {
12355                      DU_LOG("\nERROR  -->  DU APP : Memory alloc Failed at RRC Container at procF1DlRrcMsgTrans()");
12356                      return RFAILED;
12357                   }
12358                }
12359                else
12360                {
12361                   DU_LOG("\nERROR  -->  DU_APP : RRC Container Size is invalid:%ld",\
12362                   f1DlRrcMsg->protocolIEs.list.array[idx]->value.choice.RRCContainer.size);
12363                   return RFAILED;
12364                }
12365                break;
12366             }
12367          case ProtocolIE_ID_id_RRCDeliveryStatusRequest:
12368             {
12369                dlMsg.deliveryStatRpt = true;
12370                break;
12371             }
12372          default:
12373             DU_LOG("\nERROR  -->  DU_APP : Invalid IE received in DL RRC Msg Transfer:%ld",
12374                   f1DlRrcMsg->protocolIEs.list.array[idx]->id);
12375       }
12376    }
12377
12378    ret = duProcDlRrcMsg(&dlMsg);
12379
12380    freeAperDecodef1DlRrcMsg(f1DlRrcMsg);
12381    return ret;
12382 }
12383 /*******************************************************************
12384  *
12385 * @brief Builds the DRB to be Setup Mod list
12386 *
12387 * @details
12388 *
12389 *    Function :
12390 *
12391 *    Functionality: Constructs the DRB to be Setup Mod list
12392 *
12393 * @params[in] DRBs_SetupMod_List_t *drbSet
12394 *
12395 * @return ROK     - success
12396 *         RFAILED - failure
12397 *
12398 * ****************************************************************/
12399
12400 uint8_t BuildDrbSetupModList(DRBs_SetupMod_List_t *drbSet , DuUeCfg *ueCfg)
12401 {
12402    uint8_t arrIdx =0;
12403    uint8_t drbCnt =0;
12404    struct DRBs_SetupMod_ItemIEs *drbItemIe;
12405
12406    drbCnt = 1;
12407    drbSet->list.count = drbCnt;
12408    drbSet->list.size = drbCnt * sizeof(DRBs_SetupMod_ItemIEs_t *);
12409    DU_ALLOC(drbSet->list.array, drbSet->list.size);
12410    if(drbSet->list.array == NULLP)
12411    {
12412       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
12413       return  RFAILED;
12414    }
12415    for(arrIdx=0; arrIdx<drbCnt; arrIdx++)
12416    {
12417       DU_ALLOC(drbSet->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
12418       if(drbSet->list.array[arrIdx] == NULLP)
12419       {
12420               DU_LOG("\nERROR  -->  F1AP : Memory allocation failed in BuildDrbToBeSetupModList");
12421               return  RFAILED;
12422       }
12423
12424       drbItemIe = (struct DRBs_SetupMod_ItemIEs *)drbSet->list.array[arrIdx];
12425       drbItemIe->id = ProtocolIE_ID_id_DRBs_SetupMod_Item;
12426       drbItemIe->criticality = Criticality_reject;
12427       drbItemIe->value.present = DRBs_SetupMod_ItemIEs__value_PR_DRBs_SetupMod_Item;
12428       drbItemIe->value.choice.DRBs_SetupMod_Item.dRBID = ueCfg->upTnlInfo[arrIdx].drbId;
12429       if(fillDlTnlSetupList(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List,\
12430       &ueCfg->upTnlInfo[arrIdx])!= ROK)
12431       {
12432          DU_LOG("\nERROR  -->  F1AP : Failed to fill DlTnl SetupList in BuildDrbToBeSetupModList");
12433          return RFAILED;
12434       }
12435
12436    }
12437
12438    return ROK;
12439 }
12440 /*******************************************************************
12441 * @brief Free the memory allocated for DRB setup List
12442 *
12443 * @details
12444 *
12445 *    Function : FreeDrbSetupModList
12446 *
12447 *    Functionality:
12448 *       Free the memory allocated for DRB setup list
12449 *
12450 * @params[in] DRBs_Setup_List_t *
12451 * @return void
12452 *
12453 * ****************************************************************/
12454 void FreeDrbSetupModList(DRBs_SetupMod_List_t *drbSetupList)
12455 {
12456    uint8_t arrIdx = 0;
12457    DRBs_SetupMod_ItemIEs_t *drbItemIe = NULLP;
12458
12459    for(arrIdx = 0; arrIdx < drbSetupList->list.count; arrIdx++)
12460    {
12461       drbItemIe = ((DRBs_SetupMod_ItemIEs_t *)drbSetupList->list.array[arrIdx]);
12462       freeDlTnlInfo(&drbItemIe->value.choice.DRBs_SetupMod_Item.dLUPTNLInformation_ToBeSetup_List);
12463       DU_FREE(drbSetupList->list.array[arrIdx], sizeof(DRBs_SetupMod_ItemIEs_t));
12464    }
12465    DU_FREE(drbSetupList->list.array, drbSetupList->list.size);
12466 }
12467 /*******************************************************************
12468 * @brief Free the memory allocated for UE Context Mod Response
12469 *
12470 * @details
12471 *
12472 *    Function : FreeUeContextModResp
12473 *
12474 *    Functionality:
12475 *       Free the memory allocated for UE Context Mod Response
12476 *
12477 * @params[in] F1AP_PDU_t *f1apMsg
12478 * @return void
12479 *
12480 * ****************************************************************/
12481
12482 void FreeUeContextModResp(F1AP_PDU_t *f1apMsg)
12483 {
12484    uint8_t ieIdx;
12485    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
12486    if(f1apMsg)
12487    {
12488       if(f1apMsg->choice.successfulOutcome)
12489       {
12490          ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
12491          if(ueContextModifyRes->protocolIEs.list.array)
12492          {
12493             for(ieIdx=0 ; ieIdx<ueContextModifyRes->protocolIEs.list.count; ieIdx++)
12494             {
12495                if(ueContextModifyRes->protocolIEs.list.array[ieIdx])
12496                {
12497                   switch(ueContextModifyRes->protocolIEs.list.array[ieIdx]->id)
12498                   {
12499                      case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12500                         break;
12501                      case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12502                         break;
12503                      case ProtocolIE_ID_id_DRBs_SetupMod_List:
12504                         {
12505                             FreeDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
12506                             value.choice.DRBs_SetupMod_List));
12507                             break;
12508                         }
12509                   }
12510                   DU_FREE(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
12511                }
12512
12513             }
12514             DU_FREE(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
12515          }
12516          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12517       }
12518       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
12519    }
12520 }
12521
12522 /*****************************************************************i
12523 *
12524 * @brief Creating the ue context modifcation response and sending
12525 *
12526 * @details
12527 *
12528 *    Function : BuildAndSendUeContextModRsp
12529 *
12530 *    Functionality:
12531 *         - Creating the ue context modifcation response
12532 *
12533 * @params[in] uint8_t cellId,uint8_t ueIdx
12534 * @return ROK     - success
12535 *         RFAILED - failure
12536 *
12537 * ****************************************************************/
12538 uint8_t BuildAndSendUeContextModRsp(uint8_t cellId,uint8_t ueIdx)
12539 {
12540    uint8_t   ieIdx = 0;
12541    uint8_t   cellIdx =0;
12542    uint8_t   elementCnt = 0;
12543    uint8_t   ret = RFAILED;
12544    uint32_t  gnbCuUeF1apId;   /* gNB-CU UE F1AP Id */
12545    uint32_t  gnbDuUeF1apId;   /* gNB-DU UE F1AP Id */
12546    F1AP_PDU_t *f1apMsg = NULLP;
12547    asn_enc_rval_t         encRetVal;
12548    UEContextModificationResponse_t *ueContextModifyRes = NULLP;
12549    DuUeCb                   *ueCb = NULLP;
12550
12551    DU_LOG("\nINFO  -->  F1AP : Building Ue context modification response\n");
12552
12553    while(1)
12554    {
12555       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
12556       if(f1apMsg == NULLP)
12557       {
12558          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
12559          break;
12560       }
12561
12562       f1apMsg->present =  F1AP_PDU_PR_successfulOutcome;
12563
12564       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
12565       if(f1apMsg->choice.successfulOutcome == NULLP)
12566       {
12567          DU_LOG("\nERROR  -->  F1AP : Memory allocation for F1AP-PDU failed Ue context modification");
12568          break;
12569       }
12570       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextModification;
12571       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
12572       f1apMsg->choice.successfulOutcome->value.present = SuccessfulOutcome__value_PR_UEContextModificationResponse;
12573
12574       ueContextModifyRes =&f1apMsg->choice.successfulOutcome->value.choice.UEContextModificationResponse;
12575
12576       elementCnt = 3;
12577       ueContextModifyRes->protocolIEs.list.count = elementCnt;
12578       ueContextModifyRes->protocolIEs.list.size = elementCnt*sizeof(UEContextModificationResponse_t*);
12579
12580       /* Initialize the UE context modification members */
12581       DU_ALLOC(ueContextModifyRes->protocolIEs.list.array, ueContextModifyRes->protocolIEs.list.size);
12582       if(ueContextModifyRes->protocolIEs.list.array == NULLP)
12583       {
12584          DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
12585          break;
12586       }
12587
12588       for(ieIdx=0 ; ieIdx<elementCnt; ieIdx++)
12589       {
12590          DU_ALLOC(ueContextModifyRes->protocolIEs.list.array[ieIdx], sizeof(UEContextModificationResponse_t));
12591          if(ueContextModifyRes->protocolIEs.list.array[ieIdx] == NULLP)
12592          {
12593             DU_LOG("\nERROR  -->  F1AP : Memory allocation for UE context modifcation Request failed");
12594             break;
12595          }
12596       }
12597
12598       /* Fetching Ue Cb Info*/
12599       GET_CELL_IDX(cellId, cellIdx);
12600       gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
12601       gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
12602       ueCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1];
12603
12604       ieIdx=0;
12605       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
12606       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12607       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
12608       UEContextModificationResponseIEs__value_PR_GNB_CU_UE_F1AP_ID;
12609       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID = gnbCuUeF1apId;
12610
12611       ieIdx++;
12612       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
12613       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12614       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present=\
12615       UEContextModificationResponseIEs__value_PR_GNB_DU_UE_F1AP_ID;
12616       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID = gnbDuUeF1apId;
12617
12618       ieIdx++;
12619       ueContextModifyRes->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_DRBs_SetupMod_List;
12620       ueContextModifyRes->protocolIEs.list.array[ieIdx]->criticality = Criticality_reject;
12621       ueContextModifyRes->protocolIEs.list.array[ieIdx]->value.present =\
12622       UEContextModificationResponseIEs__value_PR_DRBs_SetupMod_List;
12623       if(ueCb->f1UeDb)
12624       {
12625          ret = BuildDrbSetupModList(&(ueContextModifyRes->protocolIEs.list.array[ieIdx]->\
12626                   value.choice.DRBs_SetupMod_List) , &ueCb->f1UeDb->duUeCfg);
12627          if(ret != ROK)
12628          {
12629             DU_LOG( "\nERROR  -->  F1AP : Failed to build drb setupmod List ");
12630             break;
12631          }
12632          freeF1UeDb(ueCb->f1UeDb);
12633          ueCb->f1UeDb = NULLP;
12634       }
12635       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
12636
12637       /* Encode the F1SetupRequest type as APER */
12638       memset(encBuf, 0, ENC_BUF_MAX_LEN);
12639       encBufSize = 0;
12640       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf,encBuf);
12641
12642       /* Encode results */
12643       if(encRetVal.encoded == ENCODE_FAIL)
12644       {
12645          DU_LOG( "\nERROR  -->  F1AP : Could not encode UE Context Setup Request structure (at %s)\n",\
12646                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
12647          ret = RFAILED;
12648          break;
12649       }
12650       else
12651       {
12652          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UE Context Modification Response\n");
12653          for(int i=0; i< encBufSize; i++)
12654          {
12655             printf("%x",encBuf[i]);
12656          }
12657       }
12658
12659       /* Sending  msg  */
12660       if(sendF1APMsg() != ROK)
12661       {
12662          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Setup Res Failed");
12663          ret = RFAILED;
12664          break;
12665       }
12666       break;
12667    }
12668    FreeUeContextModResp(f1apMsg);
12669    return ret;
12670 }
12671 /*******************************************************************
12672  *
12673  * @brief Deallocating the memory allocated by the aper decoder
12674  *          for QOSInfo
12675  *
12676  * @details
12677  *
12678  *    Function : freeAperDecodeQosInfo
12679  *
12680  *    Functionality:  Deallocating the memory allocated for QOSInfo
12681  *
12682  * @params[in] QoSFlowLevelQoSParameters_t *drbQos
12683  *
12684  * @return void
12685  *
12686  * ****************************************************************/
12687
12688 void freeAperDecodeQosInfo(QoSFlowLevelQoSParameters_t *drbQos)
12689 {
12690    if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI != NULLP)
12691    {
12692       if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow!=NULLP)
12693       {
12694          if(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume!=NULLP)
12695          {
12696             free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->maxDataBurstVolume);
12697          }
12698          free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI->averagingWindow);
12699       }
12700       free(drbQos->qoS_Characteristics.choice.non_Dynamic_5QI);
12701    }
12702 }
12703 /*******************************************************************
12704  *
12705  * @brief Deallocating the memory allocated by the aper decoder
12706  *          for UlTnlInfoforDrb
12707  *
12708  * @details
12709  *
12710  *    Function : freeAperDecodeUlTnlInfoforDrbSetupMod
12711  *
12712  *    Functionality:  Deallocating memory allocated for UlTnlInfoforDrb
12713  *
12714  * @params[in] ULUPTNLInformation_ToBeSetup_List_t *ulInfo
12715  *
12716  * @return void
12717  *
12718  * ****************************************************************/
12719 void freeAperDecodeUlTnlInfoforDrbSetupMod(ULUPTNLInformation_ToBeSetup_List_t *ulInfo)
12720 {
12721    uint8_t arrIdx =0;
12722
12723    if(ulInfo->list.array)
12724    {
12725       for(arrIdx=0; arrIdx<ulInfo->list.count ; arrIdx++)
12726       {
12727          if(ulInfo->list.array[arrIdx])
12728          {
12729             if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel )
12730             {
12731                if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->transportLayerAddress.buf)
12732                {
12733                   if(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->gTP_TEID.buf)
12734                   {
12735                      free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12736                            gTP_TEID.buf);
12737                   }
12738                   free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel->\
12739                         transportLayerAddress.buf);
12740                }
12741                free(ulInfo->list.array[arrIdx]->uLUPTNLInformation.choice.gTPTunnel);
12742             }
12743             free(ulInfo->list.array[arrIdx]);
12744          }
12745       }
12746       free(ulInfo->list.array);
12747    }
12748 }
12749 /*******************************************************************
12750  *
12751  * @brief Deallocating the memory allocated by the aper decoder
12752  *          for DrbSetupModItem
12753  *
12754  * @details
12755  *
12756  *    Function : freeAperDecodeDrbSetupModItem
12757  *
12758  *    Functionality:  Deallocating memory allocated for DrbSetupModItem
12759  *
12760  * @params[in] DRBs_ToBeSetupMod_Item_t *drbItem
12761  *
12762  * @return void
12763  *
12764  * ****************************************************************/
12765
12766 void freeAperDecodeDrbSetupModItem(DRBs_ToBeSetupMod_Item_t *drbItem)
12767 {
12768    uint8_t arrIdx =0;
12769    SNSSAI_t *snssai =NULLP;
12770    Flows_Mapped_To_DRB_List_t *flowMap = NULLP;
12771
12772    drbItem->qoSInformation.present = QoSInformation_PR_choice_extension;
12773    switch(drbItem->qoSInformation.present)
12774    {
12775       case QoSInformation_PR_NOTHING:
12776          break;
12777       case QoSInformation_PR_eUTRANQoS:
12778          {
12779             if(drbItem->qoSInformation.choice.eUTRANQoS)
12780             {
12781                free(drbItem->qoSInformation.choice.eUTRANQoS);
12782             }
12783             break;
12784          }
12785       case QoSInformation_PR_choice_extension:
12786          {
12787             if(drbItem->qoSInformation.choice.choice_extension)
12788             {
12789                freeAperDecodeQosInfo(&drbItem->qoSInformation.choice.choice_extension->value.choice.\
12790                      DRB_Information.dRB_QoS);
12791                snssai = &drbItem->qoSInformation.choice.choice_extension->value.choice.DRB_Information.sNSSAI;
12792                if(snssai->sST.buf)
12793                {
12794                   free(snssai->sST.buf);
12795                }
12796                if(snssai->sD)
12797                {
12798                   if(snssai->sD->buf)
12799                   {
12800                      free(snssai->sD->buf);
12801                   }
12802                   free(snssai->sD);
12803                }
12804
12805                flowMap = &drbItem->qoSInformation.choice.choice_extension->value.choice.\
12806                          DRB_Information.flows_Mapped_To_DRB_List;
12807                if(flowMap->list.array)
12808                {
12809                   for(arrIdx=0; arrIdx<flowMap->list.count; arrIdx++)
12810                   {
12811                      if(flowMap->list.array[arrIdx] )
12812                      {
12813                         freeAperDecodeQosInfo(&flowMap->list.array[arrIdx]->qoSFlowLevelQoSParameters);
12814                         free(flowMap->list.array[arrIdx]);
12815                      }
12816                   }
12817                   free(flowMap->list.array);
12818                }
12819
12820                free(drbItem->qoSInformation.choice.choice_extension);
12821             }
12822             break;
12823          }
12824
12825    }
12826    freeAperDecodeUlTnlInfoforDrbSetupMod(&drbItem->uLUPTNLInformation_ToBeSetup_List);
12827    if(drbItem->uLConfiguration)
12828    {
12829       free(drbItem->uLConfiguration);
12830    }
12831 }
12832
12833 /*******************************************************************
12834  *
12835  * @brief Deallocating the memory allocated by the aper decoder
12836  *          for DrbToBeSetupModList
12837  *
12838  * @details
12839  *
12840  *    Function : freeAperDecodeDrbToBeSetupModList
12841  *
12842  *    Functionality:  Deallocating memory allocated for DrbToBeSetupModList
12843  *
12844  * @params[in] DRBs_ToBeSetupMod_List_t *drbSet
12845  *
12846  * @return void
12847  *
12848  * ****************************************************************/
12849
12850 void freeAperDecodeDrbToBeSetupModList(DRBs_ToBeSetupMod_List_t *drbSet)
12851 {
12852    uint8_t arrIdx =0;
12853    struct DRBs_ToBeSetupMod_ItemIEs *drbItemIe;
12854
12855    if(drbSet->list.array)
12856    {
12857       for(arrIdx=0; arrIdx<drbSet->list.count ; arrIdx++)
12858       {
12859          if(drbSet->list.array[arrIdx] != NULLP)
12860          {
12861             if(arrIdx == 0)
12862             {
12863                drbItemIe = (DRBs_ToBeSetupMod_ItemIEs_t *)drbSet->list.array[arrIdx];
12864                freeAperDecodeDrbSetupModItem(&(drbItemIe->value.choice.DRBs_ToBeSetupMod_Item));
12865             }
12866             free(drbSet->list.array[arrIdx]);
12867          }
12868       }
12869       free(drbSet->list.array);
12870    }
12871
12872 }
12873 /*******************************************************************
12874  *
12875  * @brief Deallocating the memory allocated by the aper decoder
12876  *          for UeContextModificationReqMsg
12877  *
12878  * @details
12879  *
12880  *    Function : freeAperDecodeUeContextModificationReqMsg
12881  *
12882  *    Functionality:  Deallocating memory allocated for
12883  *                  UeContextModificationReqMsg
12884  *
12885  * @params[in] UEContextModificationRequest_t *UeContextModifyReq
12886  *
12887  * @return void
12888  *
12889  * ****************************************************************/
12890 void freeAperDecodeUeContextModificationReqMsg(UEContextModificationRequest_t *UeContextModifyReq )
12891 {
12892    uint8_t arrIdx, ieId;
12893
12894    if(UeContextModifyReq->protocolIEs.list.array)
12895    {
12896       for( arrIdx = 0 ; arrIdx<UeContextModifyReq->protocolIEs.list.count ; arrIdx++)
12897       {
12898          if(UeContextModifyReq->protocolIEs.list.array[arrIdx])
12899          {
12900             ieId = UeContextModifyReq->protocolIEs.list.array[arrIdx]->id;
12901             switch(ieId)
12902             {
12903                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12904                   break;
12905                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12906                   break;
12907                case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
12908                   {
12909                      freeAperDecodeDrbToBeSetupModList(&UeContextModifyReq->protocolIEs.list.array[arrIdx]->\
12910                            value.choice.DRBs_ToBeSetupMod_List);
12911                      break;
12912                   }
12913             }
12914             free(UeContextModifyReq->protocolIEs.list.array[arrIdx]);
12915          }
12916       }
12917       free(UeContextModifyReq->protocolIEs.list.array);
12918    }
12919 }
12920 /*******************************************************************
12921  *
12922  * @brief processing the F1 UeContextModificationReq
12923  *
12924  * @details
12925  *
12926  *    Function : procF1UeContextModificationReq
12927  *
12928  *    Functionality:  processing the F1 UeContextModificationReq
12929  *
12930  * @params[in] F1AP_PDU_t *f1apMsg
12931  *
12932  * @return
12933  * ****************************************************************/
12934 uint8_t procF1UeContextModificationReq(F1AP_PDU_t *f1apMsg)
12935 {
12936    UEContextModificationRequest_t *ueContextModifyReq = NULLP;
12937    uint8_t  ret = ROK, ieIdx = 0, cellIdx=0, ueIdx=0;
12938    DuUeCb   *duUeCb = NULLP;
12939    DRBs_ToBeSetupMod_List_t *drbSetupModCfg;
12940    DRBs_ToBeModified_List_t *drbModifiedCfg;
12941    uint32_t gnbCuUeF1apId, gnbDuUeF1apId;
12942
12943    ueContextModifyReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextModificationRequest;
12944    for(ieIdx=0; (ieIdx < ueContextModifyReq->protocolIEs.list.count && ret == ROK); ieIdx++)
12945    {
12946       switch(ueContextModifyReq->protocolIEs.list.array[ieIdx]->id)
12947       {
12948          case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
12949             {
12950                gnbCuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID;
12951                break;
12952             }
12953          case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
12954             {
12955                gnbDuUeF1apId = ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID;
12956                break;
12957             }
12958          case ProtocolIE_ID_id_DRBs_ToBeSetupMod_List:
12959          case ProtocolIE_ID_id_DRBs_ToBeModified_List:
12960             {
12961                for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
12962                {
12963                   for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
12964                   {
12965                      if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
12966                            (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
12967                      {
12968
12969                         duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
12970                         if(duUeCb->f1UeDb == NULLP)
12971                         {
12972                            DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
12973                         }
12974                         if(duUeCb->f1UeDb)
12975                         {
12976                            duUeCb->f1UeDb->actionType = UE_CTXT_MOD;
12977                            if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present ==\
12978                                  UEContextModificationRequestIEs__value_PR_DRBs_ToBeSetupMod_List)
12979                            {
12980                               drbSetupModCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
12981                               choice.DRBs_ToBeSetupMod_List;
12982
12983                               if(extractDrbListToSetupMod(NULL, drbSetupModCfg, NULL, drbSetupModCfg->list.count,\
12984                                     &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap))
12985                               {
12986                                  DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbSetupModList");
12987                                  ret = RFAILED;
12988                               }
12989                            }
12990
12991                            if(ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.present == \
12992                                   UEContextModificationRequestIEs__value_PR_DRBs_ToBeModified_List)
12993
12994                            {
12995                               drbModifiedCfg = &ueContextModifyReq->protocolIEs.list.array[ieIdx]->value.\
12996                               choice.DRBs_ToBeModified_List;
12997                               if(extractDrbListToSetupMod(NULL, NULL, drbModifiedCfg, drbSetupModCfg->list.count,\
12998                                  &duUeCb->f1UeDb->duUeCfg, &duUeCb->drbBitMap))
12999                               {
13000                                  DU_LOG("\nERROR  -->  DU APP : Failed at extractDrbListToSetupMod() for DrbModifiedList");
13001                                  ret = RFAILED;
13002                               }
13003                            }
13004                         }
13005                         break;
13006                      }
13007                   }
13008                   if(ueIdx >= duCb.actvCellLst[cellIdx]->numActvUes)
13009                   {
13010                      DU_LOG("\nERROR  -->  DU APP : wrong values of gnbCuUeF1apId and gnbDuUeF1apId ");
13011                      ret = RFAILED;
13012                   }
13013                }
13014                break;
13015             }
13016       }
13017    }
13018    if(ret != RFAILED)
13019    {
13020       ret = duProcUeContextModReq(duUeCb);
13021    }
13022    freeAperDecodeUeContextModificationReqMsg(ueContextModifyReq);
13023    return ret;
13024 }
13025 /*****************************************************************i
13026 *
13027 * @brief Free memory allocated for UE Context Release Request
13028 *
13029 * @details
13030 *
13031 *    Function : FreeUeContextReleaseReq
13032 *
13033 *    Functionality:
13034 *         - Free memory allocated for UE Context Release Request
13035 *
13036 * @params[in] F1AP_PDU_t *f1apMsg
13037 * @return void
13038 *
13039 * *************************************************************/
13040 void FreeUeContextReleaseReq(F1AP_PDU_t *f1apMsg)
13041 {
13042    uint8_t ieIdx;
13043    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
13044
13045    if(f1apMsg)
13046    {
13047       if(f1apMsg->choice.initiatingMessage)
13048       {
13049          ueReleaseReq =&f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
13050          if(ueReleaseReq->protocolIEs.list.array)
13051          {
13052             for(ieIdx=0 ; ieIdx<ueReleaseReq->protocolIEs.list.count; ieIdx++)
13053             {
13054                DU_FREE(ueReleaseReq->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseRequest_t));
13055             }
13056             DU_FREE(ueReleaseReq->protocolIEs.list.array, ueReleaseReq->protocolIEs.list.size);
13057          }
13058          DU_FREE(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
13059       }
13060       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
13061    }
13062
13063 }
13064 /*****************************************************************i
13065 *
13066 * @brief Build and Send UE Context Release Request
13067 *
13068 * @details
13069 *
13070 *    Function : BuildAndSendUeContextReleaseReq
13071 *
13072 *    Functionality:
13073 *         - Build and Send UE Context Release Request
13074 *
13075 * @params[in]
13076 * @return ROK     - success
13077 *         RFAILED - failure
13078 *
13079 * *************************************************************/
13080 uint8_t BuildAndSendUeContextReleaseReq(uint16_t cellId, uint8_t ueIdx)
13081 {
13082    bool memAllocFail = false;
13083    uint8_t ieIdx =0;
13084    uint8_t ret = RFAILED;
13085    uint16_t cellIdx =0;
13086    uint16_t crnti = 0;
13087    uint8_t  elementCnt = 0;
13088    uint32_t  gnbCuUeF1apId =0;   /* gNB-CU UE F1AP Id */
13089    uint32_t  gnbDuUeF1apId =0;   /* gNB-DU UE F1AP Id */
13090    asn_enc_rval_t encRetVal;
13091    F1AP_PDU_t *f1apMsg = NULLP;
13092    UEContextReleaseRequest_t *ueReleaseReq = NULLP;
13093
13094    DU_LOG("\nINFO  --> Building the UE Context Release Request");
13095    do
13096    {
13097       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
13098       if(f1apMsg == NULLP)
13099       {
13100          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for f1apMsg");
13101          break;
13102       }
13103
13104       f1apMsg->present = F1AP_PDU_PR_initiatingMessage;
13105       DU_ALLOC(f1apMsg->choice.initiatingMessage, sizeof(InitiatingMessage_t));
13106       if(f1apMsg->choice.initiatingMessage == NULLP)
13107       {
13108          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for\
13109          initiatingMessage");
13110          break;
13111       }
13112       f1apMsg->choice.initiatingMessage->procedureCode = ProcedureCode_id_UEContextReleaseRequest;
13113       f1apMsg->choice.initiatingMessage->criticality = Criticality_reject;
13114       f1apMsg->choice.initiatingMessage->value.present = \
13115       InitiatingMessage__value_PR_UEContextReleaseRequest;
13116
13117       ueReleaseReq = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseRequest;
13118
13119       elementCnt = 2;
13120
13121       ueReleaseReq->protocolIEs.list.count = elementCnt;
13122       ueReleaseReq->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseRequest_t *);
13123
13124       /* Initialize the F1Setup members */
13125       DU_ALLOC(ueReleaseReq->protocolIEs.list.array,ueReleaseReq->protocolIEs.list.size);
13126       if(ueReleaseReq->protocolIEs.list.array == NULLP)
13127       {
13128          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE array");
13129          break;
13130       }
13131       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
13132       {
13133          DU_ALLOC(ueReleaseReq->protocolIEs.list.array[ieIdx],\
13134                sizeof(UEContextReleaseRequest_t));
13135          if(ueReleaseReq->protocolIEs.list.array[ieIdx] == NULLP)
13136          {
13137             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): Memory allocation failed for IE elements");
13138             memAllocFail = true;
13139             break;
13140          }
13141       }
13142       if(memAllocFail == true)
13143          break;
13144
13145       /* Fetching Ue Cb Info*/
13146       GET_CELL_IDX(cellId, cellIdx);
13147       if(duCb.actvCellLst[cellIdx] == NULLP)
13148       {
13149          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): CellId[%d] does not exist", cellId);
13150          break;
13151       }
13152       else
13153       {
13154          GET_CRNTI(crnti, ueIdx);
13155          if(duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].crnti != crnti)
13156          {
13157             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseReq(): crnti[%d] does not exist", crnti);
13158             break;
13159          }
13160          gnbDuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbDuUeF1apId;
13161          gnbCuUeF1apId = duCb.actvCellLst[cellIdx]->ueCb[ueIdx-1].gnbCuUeF1apId;
13162       }
13163
13164       ieIdx=0;
13165       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
13166       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13167       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present = \
13168       UEContextReleaseRequestIEs__value_PR_GNB_CU_UE_F1AP_ID;
13169       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
13170
13171       ieIdx++;
13172       ueReleaseReq->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
13173       ueReleaseReq->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13174       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.present =\
13175       UEContextReleaseRequestIEs__value_PR_GNB_DU_UE_F1AP_ID;
13176       ueReleaseReq->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
13177
13178       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13179
13180       /* Encode the F1SetupRequest type as APER */
13181       memset(encBuf, 0, ENC_BUF_MAX_LEN);
13182       encBufSize = 0;
13183       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
13184       /* Encode results */
13185       if(encRetVal.encoded == ENCODE_FAIL)
13186       {
13187          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseRequest structure (at %s)\n",\
13188                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13189          break;
13190       }
13191       else
13192       {
13193          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseRequest\n");
13194          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
13195          {
13196             printf("%x",encBuf[ieIdx]);
13197          }
13198       }
13199
13200       /* Sending msg */
13201       if(sendF1APMsg() != ROK)
13202       {
13203          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Request failed");
13204          break;
13205       }
13206       ret = ROK;
13207       break;
13208    }while(true);
13209
13210    FreeUeContextReleaseReq(f1apMsg);
13211    return ret;
13212 }
13213 /*****************************************************************i
13214  *
13215  * @brief Free memory allocated for UE Context Release Complete
13216  *
13217  * @details
13218  *
13219  *    Function : FreeUeContextReleaseComplete
13220  *
13221  *    Functionality:
13222  *         - Free memory allocated for UE Context Release Complete
13223  *
13224  * @params[in] F1AP_PDU_t *f1apMsg
13225  * @return void
13226  *
13227  * *************************************************************/
13228 void FreeUeContextReleaseComplete(F1AP_PDU_t *f1apMsg)
13229 {
13230    uint8_t ieIdx;
13231    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
13232
13233    if(f1apMsg)
13234    {
13235       if(f1apMsg->choice.successfulOutcome)
13236       {
13237          ueReleaseComplete =&f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
13238          if(ueReleaseComplete->protocolIEs.list.array)
13239          {
13240             for(ieIdx=0 ; ieIdx<ueReleaseComplete->protocolIEs.list.count; ieIdx++)
13241             {
13242                DU_FREE(ueReleaseComplete->protocolIEs.list.array[ieIdx], sizeof(UEContextReleaseComplete_t));
13243             }
13244             DU_FREE(ueReleaseComplete->protocolIEs.list.array, ueReleaseComplete->protocolIEs.list.size);
13245          }
13246          DU_FREE(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
13247       }
13248       DU_FREE(f1apMsg, sizeof(F1AP_PDU_t));
13249    }
13250
13251 }
13252 /*****************************************************************i
13253  *
13254  * @brief Build and Send UE Context Release Complete
13255  *
13256  * @details
13257  *
13258  *    Function : BuildAndSendUeContextReleaseComplete
13259  *
13260  *    Functionality:
13261  *         - Build and Send UE Context Release Complete
13262  *
13263  * @params[in]  cellId,  gnbCuUeF1apId, gnbDuUeF1apId
13264  * @return ROK     - success
13265  *         RFAILED - failure
13266  *
13267  * *************************************************************/
13268 uint8_t BuildAndSendUeContextReleaseComplete(uint16_t cellId, uint32_t gnbCuUeF1apId, uint32_t gnbDuUeF1apId)
13269 {
13270    bool memAllocFail = false;
13271    uint8_t ieIdx =0, ret = RFAILED, elementCnt = 0;
13272    asn_enc_rval_t encRetVal;
13273    F1AP_PDU_t *f1apMsg = NULLP;
13274    UEContextReleaseComplete_t *ueReleaseComplete = NULLP;
13275
13276    DU_LOG("\nINFO  --> Building the UE Context Release Complete");
13277    do
13278    {
13279       DU_ALLOC(f1apMsg, sizeof(F1AP_PDU_t));
13280       if(f1apMsg == NULLP)
13281       {
13282          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for f1apMsg");
13283          break;
13284       }
13285
13286       f1apMsg->present = F1AP_PDU_PR_successfulOutcome;
13287       DU_ALLOC(f1apMsg->choice.successfulOutcome, sizeof(SuccessfulOutcome_t));
13288       if(f1apMsg->choice.successfulOutcome == NULLP)
13289       {
13290          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for\
13291                successfulOutcome");
13292          break;
13293       }
13294       f1apMsg->choice.successfulOutcome->procedureCode = ProcedureCode_id_UEContextRelease;
13295       f1apMsg->choice.successfulOutcome->criticality = Criticality_reject;
13296       f1apMsg->choice.successfulOutcome->value.present = \
13297       SuccessfulOutcome__value_PR_UEContextReleaseComplete;
13298
13299       ueReleaseComplete = &f1apMsg->choice.successfulOutcome->value.choice.UEContextReleaseComplete;
13300
13301       elementCnt = 2;
13302       ueReleaseComplete->protocolIEs.list.count = elementCnt;
13303       ueReleaseComplete->protocolIEs.list.size = elementCnt * sizeof(UEContextReleaseComplete_t *);
13304
13305       /* Initialize the UE Release Complete members */
13306       DU_ALLOC(ueReleaseComplete->protocolIEs.list.array,ueReleaseComplete->protocolIEs.list.size);
13307       if(ueReleaseComplete->protocolIEs.list.array == NULLP)
13308       {
13309          DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE array");
13310          break;
13311       }
13312       for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
13313       {
13314          DU_ALLOC(ueReleaseComplete->protocolIEs.list.array[ieIdx],\
13315                sizeof(UEContextReleaseComplete_t));
13316          if(ueReleaseComplete->protocolIEs.list.array[ieIdx] == NULLP)
13317          {
13318             DU_LOG("\nERROR  -->  F1AP : BuildAndSendUeContextReleaseComplete(): Memory allocation failed for IE\
13319             elements");
13320             memAllocFail = true;
13321             break;
13322          }
13323       }
13324       if(memAllocFail == true)
13325          break;
13326
13327
13328       ieIdx=0;
13329       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID;
13330       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13331       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present = \
13332       UEContextReleaseCompleteIEs__value_PR_GNB_CU_UE_F1AP_ID;
13333       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_CU_UE_F1AP_ID =gnbCuUeF1apId;
13334
13335       ieIdx++;
13336       ueReleaseComplete->protocolIEs.list.array[ieIdx]->id = ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID;
13337       ueReleaseComplete->protocolIEs.list.array[ieIdx]->criticality= Criticality_reject;
13338       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.present =\
13339       UEContextReleaseCompleteIEs__value_PR_GNB_DU_UE_F1AP_ID;
13340       ueReleaseComplete->protocolIEs.list.array[ieIdx]->value.choice.GNB_DU_UE_F1AP_ID =gnbDuUeF1apId;
13341
13342       xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13343
13344       /* Encode the F1SetupComplete type as APER */
13345       memset(encBuf, 0, ENC_BUF_MAX_LEN);
13346       encBufSize = 0;
13347       encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
13348       /* Encode results */
13349       if(encRetVal.encoded == ENCODE_FAIL)
13350       {
13351          DU_LOG("\nERROR  -->  F1AP : Could not encode UEContextReleaseComplete structure (at %s)\n",\
13352                encRetVal.failed_type ? encRetVal.failed_type->name : "unknown");
13353          break;
13354       }
13355       else
13356       {
13357          DU_LOG("\nDEBUG   -->  F1AP : Created APER encoded buffer for UEContextReleaseComplete\n");
13358          for(ieIdx=0; ieIdx< encBufSize; ieIdx++)
13359          {
13360             printf("%x",encBuf[ieIdx]);
13361          }
13362       }
13363
13364       /* Sending msg */
13365       if(sendF1APMsg() != ROK)
13366       {
13367          DU_LOG("\nERROR  -->  F1AP : Sending UE Context Release Complete failed");
13368          break;
13369       }
13370       ret = ROK;
13371       break;
13372    }while(true);
13373
13374    if(ret == ROK)
13375    {
13376       duCb.actvCellLst[cellId-1]->cellStatus = DELETION_IN_PROGRESS;
13377       ret = duSendCellDeletReq(cellId);
13378       if(ret != ROK)
13379       {
13380          DU_LOG("\nERROR  -->  F1AP: BuildAndSendUeContextReleaseComplete(): Failed to process cell\
13381                Delete req for CellId");
13382       }
13383    }
13384    FreeUeContextReleaseComplete(f1apMsg);
13385    return ret;
13386
13387 }
13388
13389 /*******************************************************************
13390 *
13391 * @brief added free part for the memory allocated by aper_decoder
13392 *
13393 * @details
13394 *
13395 *    Function : freeAperDecodeUeContextReleaseCommand
13396 *
13397 *    Functionality: added free part for the memory allocated by aper_decoder
13398 *
13399 * @params[in] F1AP_PDU_t *f1apMsg
13400 * @return void
13401 *
13402 * ****************************************************************/
13403 void freeAperDecodeUeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
13404 {
13405    uint8_t ieIdx=0;
13406    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
13407
13408    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
13409
13410    if(ueContextReleaseCommand->protocolIEs.list.array)
13411    {
13412       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
13413       {
13414          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
13415          {
13416             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
13417             {
13418                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13419                   break;
13420                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13421                   break;
13422                case ProtocolIE_ID_id_Cause:
13423                   break;
13424                case ProtocolIE_ID_id_RRCContainer:
13425                {
13426                   if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf)
13427                   {
13428                      free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->value.choice.RRCContainer.buf);
13429                   }
13430                   break;
13431                }
13432                default :
13433                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
13434                        ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
13435                   break;
13436             }
13437          }
13438          free(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]);
13439       }
13440       free(ueContextReleaseCommand->protocolIEs.list.array);
13441    }
13442 }
13443 /*******************************************************************
13444 *
13445 * @brief processing of UE Context Release Command
13446 *
13447 * @details
13448 *
13449 *    Function : procF1UeContextReleaseCommand
13450 *
13451 *    Functionality: processing of UE Context Release Command
13452 *
13453 * @params[in] F1AP_PDU_t *f1apMsg
13454 * @return void
13455 *
13456 * ****************************************************************/
13457 uint8_t procF1UeContextReleaseCommand(F1AP_PDU_t *f1apMsg)
13458 {
13459    uint8_t  ieIdx=0, ret=ROK, ueIdx=0;
13460    uint16_t cellIdx =0;
13461    bool ueIdxFound;
13462    uint32_t gnbCuUeF1apId=0, gnbDuUeF1apId=0;
13463    DuUeCb   *duUeCb = NULLP;
13464    UEContextReleaseCommand_t *ueContextReleaseCommand = NULLP;
13465
13466    ueContextReleaseCommand = &f1apMsg->choice.initiatingMessage->value.choice.UEContextReleaseCommand;
13467
13468    if(ueContextReleaseCommand->protocolIEs.list.array)
13469    {
13470       for(ieIdx=0; ieIdx < ueContextReleaseCommand->protocolIEs.list.count; ieIdx++)
13471       {
13472          if(ueContextReleaseCommand->protocolIEs.list.array[ieIdx])
13473          {
13474             switch(ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id)
13475             {
13476                case ProtocolIE_ID_id_gNB_CU_UE_F1AP_ID:
13477                   {
13478                      gnbCuUeF1apId= ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13479                                     value.choice.GNB_CU_UE_F1AP_ID;
13480                      break;
13481                   }
13482
13483                case ProtocolIE_ID_id_gNB_DU_UE_F1AP_ID:
13484                   {
13485                      gnbDuUeF1apId = ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13486                                      value.choice.GNB_DU_UE_F1AP_ID;
13487                      break;
13488                   }
13489
13490                case ProtocolIE_ID_id_Cause:
13491                   {
13492                      break;
13493                   }
13494
13495                case ProtocolIE_ID_id_RRCContainer:
13496                   {
13497                      for(cellIdx = 0; cellIdx < duCb.numActvCells; cellIdx++)
13498                      {
13499                         for(ueIdx = 0; ueIdx < duCb.actvCellLst[cellIdx]->numActvUes; ueIdx++)
13500                         {
13501                            if((duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbDuUeF1apId == gnbDuUeF1apId)&&\
13502                                  (duCb.actvCellLst[cellIdx]->ueCb[ueIdx].gnbCuUeF1apId == gnbCuUeF1apId))
13503                            {
13504                               duUeCb = &duCb.actvCellLst[cellIdx]->ueCb[ueIdx];
13505                               DU_ALLOC(duUeCb->f1UeDb, sizeof(F1UeContextSetupDb));
13506                               if(duUeCb->f1UeDb)
13507                               {
13508                                  memset(duUeCb->f1UeDb, 0, sizeof(F1UeContextSetupDb));
13509                                  duUeCb->f1UeDb->actionType = UE_CTXT_RELEASE;
13510                                  duUeCb->f1UeDb->cellIdx = cellIdx;
13511                                  /* Filling Dl RRC Msg Info */
13512                                  DU_ALLOC_SHRABL_BUF(duUeCb->f1UeDb->dlRrcMsg, sizeof(F1DlRrcMsg));
13513                                  if(!duUeCb->f1UeDb->dlRrcMsg)
13514                                  {
13515                                     DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
13516                                     Memory allocation failed ");
13517                                     ret = RFAILED;
13518                                  }
13519                                  else
13520                                  {
13521                                     duUeCb->f1UeDb->dlRrcMsgPres = true;
13522                                     memset(duUeCb->f1UeDb->dlRrcMsg, 0, sizeof(F1DlRrcMsg));
13523                                     ret = extractDlRrcMsg(gnbDuUeF1apId, gnbCuUeF1apId, duUeCb->f1UeDb->dlRrcMsg,\
13524                                           &ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->\
13525                                           value.choice.RRCContainer);
13526                                  }
13527
13528                               }
13529                               else
13530                               {
13531                                  DU_LOG("\nERROR  -->  DU APP : procF1UeContextReleaseCommand(): \
13532                                  Memory allocation failed ");
13533                                  ret = RFAILED;
13534
13535                               }
13536
13537                               ueIdxFound = true;
13538                               break;
13539                            }
13540                         }
13541                         if(ueIdxFound == true)
13542                         {
13543                            break;
13544                         }
13545                      }
13546                      if(!ueIdxFound)
13547                      {
13548                         DU_LOG("\nERROR  -->  F1AP: DuUeCb is not found at procF1UeContextSetupReq()");
13549                         ret = RFAILED;
13550                      }
13551
13552
13553                      break;
13554                   }
13555                default :
13556                   DU_LOG("\nERROR  -->  F1AP: freeAperDecodeUeContextReleaseCommand():Invalid IE Received: %ld"\
13557                         ,ueContextReleaseCommand->protocolIEs.list.array[ieIdx]->id);
13558                   break;
13559             }
13560          }
13561       }
13562    }
13563    if(ret != RFAILED)
13564    {
13565       duProcUeContextReleaseCommand(duUeCb);
13566    }
13567    freeAperDecodeUeContextReleaseCommand(f1apMsg);
13568    return ret;
13569 }
13570 /**************************************************************
13571  *
13572  * @brief Handles received F1AP message and sends back response
13573  *
13574  * @details
13575  *
13576  *    Function : F1APMsgHdlr
13577  *
13578  *    Functionality:
13579  *         - Decodes received F1AP control message
13580  *         - Prepares response message, encodes and sends to SCTP
13581  *
13582  * @params[in]
13583  * @return ROK     - success
13584  *         RFAILED - failure
13585  *
13586  * ****************************************************************/
13587 void F1APMsgHdlr(Buffer *mBuf)
13588 {
13589    int i =0;
13590    char *recvBuf =NULLP;
13591    MsgLen copyCnt =0;
13592    MsgLen recvBufLen =0;
13593    F1AP_PDU_t *f1apMsg =NULLP;
13594    asn_dec_rval_t rval; /* Decoder return value */
13595    F1AP_PDU_t f1apasnmsg ;
13596    DU_LOG("\nINFO  -->  F1AP : Received F1AP message buffer");
13597    ODU_PRINT_MSG(mBuf, 0,0);
13598
13599    /* Copy mBuf into char array to decode it */
13600    ODU_GET_MSG_LEN(mBuf, &recvBufLen);
13601    DU_ALLOC(recvBuf, (Size)recvBufLen);
13602
13603    if(recvBuf == NULLP)
13604    {
13605       DU_LOG("\nERROR  -->  F1AP : Memory allocation failed");
13606       return;
13607    }
13608    if(ODU_COPY_MSG_TO_FIX_BUF(mBuf, 0, recvBufLen, (Data *)recvBuf, &copyCnt) != ROK)
13609    {
13610       DU_LOG("\nERROR   -->  F1AP : Failed while copying %d", copyCnt);
13611       return;
13612    }
13613
13614    printf("\nDEBUG   -->  F1AP : Received flat buffer to be decoded : ");
13615    for(i=0; i< recvBufLen; i++)
13616    {
13617       printf("%x",recvBuf[i]);
13618    }
13619
13620    /* Decoding flat buffer into F1AP messsage */
13621    f1apMsg = &f1apasnmsg;
13622    memset(f1apMsg, 0, sizeof(F1AP_PDU_t));
13623
13624    rval = aper_decode(0, &asn_DEF_F1AP_PDU, (void **)&f1apMsg, recvBuf, recvBufLen, 0, 0);
13625    DU_FREE(recvBuf, (Size)recvBufLen);
13626
13627    if(rval.code == RC_FAIL || rval.code == RC_WMORE)
13628    {
13629       DU_LOG("\nERROR  -->  F1AP : ASN decode failed");
13630       return;
13631    }
13632    printf("\n");
13633    xer_fprint(stdout, &asn_DEF_F1AP_PDU, f1apMsg);
13634
13635    switch(f1apMsg->present)
13636    {
13637       case F1AP_PDU_PR_successfulOutcome:
13638          {
13639             switch(f1apMsg->choice.successfulOutcome->value.present)
13640             {
13641                case SuccessfulOutcome__value_PR_ResetAcknowledge:
13642                   {
13643                      DU_LOG("\nINFO   -->  F1AP : F1ResetAcknowledge is received successfully ");
13644                      break;
13645                   }
13646                case SuccessfulOutcome__value_PR_F1SetupResponse:
13647                   {
13648 #ifndef ODU_TEST_STUB
13649                      procF1SetupRsp(f1apMsg);
13650 #endif
13651                      break;
13652                   }
13653
13654                case SuccessfulOutcome__value_PR_GNBDUConfigurationUpdateAcknowledge:
13655                   {
13656                      procF1GNBDUCfgUpdAck(f1apMsg);
13657                      break;
13658                   }
13659
13660                default:
13661                   {
13662                      DU_LOG("\nERROR  -->  F1AP : Invalid type of SuccessfulOutcome__value_PR_ResetAcknowledge [%d]",\
13663                            f1apMsg->choice.successfulOutcome->value.present);
13664                      return;
13665                   }
13666             }/* End of switch(successfulOutcome) */
13667             free(f1apMsg->choice.successfulOutcome);
13668             break;
13669          }
13670       case F1AP_PDU_PR_initiatingMessage:
13671          {
13672             switch(f1apMsg->choice.initiatingMessage->value.present)
13673             {
13674                case InitiatingMessage__value_PR_Reset:
13675                   {
13676                      procF1ResetReq(f1apMsg);
13677                      break;
13678                   }
13679                case InitiatingMessage__value_PR_DLRRCMessageTransfer:
13680                   {
13681                      procF1DlRrcMsgTrans(f1apMsg);
13682                      break;
13683                   }
13684                case InitiatingMessage__value_PR_UEContextSetupRequest:
13685                   {
13686                      procF1UeContextSetupReq(f1apMsg);
13687                      break;
13688                   }
13689                case InitiatingMessage__value_PR_UEContextModificationRequest:
13690                   {
13691                      procF1UeContextModificationReq(f1apMsg);
13692                      break;
13693                   }
13694                case InitiatingMessage__value_PR_UEContextReleaseCommand:
13695                   {
13696                       procF1UeContextReleaseCommand(f1apMsg);
13697                       break;
13698                   }
13699                default:
13700                   {
13701                      DU_LOG("\nERROR  -->  F1AP : Invalid type of F1AP_PDU_PR_initiatingMessage [%d]",
13702                            f1apMsg->choice.initiatingMessage->value.present);
13703                      return;
13704                   }
13705             }/* End of switch(initiatingMessage) */
13706             free(f1apMsg->choice.initiatingMessage);
13707             break;
13708          }
13709
13710       default:
13711          {
13712             DU_LOG("\nERROR  -->  F1AP : Invalid type of f1apMsg->present [%d]",f1apMsg->present);
13713             return;
13714          }
13715          free(f1apMsg);
13716
13717    }/* End of switch(f1apMsg->present) */
13718
13719 } /* End of F1APMsgHdlr */
13720
13721 /**********************************************************************
13722   End of file
13723  **********************************************************************/